Fixed processors of Ore

src/main/java/gregtechmod/api/interfaces/IOreRecipeRegistrator.java

@@ -10,9 +10,9 @@ public interface IOreRecipeRegistrator {
 	/**
 	 * Contains a Code Fragment, used in the OrePrefix to register Recipes. Better than using a switch/case, like I did before.
 	 * @param aPrefix always != null
-	 * @param dictEntry TODO
+	 * @param entries TODO
 	 */
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry);
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries);
 	
 	/**
 	 * All checks from OrePrefixes and OreDictHandler classes was moved here, execute this method before executing processor

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBattery.java

@@ -20,8 +20,8 @@ public class ProcessingBattery implements IOreRecipeRegistrator {
 		OrePrefixes.battery.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials material = this.getMaterial(aPrefix, entry);
 			if (material == Materials.Lithium && this.isExecutable(aPrefix, material)) {
 				RecipeMaps.ASSEMBLING.factory().EUt(16).duration(12800)

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBlock.java

@@ -25,8 +25,8 @@ public class ProcessingBlock implements IOreRecipeRegistrator {
 		OrePrefixes.block.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) ) {
 				if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial) != null) 

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBolt.java

@@ -17,8 +17,8 @@ public class ProcessingBolt implements IOreRecipeRegistrator {
 		OrePrefixes.bolt.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && (aMaterial.mTypes & 2) != 0) {
 				RecipeMaps.LATHE.factory().EUt(4).duration(Math.max(aMaterial.getMass() / 8, 1))

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCell.java

@@ -28,8 +28,8 @@ public class ProcessingCell implements IOreRecipeRegistrator {
 		OrePrefixes.cell.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				if (aMaterial != Materials.Empty) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCellPlasma.java

@@ -22,11 +22,11 @@ public class ProcessingCellPlasma implements IOreRecipeRegistrator {
 		OrePrefixes.cellPlasma.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
 //		if (aMaterial == Materials.Empty) {
 //			GT_ModHandler.removeRecipeByOutput(aStack);
 //		}
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials material = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, material) && material != Materials.Empty) {
 				RecipeFactory<?> factory = RecipeMaps.PLASMA_FUELS.factory().EUt(1);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCircuit.java

@@ -22,8 +22,8 @@ public class ProcessingCircuit implements IOreRecipeRegistrator {
 	}
 
 	// FIXME removing all circuits crafing recipe, then register new
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				switch (aMaterial) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrafting.java

@@ -25,8 +25,8 @@ public class ProcessingCrafting implements IOreRecipeRegistrator {
 		OrePrefixes.crafting.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) {
 				if (entry.oreDictName.equals(GT_OreDictNames.craftingRedstoneTorch.toString())) {
 					RecipeMaps.ASSEMBLING.factory().EUt(16).duration(800).input(RecipeEntry.fromStacks(entry.ores, Match.DAMAGE)).input(OrePrefixes.plate, Materials.Iron, 1).output(GregTech_API.getGregTechComponent(30, 1)).buildAndRegister();

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushed.java

@@ -18,8 +18,8 @@ public class ProcessingCrushed implements IOreRecipeRegistrator {
 		OrePrefixes.crushed.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedCentrifuged.java

@@ -17,8 +17,8 @@ public class ProcessingCrushedCentrifuged implements IOreRecipeRegistrator {
 		OrePrefixes.crushedCentrifuged.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedPurified.java

@@ -18,8 +18,8 @@ public class ProcessingCrushedPurified implements IOreRecipeRegistrator {
 		OrePrefixes.crushedPurified.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java

@@ -32,8 +32,8 @@ public class ProcessingDust implements IOreRecipeRegistrator {
 		OrePrefixes.dust.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				RecipeFactory<?> factory;

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustImpure.java

@@ -24,8 +24,8 @@ public class ProcessingDustImpure implements IOreRecipeRegistrator {
 		OrePrefixes.dustRefined.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				Materials tByProduct = (Materials) GT_Utility.selectItemInList(aPrefix == OrePrefixes.dustPure ? 1 : (aPrefix == OrePrefixes.dustRefined ? 2 : 0), aMaterial, aMaterial.mOreByProducts);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustSmall.java

@@ -25,8 +25,8 @@ public class ProcessingDustSmall implements IOreRecipeRegistrator {
 		OrePrefixes.dustSmall.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				ItemStack ingot;

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustTiny.java

@@ -26,8 +26,8 @@ public class ProcessingDustTiny implements IOreRecipeRegistrator {
 		OrePrefixes.dustTiny.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				ItemStack ingot;

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDye.java

@@ -23,8 +23,8 @@ public class ProcessingDye implements IOreRecipeRegistrator {
 		OrePrefixes.dye.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				Dyes aDye = Dyes.get(entry.oreDictName);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGear.java

@@ -22,8 +22,8 @@ public class ProcessingGear implements IOreRecipeRegistrator {
 	}
 	
 	@Override
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java

@@ -29,8 +29,8 @@ public class ProcessingGem implements IOreRecipeRegistrator {
 		OrePrefixes.gem.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				if ((aMaterial == Materials.Charcoal || aMaterial == Materials.Coal) && GregTech_API.sRecipeFile.get(GT_ConfigCategories.Recipes.disabledrecipes, "torchesFromCoal", false)) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java

@@ -19,7 +19,7 @@ public class ProcessingIngot1 implements IOreRecipeRegistrator {
       OrePrefixes.ingot.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       if(aMaterial.mFuelPower > 0) {
          GregTech_API.sRecipeAdder.addFuel(GT_Utility.copyAmount(1L, new Object[]{aStack}), (ItemStack)null, aMaterial.mFuelPower, aMaterial.mFuelType);
       }

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot2.java

@@ -16,7 +16,7 @@ public class ProcessingIngot2 implements IOreRecipeRegistrator {
       OrePrefixes.ingotDouble.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       if(!aMaterial.contains(SubTag.NO_SMASHING)) {
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateDouble, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24);
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 4, 1), 24);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot3.java

@@ -16,7 +16,7 @@ public class ProcessingIngot3 implements IOreRecipeRegistrator {
       OrePrefixes.ingotTriple.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       if(!aMaterial.contains(SubTag.NO_SMASHING)) {
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateTriple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24);
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateDense, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 6, 1), 24);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot4.java

@@ -16,7 +16,7 @@ public class ProcessingIngot4 implements IOreRecipeRegistrator {
       OrePrefixes.ingotQuadruple.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       if(!aMaterial.contains(SubTag.NO_SMASHING)) {
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24);
       }

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot5.java

@@ -16,7 +16,7 @@ public class ProcessingIngot5 implements IOreRecipeRegistrator {
       OrePrefixes.ingotQuintuple.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       if(!aMaterial.contains(SubTag.NO_SMASHING)) {
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(5L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24);
       }

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngotHot.java

@@ -18,8 +18,8 @@ public class ProcessingIngotHot implements IOreRecipeRegistrator {
 		OrePrefixes.ingotHot.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				RecipeMaps.VACUUM_FREEZER.factory().EUt(120)

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingItem.java

@@ -18,8 +18,8 @@ public class ProcessingItem implements IOreRecipeRegistrator {
 		OrePrefixes.item.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) {
 				for (ItemStack aStack : entry.ores) { // TODO fix this shit
 					if (entry.oreDictName.equals("itemManganese")) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLeaves.java

@@ -15,8 +15,8 @@ public class ProcessingLeaves implements IOreRecipeRegistrator {
 		OrePrefixes.treeLeaves.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) {
 				for (ItemStack aStack : entry.ores) {
 					if (aStack.getItem() instanceof ItemBlock && GT_Mod.sWoodStackSize < aStack.getMaxStackSize()) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java

@@ -31,8 +31,8 @@ public class ProcessingLog implements IOreRecipeRegistrator {
 		OrePrefixes.log.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		List<Integer> logs = dictEntry.stream()
+		List<Integer> logs = entries.stream()
 			.map(ent -> ent.ores)
 			.flatMap(List::stream)
 			.map(s -> GT_Utility.stackToInt(s))
@@ -42,7 +42,7 @@ public class ProcessingLog implements IOreRecipeRegistrator {
 			RecipeHandler.scheduleSmeltingToRemove((in, out) -> out.isItemEqual(new ItemStack(Items.coal, 1, 1)) && logs.contains(GT_Utility.stackToInt(in)));
 		}
 		
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				RecipeEntry recEntry = RecipeEntry.fromStacks(entry.ores, Match.STRICT);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingNugget.java

@@ -22,8 +22,8 @@ public class ProcessingNugget implements IOreRecipeRegistrator {
 		OrePrefixes.nugget.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && (aMaterial.mTypes & 2) != 0) {
 				RecipeMaps.LATHE.factory().EUt(8)

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOre.java

@@ -12,8 +12,16 @@ import gregtechmod.api.interfaces.IOreRecipeRegistrator;
 import gregtechmod.api.util.GT_ModHandler;
 import gregtechmod.api.util.GT_OreDictUnificator;
 import gregtechmod.api.util.GT_Utility;
+import gregtechmod.api.util.OreDictEntry;
+
+import gregtechmod.common.RecipeHandler;
+import gregtechmod.common.recipe.RecipeEntry;
+import gregtechmod.common.recipe.RecipeEntry.Match;
+import gregtechmod.common.recipe.RecipeMaps;
 
 import java.util.Iterator;
+import java.util.List;
+
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
@@ -21,169 +29,350 @@ import net.minecraft.item.ItemStack;
 public class ProcessingOre implements IOreRecipeRegistrator {
 
 	public ProcessingOre() {
-      OrePrefixes.ore.add((IOreRecipeRegistrator)this);
+		OrePrefixes.ore.add(this);
-      OrePrefixes.oreEnd.add((IOreRecipeRegistrator)this);
+		OrePrefixes.oreEnd.add(this);
-      OrePrefixes.oreNether.add((IOreRecipeRegistrator)this);
+		OrePrefixes.oreNether.add(this);
-      OrePrefixes.oreDense.add((IOreRecipeRegistrator)this);
+		OrePrefixes.oreDense.add(this);
 	}
 
-   @SuppressWarnings("deprecation")
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+		for (OreDictEntry entry : entries) {
-      if(aStack.getItem() instanceof ItemBlock && aStack.getItem().getItemStackLimit() > GT_Mod.sOreStackSize) {
+			Materials aMaterial = this.getMaterial(aPrefix, entry);
+			if (this.isExecutable(aPrefix, aMaterial)) {
+				int mult = aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense ? 1 : 2;
+				
+				if (aMaterial == Materials.Oilsands) {
+					RecipeMaps.CENTRIFUGE.factory().EUt(5).setShaped(true)
+						.duration(1000 * mult)
+						.input(RecipeEntry.fromStacks(2, entry.ores, Match.STRICT))
+						.input(GT_Items.Cell_Empty.get(1))
+						.output(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oil, mult))
+						.output(new ItemStack(Blocks.sand, 1))
+						.buildAndRegister();
+				} else {
+					registerStandardOreRecipes(aPrefix, aMaterial, entry, mult);
+				}
+				
+				ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L);
+				ItemStack tSmeltInto = tIngot == null ? (aMaterial.contains(SubTag.SMELTING_TO_GEM)
+						? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial.mOreReplacement.mDirectSmelting,
+								GT_OreDictUnificator.get(OrePrefixes.crystal, aMaterial.mOreReplacement.mDirectSmelting,
+										GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial.mOreReplacement,
+												GT_OreDictUnificator.get(OrePrefixes.crystal, aMaterial.mOreReplacement, 1L), 1L),
+										1L),
+								1L)
+						: null) : tIngot;
+				
+				for (ItemStack aStack : entry.ores) {
+					if (aMaterial != Materials.Oilsands) 
+						defaultOreRegistration(aPrefix, aMaterial, aStack, mult, tSmeltInto);
+					if (aStack.getItem() instanceof ItemBlock && aStack.getMaxStackSize() > GT_Mod.sOreStackSize)
 						aStack.getItem().setMaxStackSize(GT_Mod.sOreStackSize);
 				}
-
+			}
-      if(aMaterial == Materials.Oilsands) {
+		}
-         GregTech_API.sRecipeAdder.addCentrifugeRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), 1, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Oil, aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense?1L:2L), new ItemStack(Blocks.sand, 1, 0), (ItemStack)null, (ItemStack)null, aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense?1000:2000);
-      } else {
-         registerStandardOreRecipes(aPrefix, aMaterial, GT_Utility.copyAmount(1L, new Object[]{aStack}), aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense?1:2);
 	}
 	
-   }
+	private static void defaultOreRegistration(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, int aMultiplier, ItemStack tSmeltInto) {
-
-   private static boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, int aMultiplier) {
-      if(aOreStack != null && aMaterial != null) {
 		GT_ModHandler.addValuableOre(aOreStack.copy(), aMaterial.mOreValue);
+		if (aMaterial.mBlastFurnaceRequired || aMaterial.mDirectSmelting.mBlastFurnaceRequired) {
+			RecipeHandler.scheduleSmeltingToRemove((in, out) -> in.isItemEqual(aOreStack));
+		} else {
+			GT_ModHandler.addSmeltingRecipe(aOreStack, GT_Utility.copyAmount(aMultiplier * aMaterial.mSmeltingMultiplier, tSmeltInto));
+		}
+	}
+	
+	private static boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, OreDictEntry entry, int aMultiplier) {
+		if (aMaterial != null) {
 			Materials tMaterial = aMaterial.mOreReplacement;
 			Materials tPrimaryByMaterial = null;
 			Materials tSecondaryByMaterial = null;
 			aMultiplier = Math.max(1, aMultiplier);
-         aOreStack = GT_Utility.copyAmount(1L, new Object[]{aOreStack});
+			ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L);
-         aOreStack.stackSize = 1;
+			ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, 1L);
-         ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial.mDirectSmelting, 1L);
+			ItemStack tSmeltInto = tIngot == null ? (aMaterial.contains(SubTag.SMELTING_TO_GEM)
-         ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, (Object)tMaterial, 1L);
+					? GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial.mDirectSmelting,
-         ItemStack tSmeltInto = tIngot == null?(aMaterial.contains(SubTag.SMELTING_TO_GEM)?GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial.mDirectSmelting, GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial.mDirectSmelting, GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, GT_OreDictUnificator.get(OrePrefixes.crystal, (Object)tMaterial, 1L), 1L), 1L), 1L):null):tIngot;
+							GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial.mDirectSmelting,
-         ItemStack tSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)tMaterial, 1L);
+									GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial,
+											GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial, 1L), 1L),
+									1L),
+							1L)
+					: null) : tIngot;
+			ItemStack tSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMaterial, 1L);
 			ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L);
 			ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L);
-         ItemStack tCrushed = GT_OreDictUnificator.get(OrePrefixes.crushed, (Object)tMaterial, (long)(aMaterial.mOreMultiplier * aMultiplier));
+			ItemStack tCrushed = GT_OreDictUnificator.get(OrePrefixes.crushed, tMaterial,
+					(aMaterial.mOreMultiplier * aMultiplier));
 			ItemStack tPrimaryByProduct = null;
 			ItemStack tPrimaryByProductSmall = null;
 			ItemStack tSecondaryByProduct = null;
 			ItemStack tSecondaryByProductSmall = null;
-         if(tCrushed == null) {
+			if (tCrushed == null) {
-            tCrushed = GT_OreDictUnificator.get(OrePrefixes.dustImpure, tMaterial, GT_Utility.copyAmount((long)(aMaterial.mOreMultiplier * aMultiplier), new Object[]{tCleaned, tDust, tGem}), (long)(aMaterial.mOreMultiplier * aMultiplier));
+				tCrushed = GT_OreDictUnificator.get(OrePrefixes.dustImpure, tMaterial,
+						GT_Utility.copyAmount((aMaterial.mOreMultiplier * aMultiplier),
+								new Object[] { tCleaned, tDust, tGem }),
+						(aMaterial.mOreMultiplier * aMultiplier));
 			}
 
 			Iterator<Materials> iterator = aMaterial.mOreByProducts.iterator();
 
-         while(iterator.hasNext()) {
+			while (iterator.hasNext()) {
-            Materials tMat = (Materials)iterator.next();
+				Materials tMat = (Materials) iterator.next();
-            if(tPrimaryByProduct == null) {
+				if (tPrimaryByProduct == null) {
 					tPrimaryByMaterial = tMat;
-               tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, (Object)tMat, 1L);
+					tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L);
-               tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)tMat, 1L);
+					tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L);
-               if(tPrimaryByProductSmall == null) {
+					if (tPrimaryByProductSmall == null) {
-                  tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)tMat, 2L), 2L);
+						tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat,
+								GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L);
 					}
 				}
 
-            if(tSecondaryByProduct == null || tSecondaryByMaterial == tPrimaryByMaterial) {
+				if (tSecondaryByProduct == null || tSecondaryByMaterial == tPrimaryByMaterial) {
 					tSecondaryByMaterial = tMat;
-               tSecondaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, (Object)tMat, 1L);
+					tSecondaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L);
-               tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)tMat, 1L);
+					tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L);
-               if(tSecondaryByProductSmall == null) {
+					if (tSecondaryByProductSmall == null) {
-                  tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)tMat, 2L), 2L);
+						tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat,
+								GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L);
 					}
 				}
 			}
 
-         if(tPrimaryByMaterial == null) {
+			if (tPrimaryByMaterial == null) {
 				tPrimaryByMaterial = tMaterial;
 			}
 
-         if(tPrimaryByProduct == null) {
+			if (tPrimaryByProduct == null) {
 				tPrimaryByProduct = tDust;
 			}
 
-         if(tPrimaryByProductSmall == null) {
+			if (tPrimaryByProductSmall == null) {
 				tPrimaryByProductSmall = tSmall;
 			}
 
-         if(tSecondaryByMaterial == null) {
+			if (tSecondaryByMaterial == null) {
 				tSecondaryByMaterial = tPrimaryByMaterial;
 			}
 
-         if(tSecondaryByProduct == null) {
+			if (tSecondaryByProduct == null) {
 				tSecondaryByProduct = tPrimaryByProduct;
 			}
 
-         if(tSecondaryByProductSmall == null) {
+			if (tSecondaryByProductSmall == null) {
 				tSecondaryByProductSmall = tPrimaryByProductSmall;
 			}
 			
-         if(tSmeltInto != null) {
+			RecipeEntry ingr = RecipeEntry.fromStacks(entry.ores, Match.STRICT);
-            if(!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) {
+			
-               GT_ModHandler.addInductionSmelterRecipe(aOreStack, new ItemStack(Blocks.sand, 1), GT_Utility.mul((long)(aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT)?1:2) * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag_Rich.get(1L, new Object[0]), 300 * aMultiplier, 10 * aMultiplier);
+			if (tSmeltInto != null) {
-               GT_ModHandler.addInductionSmelterRecipe(aOreStack, GT_Items.TE_Slag_Rich.get((long)aMultiplier, new Object[0]), GT_Utility.mul((long)(aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT)?2:3) * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag.get((long)aMultiplier, new Object[0]), 300 * aMultiplier, 95);
+				if (!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) {
-               GT_ModHandler.addSmeltingRecipe(aOreStack, GT_Utility.copyAmount((long)(aMultiplier * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}));
+					GT_ModHandler.addInductionSmelterRecipe(entry.ores.get(0), new ItemStack(Blocks.sand, 1),
-            } else {
+							GT_Utility.mul((aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT) ? 1 : 2) * aMaterial.mSmeltingMultiplier), tSmeltInto),
-               GT_ModHandler.removeFurnaceSmelting(aOreStack);
+							GT_Items.TE_Slag_Rich.get(1), 300 * aMultiplier, 10 * aMultiplier);
+					GT_ModHandler.addInductionSmelterRecipe(entry.ores.get(0),
+							GT_Items.TE_Slag_Rich.get(aMultiplier),
+							GT_Utility.mul((aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT) ? 2 : 3) * aMaterial.mSmeltingMultiplier), tSmeltInto),
+							GT_Items.TE_Slag.get(aMultiplier), 300 * aMultiplier, 95);
 				}
 				
-            if(aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) {
+				if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) {
-               GregTech_API.sRecipeAdder.addBlastRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.Calcite, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag.get(1L, new Object[]{GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.DarkAsh, 1L)}), tSmeltInto.stackSize * 500, 120, 1500);
+					RecipeMaps.BLAST_FURNANCE.factory()
-            } else if(aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) {
+						.minTemperature(1500)
-               GregTech_API.sRecipeAdder.addBlastRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.Calcite, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag.get(1L, new Object[]{GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.DarkAsh, 1L)}), tSmeltInto.stackSize * 500, 120, 1500);
+						.EUt(120).duration(tSmeltInto.stackSize * 500)
+						.input(ingr)
+						.input(OrePrefixes.dust, Materials.Calcite, aMultiplier)
+						.output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto))
+						.output(GT_Items.TE_Slag.get(1L, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 1L)))
+						.buildAndRegister();
+				} else if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) {
+					RecipeMaps.BLAST_FURNANCE.factory()
+						.minTemperature(1500)
+						.EUt(120).duration(tSmeltInto.stackSize * 500)
+						.input(ingr)
+						.input(OrePrefixes.dust, Materials.Calcite, aMultiplier)
+						.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto))
+						.output(GT_Items.TE_Slag.get(1L, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 1L)))
+						.buildAndRegister();
 				}
 			}
 
-         if(tCrushed != null) {
+			if (tCrushed != null) {
-            if(GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammercrushing, aPrefix.get(aMaterial), true)) {
+				final ItemStack copy = GT_Utility.copy(tCrushed);
-               GT_ModHandler.addCraftingRecipe(GT_Utility.copy(tCrushed), new Object[]{"T", "O", Character.valueOf('T'), GT_ToolDictNames.craftingToolHardHammer, Character.valueOf('O'), aPrefix.get(aMaterial)});
+				if (GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammercrushing, aPrefix.get(aMaterial), true)) {
+					RecipeHandler.executeOnFinish(() -> GT_ModHandler.addCraftingRecipe(copy, new Object[] { "T", "O", 'T', GT_ToolDictNames.craftingToolHardHammer, 'O', aPrefix.get(aMaterial) }));
 				}
 
-            GregTech_API.sRecipeAdder.addForgeHammerRecipe(aOreStack, GT_Utility.copy(tCrushed), 16, 10);
+				RecipeMaps.HAMMER.factory().EUt(10) .duration(16).input(ingr).output(tCrushed).buildAndRegister();
-            GT_ModHandler.addPulverisationRecipe(aOreStack, GT_Utility.mul(2L, tCrushed), tMaterial.contains(SubTag.PULVERIZING_CINNABAR)?GT_OreDictUnificator.get(OrePrefixes.crystal, Materials.Cinnabar, GT_Utility.copyAmount(1L, new Object[]{tPrimaryByProduct}), 1L):GT_Utility.copyAmount(1L, new Object[]{tPrimaryByProduct}), tPrimaryByProduct == null?0:tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier, true);
+				RecipeHandler.scheduleIC2RecipeToRemove(GT_ModHandler.getMaceratorRecipeList(), (in, out) -> in.matches(entry.ores.get(0)));
-            if(tGem != null) {
+				final ItemStack out1 =tMaterial.contains(SubTag.PULVERIZING_CINNABAR) ? GT_OreDictUnificator.get(OrePrefixes.crystal, Materials.Cinnabar, GT_Utility.copyAmount(1, tPrimaryByProduct), 1L) : GT_Utility.copyAmount(1, tPrimaryByProduct);
-               GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_Items.Cell_Water.get((long)aMultiplier, new Object[0]), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), tSmall == null?GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}):GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 6), new Object[]{tSmall}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+				final int val = tPrimaryByProduct == null ? 0 : tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier;
-               if(tSmall == null && tMaterial.contains(SubTag.WASHING_MERCURY)) {
+				RecipeHandler.executeOnFinish(() -> GT_ModHandler.addPulverisationRecipe(entry, 1, GT_Utility.mul(2L, copy), out1, val));
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+				if (tGem != null) {
+					RecipeMaps.GRINDER.factory()
+						.EUt(120).duration(100)
+						.input(ingr)
+						.input(GT_ModHandler.getWater(1000 * aMultiplier))
+						.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+						.output(tSmall == null
+									? GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned)
+									: GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 6, tSmall))
+						.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+						.buildAndRegister();
+					
+					if (tMaterial.contains(SubTag.WASHING_MERCURY)) {
+						if (tSmall == null) {
+							RecipeMaps.GRINDER.factory()
+								.EUt(120).duration(100).setShaped(true)
+								.input(ingr)
+								.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier))
+								.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+								.output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tCleaned))
+								.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+								.output(GT_Items.Cell_Empty.get(aMultiplier))
+								.buildAndRegister();
 						}
 						
-               if(tMaterial.contains(SubTag.WASHING_MERCURY)) {
+						RecipeMaps.GRINDER.factory()
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tDust}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+							.output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tDust))
+							.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 
-               if(tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) {
+
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), tSmall == null?GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mOreMultiplier), new Object[]{tCleaned}):GT_Utility.mul((long)(aMultiplier * 6 * aMaterial.mOreMultiplier), new Object[]{tSmall}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+					if (tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) {
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+							.output(tSmall == null
+									? GT_Utility.mul((aMultiplier * 2 * aMaterial.mOreMultiplier), tCleaned)
+									: GT_Utility.mul((aMultiplier * 6 * aMaterial.mOreMultiplier), tSmall))
+							.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProduct))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 					
-               if(tSmall == null && tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+					if (tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						if (tSmall == null) {
+							RecipeMaps.GRINDER.factory()
+								.EUt(120).duration(100).setShaped(true)
+								.input(ingr)
+								.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier))
+								.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+								.output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tCleaned))
+								.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+								.output(GT_Items.Cell_Empty.get(aMultiplier))
+								.buildAndRegister();
 						}
 						
-               if(tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+						RecipeMaps.GRINDER.factory()
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tDust}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+							.output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tDust))
+							.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 
-               if(tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+					if (tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), tSmall == null?GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mOreMultiplier), new Object[]{tCleaned}):GT_Utility.mul((long)(aMultiplier * 6 * aMaterial.mOreMultiplier), new Object[]{tSmall}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem))
+							.output(tSmall == null
+									? GT_Utility.mul((aMultiplier * 2 * aMaterial.mOreMultiplier), tCleaned)
+									: GT_Utility.mul((aMultiplier * 6 * aMaterial.mOreMultiplier), tSmall))
+							.output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProduct))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 				} else {
-               GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_Items.Cell_Water.get((long)aMultiplier, new Object[0]), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+					RecipeMaps.GRINDER.factory()
-               if(tMaterial.contains(SubTag.WASHING_MERCURY)) {
+						.EUt(120).duration(100)
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 3), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						.input(ingr)
+						.input(GT_ModHandler.getWater(1000 * aMultiplier))
+						.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned))
+						.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+						.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall))
+						.buildAndRegister();
+					if (tMaterial.contains(SubTag.WASHING_MERCURY)) {
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 3, tCleaned))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 
-               if(tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) {
+					if (tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) {
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProduct))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 
-               if(tSecondaryByMaterial.contains(SubTag.WASHING_MERCURY)) {
+					if (tSecondaryByMaterial.contains(SubTag.WASHING_MERCURY)) {
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProduct))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 
-               if(tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+					if (tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 3), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 3, tCleaned))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 
-               if(tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+					if (tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+						RecipeMaps.GRINDER.factory()
-               }
+							.EUt(120).duration(100).setShaped(true)
-
+							.input(ingr)
-               if(tSecondaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier))
-                  GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0]));
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProduct))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
+					} else if (tSecondaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) {
+						RecipeMaps.GRINDER.factory()
+							.EUt(120).duration(100).setShaped(true)
+							.input(ingr)
+							.input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall))
+							.output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProduct))
+							.output(GT_Items.Cell_Empty.get(aMultiplier))
+							.buildAndRegister();
 					}
 				}
 			}

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOreSmelting.java

@@ -1,56 +1,80 @@
 package gregtechmod.loaders.oreprocessing;
 
-import gregtechmod.api.GregTech_API;
+import java.util.List;
+
+import gregtechmod.api.enums.Materials;
 import gregtechmod.api.enums.OrePrefixes;
 import gregtechmod.api.enums.SubTag;
 import gregtechmod.api.interfaces.IOreRecipeRegistrator;
 import gregtechmod.api.util.GT_ModHandler;
 import gregtechmod.api.util.GT_OreDictUnificator;
 import gregtechmod.api.util.GT_Utility;
+import gregtechmod.api.util.OreDictEntry;
+
+import gregtechmod.common.RecipeHandler;
+import gregtechmod.common.recipe.RecipeEntry;
+import gregtechmod.common.recipe.RecipeMaps;
+import gregtechmod.common.recipe.RecipeEntry.Match;
+
 import net.minecraft.item.ItemStack;
 
 public class ProcessingOreSmelting implements IOreRecipeRegistrator {
 
-   private final OrePrefixes[] mSmeltingPrefixes;
+	private final static OrePrefixes[] mSmeltingPrefixes = new OrePrefixes[] {
-
+			OrePrefixes.crushed, OrePrefixes.crushedPurified, OrePrefixes.crushedCentrifuged, OrePrefixes.dustImpure, OrePrefixes.dustPure, OrePrefixes.dustRefined
+	};
 
 	public ProcessingOreSmelting() {
-      this.mSmeltingPrefixes = new OrePrefixes[]{OrePrefixes.crushed, OrePrefixes.crushedPurified, OrePrefixes.crushedCentrifuged, OrePrefixes.dustImpure, OrePrefixes.dustPure, OrePrefixes.dustRefined};
+		for (OrePrefixes tPrefix : mSmeltingPrefixes) {
-      OrePrefixes[] arr$ = this.mSmeltingPrefixes;
+			tPrefix.add(this);
-      int len$ = arr$.length;
+		}
-
-      for(int i$ = 0; i$ < len$; ++i$) {
-         OrePrefixes tPrefix = arr$[i$];
-         tPrefix.add((IOreRecipeRegistrator)this);
 	}
 
-   }
+	@Override
-
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+		for (OreDictEntry entry : entries) {
-      if(!aMaterial.contains(SubTag.NO_SMELTING)) {
+			Materials aMaterial = this.getMaterial(aPrefix, entry);
-         if(!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) {
+			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMELTING)) {
-            switch(aPrefix) {
+				if (!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) {
+					switch (aPrefix) {
 					case crushed:
 					case crushedPurified:
 					case crushedCentrifuged:
-               ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial.mDirectSmelting, 10L);
+						ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mDirectSmelting, 10L);
-               if(tStack == null) {
+						if (tStack == null)
-                  tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial.mDirectSmelting, 1L);
+							tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L);
-               }
 
+						for (ItemStack aStack : entry.ores)
 							GT_ModHandler.addSmeltingRecipe(aStack, tStack);
 						break;
 					default:
-               GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial.mDirectSmelting, 1L));
+						for (ItemStack aStack : entry.ores)
-            }
+							GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L));
-         } else {
-            GT_ModHandler.removeFurnaceSmelting(aStack);
-            GregTech_API.sRecipeAdder.addBlastRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), (ItemStack)null, aMaterial.mBlastFurnaceTemp > 1750?GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial, 1L), 1L):GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial, 1L), (ItemStack)null, Math.max(aMaterial.getMass() / 4, 1) * aMaterial.mBlastFurnaceTemp, 120, aMaterial.mBlastFurnaceTemp);
-            if(aMaterial.mBlastFurnaceTemp <= 1000) {
-               GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial, 1L), aMaterial.mBlastFurnaceTemp * 2);
-            }
 					}
+				} else if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) {
+					for (final ItemStack aStack : entry.ores)
+						RecipeHandler.scheduleSmeltingToRemove((in, out) -> in.isItemEqual(aStack));
+					
+					ItemStack out = aMaterial.mBlastFurnaceTemp > 1750
+							? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), 1L)
+							: GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L);
+					
+					if (out == null) {
+						System.err.println(aMaterial);
 					}
 					
+					RecipeMaps.BLAST_FURNANCE.factory()
+						.minTemperature(aMaterial.mBlastFurnaceTemp)
+						.EUt(120).duration(Math.max(aMaterial.getMass() / 4, 1) * aMaterial.mBlastFurnaceTemp)
+						.input(RecipeEntry.fromStacks(entry.ores, Match.STRICT))
+						.output(out)
+						.buildAndRegister();
+					if (aMaterial.mBlastFurnaceTemp <= 1000) {
+						for (ItemStack aStack : entry.ores)
+							GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1, aStack), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), aMaterial.mBlastFurnaceTemp * 2);
+					}
+				}
+			}
+		}
 	}
 }

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlank.java

@@ -24,8 +24,8 @@ public class ProcessingPlank implements IOreRecipeRegistrator {
 		OrePrefixes.plank.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				if (aMaterial == Materials.Wood) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate1.java

@@ -19,7 +19,7 @@ public class ProcessingPlate1 implements IOreRecipeRegistrator {
       OrePrefixes.plate.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       GT_ModHandler.removeRecipeByOutput(aStack);
       GT_ModHandler.removeRecipe(new ItemStack[]{aStack});
       if(aMaterial.mFuelPower > 0) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate2.java

@@ -16,7 +16,7 @@ public class ProcessingPlate2 implements IOreRecipeRegistrator {
       OrePrefixes.plateDouble.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       GT_ModHandler.removeRecipeByOutput(aStack);
       if(!aMaterial.contains(SubTag.NO_SMASHING)) {
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate3.java

@@ -16,7 +16,7 @@ public class ProcessingPlate3 implements IOreRecipeRegistrator {
       OrePrefixes.plateTriple.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       GT_ModHandler.removeRecipeByOutput(aStack);
       if(!aMaterial.contains(SubTag.NO_SMASHING)) {
          GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateDense, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 3, 1), 24);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate4.java

@@ -16,7 +16,7 @@ public class ProcessingPlate4 implements IOreRecipeRegistrator {
       OrePrefixes.plateQuadruple.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       GT_ModHandler.removeRecipeByOutput(aStack);
       GregTech_API.sRecipeAdder.addCNCRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.gearGt, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 32);
       if(!aMaterial.contains(SubTag.NO_SMASHING) && GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammerquadrupleplate, OrePrefixes.plate.get(aMaterial), true)) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate5.java

@@ -15,7 +15,7 @@ public class ProcessingPlate5 implements IOreRecipeRegistrator {
       OrePrefixes.plateQuintuple.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       GT_ModHandler.removeRecipeByOutput(aStack);
       if(!aMaterial.contains(SubTag.NO_SMASHING) && GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammerquintupleplate, OrePrefixes.plate.get(aMaterial), true)) {
          GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), new Object[]{"I", "B", "H", Character.valueOf('H'), GT_ToolDictNames.craftingToolHardHammer, Character.valueOf('I'), OrePrefixes.plateQuadruple.get(aMaterial), Character.valueOf('B'), OrePrefixes.plate.get(aMaterial)});

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate9.java

@@ -10,7 +10,7 @@ public class ProcessingPlate9 implements IOreRecipeRegistrator {
       OrePrefixes.plateDense.add((IOreRecipeRegistrator)this);
    }
 
-   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+   public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
       GT_ModHandler.removeRecipeByOutput(aStack);
    }
 }

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlateAlloy.java

@@ -19,8 +19,8 @@ public class ProcessingPlateAlloy implements IOreRecipeRegistrator {
 		OrePrefixes.plateAlloy.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) {
 				if (entry.oreDictName.equals("plateAlloyCarbon")) {
 					RecipeMaps.ASSEMBLING.factory().EUt(8).duration(6400)

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRecycling.java

@@ -24,9 +24,9 @@ public class ProcessingRecycling implements IOreRecipeRegistrator {
 		}
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
 		if (aPrefix != OrePrefixes.dust && aPrefix != OrePrefixes.crushed) {
-			for (OreDictEntry entry : dictEntry) {
+			for (OreDictEntry entry : entries) {
 				Materials aMaterial = this.getMaterial(aPrefix, entry);
 				if (this.isExecutable(aPrefix, aMaterial) && aMaterial != Materials.Blaze) {
 					for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRing.java

@@ -21,8 +21,8 @@ public class ProcessingRing implements IOreRecipeRegistrator {
 		OrePrefixes.ring.add((IOreRecipeRegistrator) this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSand.java

@@ -24,8 +24,8 @@ public class ProcessingSand implements IOreRecipeRegistrator {
 		OrePrefixes.sand.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) {
 				if (entry.oreDictName.equals("sandCracked")) {
 					RecipeMaps.CENTRIFUGE.factory().EUt(5).duration(2500)

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSaplings.java

@@ -19,8 +19,8 @@ public class ProcessingSaplings implements IOreRecipeRegistrator {
 		OrePrefixes.treeSapling.add((IOreRecipeRegistrator) this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				GT_ModHandler.addPulverisationRecipe(entry, 1, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L), null, 0);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingShaping.java

@@ -41,8 +41,8 @@ public class ProcessingShaping implements IOreRecipeRegistrator {
 		OrePrefixes.ingot.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry e : dictEntry) {
+		for (OreDictEntry e : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, e);
 			if (this.isExecutable(aPrefix, aMaterial) && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null && !aMaterial.contains(SubTag.NO_SMELTING)) {
 				int tAmount = (int)(aPrefix.mMaterialAmount / GregTech_API.MATERIAL_UNIT);

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSlab.java

@@ -25,8 +25,8 @@ public class ProcessingSlab implements IOreRecipeRegistrator {
 		OrePrefixes.slab.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials mat = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, mat) && mat == Materials.Wood) {
 				RecipeMaps.CANINNING.factory().EUt(4).duration(200).input(GT_ModHandler.getRCItem("fluid.creosote.bucket", 1L)).input(RecipeEntry.fromStacks(entry.ores, Match.DAMAGE)).outputs(GT_ModHandler.getRCItem("part.tie.wood", 1L), new ItemStack(Items.bucket, 1)).buildAndRegister();

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStick.java

@@ -17,8 +17,8 @@ public class ProcessingStick implements IOreRecipeRegistrator {
 		OrePrefixes.stick.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && (aMaterial.mTypes & 2) != 0) {
 				RecipeMaps.CUTTING.factory().EUt(4).duration(aMaterial.getMass() * 2).input(RecipeEntry.fromStacks(entry.ores, Match.DAMAGE)).output(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L)).buildAndRegister();

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStone.java

@@ -25,8 +25,8 @@ public class ProcessingStone implements IOreRecipeRegistrator {
 	}
 
 	@Override
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial)) {
 				switch (aMaterial) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneCobble.java

@@ -21,8 +21,8 @@ public class ProcessingStoneCobble implements IOreRecipeRegistrator {
 	}
 
 	@Override
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) { 
+		for (OreDictEntry entry : entries) { 
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry)))
 				RecipeMaps.ASSEMBLING.factory().EUt(1).duration(400).input(OrePrefixes.stick, Materials.Wood).input(RecipeEntry.fromStacks(entry.ores, Match.STRICT)).output(new ItemStack(Blocks.lever, 1)).buildAndRegister();
 		}

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneVarious.java

@@ -26,8 +26,8 @@ public class ProcessingStoneVarious implements IOreRecipeRegistrator {
 		OrePrefixes.stoneSmooth.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadAxe.java

@@ -20,8 +20,8 @@ public class ProcessingToolHeadAxe implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadAxe.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadFile.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadFile implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadFile.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHammer.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadHammer implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadHammer.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHoe.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadHoe implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadHoe.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadPickaxe.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadPickaxe implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadPickaxe.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSaw.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadSaw implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadSaw.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadShovel.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadShovel implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadShovel.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry); 
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSword.java

@@ -19,8 +19,8 @@ public class ProcessingToolHeadSword implements IOreRecipeRegistrator {
 		OrePrefixes.toolHeadSword.add(this);
 	}
 
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			Materials aMaterial = this.getMaterial(aPrefix, entry);
 			if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) {
 				for (ItemStack aStack : entry.ores) {

src/main/java/gregtechmod/loaders/oreprocessing/ProcessingWax.java

@@ -15,8 +15,8 @@ public class ProcessingWax implements IOreRecipeRegistrator {
 	}
 
 	@Override
-	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> dictEntry) {
+	public void registerOre(OrePrefixes aPrefix, List<OreDictEntry> entries) {
-		for (OreDictEntry entry : dictEntry) {
+		for (OreDictEntry entry : entries) {
 			if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry)) && entry.oreDictName.equals("waxMagical")) {
 				RecipeMaps.MAGIC_FUELS.factory().EUt(6).duration(1).input(RecipeEntry.fromStacks(1, entry.ores)).buildAndRegister();
 			}

src/main/java/gregtechmod/loaders/preload/GT_OreProcessingLoader.java

@@ -90,8 +90,8 @@ public class GT_OreProcessingLoader implements Runnable {
       new ProcessingLeaves();
       new ProcessingLog();
       new ProcessingNugget();
-//      new ProcessingOre();
+      new ProcessingOre();
-//      new ProcessingOreSmelting();
+      new ProcessingOreSmelting();
       new ProcessingPlank();
 //      new ProcessingPlate1();
 //      new ProcessingPlate2();