Automatic synchronization

36 files changed, 2887 insertions, 1345 deletions

diff --git a/src/Java/gtPlusPlus/xmod/gregtech/HANDLER_GT.java b/src/Java/gtPlusPlus/xmod/gregtech/HANDLER_GT.java
index 169683d251..7acd76882e 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/HANDLER_GT.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/HANDLER_GT.java
@@ -1,5 +1,6 @@
 package gtPlusPlus.xmod.gregtech;
 
+import static gtPlusPlus.core.recipe.common.CI.bits;
 import static gtPlusPlus.core.util.minecraft.MaterialUtils.getMaterialName;
 
 import java.util.ArrayList;
@@ -7,23 +8,30 @@ import java.util.Collection;
 import java.util.List;
 
 import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
+import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
-import gregtech.api.interfaces.IToolStats;
+import gregtech.api.enums.OrePrefixes;
 import gregtech.api.items.GT_MetaGenerated_Tool;
 import gregtech.api.util.GT_Config;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_ModHandler.RecipeBits;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
-import gregtech.api.util.Recipe_GT;
+import gregtech.api.util.GT_Utility;
 import gregtech.common.items.GT_MetaGenerated_Tool_01;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.Pair;
 import gtPlusPlus.australia.gen.gt.WorldGen_GT_Australia;
 import gtPlusPlus.core.handler.COMPAT_HANDLER;
 import gtPlusPlus.core.handler.OldCircuitHandler;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.CORE.ConfigSwitches;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
-import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.core.util.reflect.AddGregtechRecipe;
 import gtPlusPlus.everglades.gen.gt.WorldGen_GT;
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
 import gtPlusPlus.xmod.gregtech.api.util.GTPP_Config;
@@ -31,7 +39,12 @@ import gtPlusPlus.xmod.gregtech.api.world.GTPP_Worldgen;
 import gtPlusPlus.xmod.gregtech.common.StaticFields59;
 import gtPlusPlus.xmod.gregtech.common.blocks.fluid.GregtechFluidHandler;
 import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
-import gtPlusPlus.xmod.gregtech.loaders.*;
+import gtPlusPlus.xmod.gregtech.loaders.Gregtech_Blocks;
+import gtPlusPlus.xmod.gregtech.loaders.ProcessingAngelGrinder;
+import gtPlusPlus.xmod.gregtech.loaders.ProcessingElectricButcherKnife;
+import gtPlusPlus.xmod.gregtech.loaders.ProcessingElectricLighter;
+import gtPlusPlus.xmod.gregtech.loaders.ProcessingElectricSnips;
+import gtPlusPlus.xmod.gregtech.loaders.ProcessingToolHeadChoocher;
 import gtPlusPlus.xmod.gregtech.recipes.RecipesToRemove;
 import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechConduits;
 import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechNitroDieselFix;
@@ -41,24 +54,24 @@ import net.minecraft.item.ItemStack;
 public class HANDLER_GT {
 
 	public static GT_Config mMaterialProperties = null;
-	
+
 	public static GTPP_Config sCustomWorldgenFile = null;
 	public static final List<WorldGen_GT> sWorldgenListEverglades = new ArrayList<WorldGen_GT>();
 	public static final List<WorldGen_GT_Australia> sWorldgenListAustralia = new ArrayList<WorldGen_GT_Australia>();
 	public static final List<GTPP_Worldgen> sCustomWorldgenList = new ArrayList<GTPP_Worldgen>();
 
 	public static void preInit(){
-		
+
 		if (mMaterialProperties != null){
 			GT_Materials.init(mMaterialProperties);
 		}
-		
+
 		if (ConfigSwitches.enableOldGTcircuits && !CORE.GTNH){
 			OldCircuitHandler.preInit();
 		}
-		
+
 		GregtechFluidHandler.run();		
-		
+
 	}
 
 	public static void init(){
@@ -68,7 +81,7 @@ public class HANDLER_GT {
 
 		//Add Custom Pipes, Wires and Cables.
 		GregtechConduits.run();
-		
+
 		//Register Tile Entities
 		COMPAT_HANDLER.registerGregtechMachines();
 
@@ -81,7 +94,7 @@ public class HANDLER_GT {
 		if (ConfigSwitches.enableOldGTcircuits && !CORE.GTNH){
 			OldCircuitHandler.init();
 		}
-		
+
 		//Generates recipes for all gregtech smelting and alloy smelting combinations.
 		//RecipeGen_BlastSmelterGT.generateRecipes();
 		//new RecipeGen_BlastSmelterGT_Ex();
@@ -89,7 +102,7 @@ public class HANDLER_GT {
 	}
 
 	public static void postInit(){
-		
+
 		//Only loads if the config option is true (default: true)
 		if (CORE.ConfigSwitches.enableSkookumChoochers){
 			new ProcessingToolHeadChoocher().run();
@@ -98,7 +111,7 @@ public class HANDLER_GT {
 		new ProcessingElectricSnips().run();
 		new ProcessingElectricButcherKnife().run();
 		new ProcessingElectricLighter().run();
-		
+
 		if (CORE.ConfigSwitches.enableNitroFix){
 			GregtechNitroDieselFix.run();
 		}
@@ -106,18 +119,309 @@ public class HANDLER_GT {
 		if (ConfigSwitches.enableOldGTcircuits && !CORE.GTNH){
 			OldCircuitHandler.postInit();
 		}
-		
-		
+
+
 		//Register some custom recipe maps for any enabled multiblocks.
 		//MultiblockRecipeMapHandler.run();
 	}
-	
+
 	public static void onLoadComplete(FMLLoadCompleteEvent event) {
 		removeCrudeTurbineRotors();
-		cleanAssemblyLineRecipeMap();
+		cleanAssemblyLineRecipeMap();		
+		if (ConfigSwitches.enableHarderRecipesForHighTierCasings) {
+	        removeOldHighTierCasingRecipes();		    
+		}		
 		RecipesToRemove.go();
+		convertPyroToCokeOven();
+	}
+
+	private static void convertPyroToCokeOven() {
+        int aCount = 0;
+	    for (GT_Recipe g : GT_Recipe.GT_Recipe_Map.sPyrolyseRecipes.mRecipeList) {
+	        if (AddGregtechRecipe.importPyroRecipe(g)) {
+	            aCount++;
+	        }
+	    }
+	    Logger.INFO("Converted "+aCount+" Pyrolyse recipes into Industrial Coke Oven recipes.");
+	    
+    }
+
+    private static GT_Recipe replaceItemInRecipeWithAnother(GT_Recipe aRecipe, ItemStack aExisting, ItemStack aNewItem) {
+	    ItemStack[] aInputItemsCopy = aRecipe.mInputs;
+	    String aOutputName = ItemUtils.getItemName(aRecipe.mOutputs[0]);
+	    boolean aDidChange = false;
+        Logger.INFO("Attempting to Modify Recipe for "+aOutputName);
+	    for (int i=0;i<aRecipe.mInputs.length;i++) {
+	        ItemStack aCurrentInputSlot = aRecipe.mInputs[i];
+	        if (aCurrentInputSlot != null) {
+	            if (GT_Utility.areStacksEqual(aCurrentInputSlot, aExisting, true)) {
+	                aInputItemsCopy[i] = ItemUtils.getSimpleStack(aNewItem, aCurrentInputSlot.stackSize);
+	                aDidChange = true;
+	            }
+	        }
+	    }
+	    if (aDidChange) {
+	        aRecipe.mInputs = aInputItemsCopy;
+	        Logger.INFO("Modifed Recipe for "+aOutputName);
+	        return aRecipe;
+	    }
+	    else {
+            Logger.INFO("Failed to Modify Recipe for "+aOutputName);
+	        return aRecipe;
+	    }
 	}
 	
+	private static void updateRecipeMap(GT_Recipe aOld, GT_Recipe aNew, GT_Recipe_Map aMap) {
+	    RecipeUtils.removeGtRecipe(aOld, aMap);
+	    RecipeUtils.addGtRecipe(aNew, aMap);
+	    Logger.INFO("Updating recipe map: "+aMap.mNEIName);
+	    Logger.INFO("Removed Recipe with hash: "+aOld.hashCode());
+	    Logger.INFO("Added Recipe with hash: "+aNew.hashCode());
+        
+	}
+
+	private static void removeOldHighTierCasingRecipes() {
+
+        Logger.INFO("Trying to appropriately retier GT Machine Hulls/Casings from LuV+");
+		final Object aHardCasingsTest = StaticFields59.getFieldFromGregtechProxy("mHardMachineCasings");
+
+		boolean aHardCasings = aHardCasingsTest != null ? (boolean) aHardCasingsTest : false;
+		
+        Logger.INFO("Are Hard casings/hulls enabled within GT? "+(aHardCasingsTest == null ? "Version does not support config option" : aHardCasings));
+
+		// Static objects to save memory		
+		ItemStack aCasing_LUV = CI.machineCasing_LuV;
+		ItemStack aCasing_ZPM = CI.machineCasing_ZPM;
+		ItemStack aCasing_UV = CI.machineCasing_UV;
+		ItemStack aCasing_MAX = CI.machineCasing_MAX;
+
+		ItemStack aHull_LUV = CI.machineHull_LuV;
+		ItemStack aHull_ZPM = CI.machineHull_ZPM;
+		ItemStack aHull_UV = CI.machineHull_UV;
+		ItemStack aHull_MAX = CI.machineHull_MAX;
+
+        int aTier_LUV = 5;
+        int aTier_ZPM = 6;
+        int aTier_UV = 7;
+        //int aTier_MAX = 8;
+		
+
+		ItemStack[] aCasings = new ItemStack[] {aCasing_LUV, aCasing_ZPM, aCasing_UV, aCasing_MAX};
+		ItemStack[] aHulls = new ItemStack[] {aHull_LUV, aHull_ZPM, aHull_UV, aHull_MAX};
+
+		// Remove Hand Crafting Recipes
+
+		// Casings
+        Logger.INFO("Removing shaped crafting for Casings.");
+		RecipeUtils.removeRecipeByOutput(aCasing_LUV);
+		RecipeUtils.removeRecipeByOutput(aCasing_ZPM);
+		RecipeUtils.removeRecipeByOutput(aCasing_UV);
+		//RecipeUtils.removeRecipeByOutput(aCasing_MAX);	
+
+		// Hulls
+        Logger.INFO("Removing shaped crafting for Hulls.");
+		RecipeUtils.removeRecipeByOutput(aHull_LUV);
+		RecipeUtils.removeRecipeByOutput(aHull_ZPM);
+		RecipeUtils.removeRecipeByOutput(aHull_UV);
+		//RecipeUtils.removeRecipeByOutput(aHull_MAX);		
+
+		// Modify Assembler Recipes
+        Logger.INFO("Attempting to modify existing Assembly recipes for Casings & Hulls, this should provide best compatibility.");
+        int aUpdateCount = 0;
+        
+        AutoMap<Pair<GT_Recipe, GT_Recipe>> aDataToModify = new AutoMap<Pair<GT_Recipe, GT_Recipe>>();
+        
+        
+		Outer :for (final GT_Recipe r : GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.mRecipeList) {		    
+		    
+		    if (r != null && r.mOutputs != null && r.mOutputs.length > 0) {
+
+		        GT_Recipe aOldRecipeCopy = r;
+		        GT_Recipe aNewRecipe = r.copy();
+
+		        //Casings
+		        Inner : for (ItemStack aCasingObject : aCasings) {
+		            if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aCasingObject)) {
+		                String aOutputName = ItemUtils.getItemName(aOldRecipeCopy.mOutputs[0]);
+		                Logger.INFO("Attempting to Modify Assembly Recipe for "+aOutputName);		                
+		                //Replace Chrome
+		                if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aCasing_LUV)) {
+		                    aNewRecipe = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateChrome", 1), ELEMENT.getInstance().SELENIUM.getPlate(1));
+		                    aDataToModify.put(new Pair<GT_Recipe, GT_Recipe>(r, aNewRecipe));
+		                    aUpdateCount++;
+		                    continue Outer;
+		                }
+		                //Replace Iridium
+		                else if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aCasing_ZPM)) {
+		                    aNewRecipe = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateIridium", 1), CI.getPlate(aTier_ZPM, 1));
+		                    aDataToModify.put(new Pair<GT_Recipe, GT_Recipe>(r, aNewRecipe));
+                            aUpdateCount++;
+		                    continue Outer;
+		                }
+		                //Replace Osmium
+		                else if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aCasing_UV)) {
+		                    aNewRecipe = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateOsmium", 1), CI.getPlate(aTier_UV, 1));
+		                    aDataToModify.put(new Pair<GT_Recipe, GT_Recipe>(r, aNewRecipe));
+                            aUpdateCount++;
+		                    continue Outer;
+		                }
+		                //else if (aOldRecipeCopy.mOutputs[0] == aCasing_LUV) {
+		                //	aOldRecipeCopy = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateChrome", 8), CI.getPlate(aTier_MAX, 8));
+		                //  updateRecipeMap(aOldRecipeCopy, aNewRecipe, GT_Recipe.GT_Recipe_Map.sAssemblerRecipes);
+		                //}
+		                else {
+		                    continue Inner;
+		                }
+		            }					
+		        }
+
+		        //Hulls
+		        Inner : for (ItemStack aHullObject : aHulls) {
+		            if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aHullObject)) {
+                        String aOutputName = ItemUtils.getItemName(aOldRecipeCopy.mOutputs[0]);
+                        Logger.INFO("Attempting to Modify Assembly Recipe for "+aOutputName);   						
+		                //Replace Chrome
+		                if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aHull_LUV)) {
+		                    aNewRecipe = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateChrome", 1), ELEMENT.getInstance().SELENIUM.getPlate(1));
+		                    aDataToModify.put(new Pair<GT_Recipe, GT_Recipe>(r, aNewRecipe));
+                            aUpdateCount++;
+		                    continue Outer;
+		                }
+		                //Replace Iridium
+		                else if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aHull_ZPM)) {
+		                    aNewRecipe = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateIridium", 1), CI.getPlate(aTier_ZPM, 1));
+		                    aDataToModify.put(new Pair<GT_Recipe, GT_Recipe>(r, aNewRecipe));
+                            aUpdateCount++;
+		                    continue Outer;
+		                }
+		                //Replace Osmium
+		                else if (GT_Utility.areStacksEqual(aOldRecipeCopy.mOutputs[0], aHull_UV)) {
+		                    aNewRecipe = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateOsmium", 1), CI.getPlate(aTier_UV, 1));
+		                    aDataToModify.put(new Pair<GT_Recipe, GT_Recipe>(r, aNewRecipe));
+                            aUpdateCount++;
+		                    continue Outer;
+		                }
+		                //else if (aOldRecipeCopy.mOutputs[0] == aHull_LUV) {
+		                //	aOldRecipeCopy = replaceItemInRecipeWithAnother(aOldRecipeCopy, ItemUtils.getItemStackOfAmountFromOreDict("plateChrome", 8), CI.getPlate(aTier_MAX, 8));
+		                //  updateRecipeMap(aOldRecipeCopy, aNewRecipe, GT_Recipe.GT_Recipe_Map.sAssemblerRecipes);
+		                //}
+		                else {
+		                    continue Inner;
+		                }
+		            }					
+		        }
+		    }
+		}
+
+        Logger.INFO("There is "+aUpdateCount+" recipes flagged for update.");
+
+        if (aUpdateCount > 0) {            
+            for (Pair<GT_Recipe, GT_Recipe> g : aDataToModify) {
+                updateRecipeMap(g.getKey(), g.getValue(), GT_Recipe.GT_Recipe_Map.sAssemblerRecipes);                
+            }    
+            Logger.INFO("Modified "+aUpdateCount+" recipes.");       
+        }
+        
+
+
+        Logger.INFO("Adding new Shaped recipes for Casings.");
+        GT_ModHandler.addCraftingRecipe(ItemList.Casing_LuV.get(1), bits, new Object[]{"PPP", "PwP", "PPP", 'P', ELEMENT.getInstance().SELENIUM.getPlate(1)});
+        GT_ModHandler.addCraftingRecipe(ItemList.Casing_ZPM.get(1), bits, new Object[]{"PPP", "PwP", "PPP", 'P', CI.getPlate(aTier_ZPM, 1)});
+        GT_ModHandler.addCraftingRecipe(ItemList.Casing_UV.get(1), bits, new Object[]{"PPP", "PwP", "PPP", 'P', CI.getPlate(aTier_UV, 1)});
+        //GT_ModHandler.addCraftingRecipe(ItemList.Casing_MAX.get(1), bits, new Object[]{"PPP", "PwP", "PPP", 'P', OrePrefixes.plate.get(Materials.Neutronium)});
+
+		if (!aHardCasings) {
+	        Logger.INFO("Adding new easy Shaped recipes for Hulls.");
+	        GT_ModHandler.addCraftingRecipe(ItemList.Hull_LuV.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED, new Object[]{"CMC", 'M', ItemList.Casing_LuV, 'C',
+	                        OrePrefixes.cableGt01.get(Materials.VanadiumGallium)});
+	        GT_ModHandler.addCraftingRecipe(ItemList.Hull_ZPM.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED,
+	                new Object[]{"CMC", 'M', ItemList.Casing_ZPM, 'C', OrePrefixes.cableGt01.get(Materials.Naquadah)});
+	        GT_ModHandler.addCraftingRecipe(ItemList.Hull_UV.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED, new Object[]{"CMC", 'M', ItemList.Casing_UV, 'C',
+	                        OrePrefixes.wireGt04.get(Materials.NaquadahAlloy)});
+	        /*GT_ModHandler.addCraftingRecipe(ItemList.Hull_MAX.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED, new Object[]{"CMC", 'M', ItemList.Casing_MAX, 'C',
+	                        OrePrefixes.wireGt01.get(Materials.Superconductor)});*/
+		}
+		else {
+	        Logger.INFO("Adding new hard Shaped recipes for Hulls.");
+	        GT_ModHandler.addCraftingRecipe(ItemList.Hull_LuV.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED,
+	                new Object[]{"PHP", "CMC", 'M', ItemList.Casing_LuV, 'C',
+	                        OrePrefixes.cableGt01.get(Materials.VanadiumGallium), 'H',
+	                        ELEMENT.getInstance().SELENIUM.getPlate(1), 'P', OrePrefixes.plate.get(Materials.Plastic)});
+	        GT_ModHandler.addCraftingRecipe(ItemList.Hull_ZPM.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED,
+	                new Object[]{"PHP", "CMC", 'M', ItemList.Casing_ZPM, 'C',
+	                        OrePrefixes.cableGt01.get(Materials.Naquadah), 'H',
+	                        CI.getPlate(aTier_ZPM, 1), 'P',
+	                        OrePrefixes.plate.get(Materials.Polytetrafluoroethylene)});
+	        GT_ModHandler.addCraftingRecipe(ItemList.Hull_UV.get(1),
+	                RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED,
+	                new Object[]{"PHP", "CMC", 'M', ItemList.Casing_UV, 'C',
+	                        OrePrefixes.wireGt04.get(Materials.NaquadahAlloy), 'H',
+	                        CI.getPlate(aTier_UV, 1), 'P',
+	                        OrePrefixes.plate.get(Materials.Polytetrafluoroethylene)});
+            /*GT_ModHandler.addCraftingRecipe(ItemList.Hull_MAX.get(1),
+                    RecipeBits.NOT_REMOVABLE | RecipeBits.BUFFERED,
+                    new Object[]{"PHP", "CMC", 'M', ItemList.Casing_MAX, 'C',
+                            OrePrefixes.wireGt01.get(Materials.Superconductor), 'H',
+                            OrePrefixes.plate.get(Materials.Neutronium), 'P',
+                            OrePrefixes.plate.get(Materials.Polytetrafluoroethylene)});*/
+		}
+
+
+
+		//Casings
+		
+        /*GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Chrome, 8L),
+        		ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]),
+        		ItemList.Casing_LuV.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 8L),
+        		ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]),
+        		ItemList.Casing_ZPM.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Osmium, 8L),
+        		ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]),
+        		ItemList.Casing_UV.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 8L),
+        		ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]),
+        		ItemList.Casing_MAX.get(1), 50, 16);	*/	
+
+
+
+		//Hulls
+
+		//Hard Hulls
+        /*GT_Values.RA.addAssemblerRecipe(
+        		GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.VanadiumGallium, 2L),
+        		ItemList.Casing_LuV.get(1), Materials.Plastic.getMolten(288L),
+        		ItemList.Hull_LuV.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 2L),
+        		ItemList.Casing_ZPM.get(1), Materials.Polytetrafluoroethylene.getMolten(288L),
+        		ItemList.Hull_ZPM.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.NaquadahAlloy, 2L),
+        		ItemList.Casing_UV.get(1), Materials.Polytetrafluoroethylene.getMolten(288L),
+        		ItemList.Hull_UV.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(
+        		GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Superconductor, 2L),
+        		ItemList.Casing_MAX.get(1), Materials.Polytetrafluoroethylene.getMolten(288L),
+        		ItemList.Hull_MAX.get(1), 50, 16);*/
+
+		//Easy Hulls
+        /*GT_Values.RA.addAssemblerRecipe(
+        		GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.VanadiumGallium, 2L),
+        		ItemList.Casing_LuV.get(1), ItemList.Hull_LuV.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 2L),
+        		ItemList.Casing_ZPM.get(1), ItemList.Hull_ZPM.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.NaquadahAlloy, 2L),
+        		ItemList.Casing_UV.get(1), ItemList.Hull_UV.get(1), 50, 16);
+        GT_Values.RA.addAssemblerRecipe(
+        		GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Superconductor, 2L),
+        		ItemList.Casing_MAX.get(1), ItemList.Hull_MAX.get(1), 50, 16);*/
+		}
+
 	private static int removeCrudeTurbineRotors() {
 		int aRemoved = 0;
 		int CUT = CORE.turbineCutoffBase;
@@ -156,7 +460,7 @@ public class HANDLER_GT {
 								else {
 									break outputs;
 								}
-								
+
 							}
 							else {
 								continue outputs;
@@ -172,12 +476,12 @@ public class HANDLER_GT {
 				}
 			}
 		}
-		
+
 		Logger.INFO("Removed "+aRemoved+" useless Turbines.");
-		
+
 		return aRemoved;
 	}
-	
+
 	/**
 	 * Should clean out any invalid Assembly Line recipes, if the map actually exists.
 	 * Prevents NPE's being thrown by GT's AL handler. (Fucking Annoying)
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
index 68fe121081..933ec227ba 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
@@ -313,6 +313,10 @@ public enum GregtechItemList implements GregtechItemContainer {
 	//Larger Turbines
 	Large_Steam_Turbine, Large_HPSteam_Turbine, 
 	Casing_Turbine_Shaft, Casing_Turbine_LP, Casing_Turbine_HP,
+	
+	//Large Vacuum Furnace
+	Casing_Vacuum_Furnace,
+	Controller_Vacuum_Furnace,
 
 
 
@@ -427,6 +431,7 @@ public enum GregtechItemList implements GregtechItemContainer {
 
 	//Debug machine
 	Pollution_Creator, 
+	Garbage_Collector_Debug_Machine,
 
 
 	//Basically is an automatic Cauldron
@@ -582,9 +587,14 @@ public enum GregtechItemList implements GregtechItemContainer {
 	 */
 
 	//Fluid Void Covers
-	Cover_Overflow_ULV, Cover_Overflow_LV, Cover_Overflow_MV, Cover_Overflow_HV, Cover_Overflow_EV, Cover_Overflow_IV,    
-	
+	Cover_Overflow_ULV, Cover_Overflow_LV, Cover_Overflow_MV, Cover_Overflow_HV, Cover_Overflow_EV, Cover_Overflow_IV, 
 	
+	//Fake Hull Covers
+	FakeMachineCasingPlate_ULV, FakeMachineCasingPlate_LV,
+	FakeMachineCasingPlate_MV, FakeMachineCasingPlate_HV,
+	FakeMachineCasingPlate_EV, FakeMachineCasingPlate_IV,
+	FakeMachineCasingPlate_LuV, FakeMachineCasingPlate_ZPM,
+	FakeMachineCasingPlate_UV, FakeMachineCasingPlate_MAX,
 	
 
 	//----------------------------------------------------------------------------
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_Hatch_Muffler_Advanced.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_Hatch_Muffler_Advanced.java
new file mode 100644
index 0000000000..721fe053ae
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_Hatch_Muffler_Advanced.java
@@ -0,0 +1,51 @@
+package gtPlusPlus.xmod.gregtech.api.gui;
+
+import gregtech.api.gui.GT_ContainerMetaTile_Machine;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gtPlusPlus.core.slots.SlotAirFilter;
+import net.minecraft.entity.player.InventoryPlayer;
+
+
+public class CONTAINER_Hatch_Muffler_Advanced extends GT_ContainerMetaTile_Machine {
+
+	public long maxEU = 0;
+	public long storedEU = 0;
+
+	public CONTAINER_Hatch_Muffler_Advanced(final InventoryPlayer aInventoryPlayer, final IGregTechTileEntity aTileEntity) {
+		super(aInventoryPlayer, aTileEntity);
+	}
+
+	public CONTAINER_Hatch_Muffler_Advanced(final InventoryPlayer aInventoryPlayer, final IGregTechTileEntity aTileEntity, final boolean bindInventory) {
+		super(aInventoryPlayer, aTileEntity, bindInventory);
+	}
+
+	@Override
+	public void addSlots(final InventoryPlayer aInventoryPlayer) {
+		this.addSlotToContainer(new SlotAirFilter(this.mTileEntity, 1, 80, 35));
+	}
+
+	@Override
+	public int getSlotCount() {
+		return 1;
+	}
+
+	@Override
+	public int getShiftClickSlotCount() {
+		return 1;
+	}
+
+	@Override
+	public void updateProgressBar(final int id, final int value) {
+		super.updateProgressBar(id, value);
+		switch (id) {		
+		default:
+			break;
+		}
+	}
+
+	@Override
+	public void detectAndSendChanges() {
+		super.detectAndSendChanges();		
+	}
+
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_SuperChest.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_SuperChest.java
index 503b36e157..dcab57c380 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_SuperChest.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_SuperChest.java
@@ -4,21 +4,16 @@ import java.util.Iterator;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.ICrafting;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-
 import gregtech.api.gui.GT_ContainerMetaTile_Machine;
 import gregtech.api.gui.GT_Slot_Output;
 import gregtech.api.gui.GT_Slot_Render;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-
 import gtPlusPlus.core.slots.SlotLockedInput;
-import gtPlusPlus.core.util.reflect.ReflectionUtils;
 import gtPlusPlus.xmod.gregtech.common.tileentities.storage.GT_MetaTileEntity_TieredChest;
 import gtPlusPlus.xmod.gregtech.common.tileentities.storage.shelving.GT4Entity_Shelf_Large;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.ICrafting;
+import net.minecraft.item.ItemStack;
 
 public class CONTAINER_SuperChest extends GT_ContainerMetaTile_Machine {
 	
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/GUI_Hatch_Muffler_Advanced.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/GUI_Hatch_Muffler_Advanced.java
new file mode 100644
index 0000000000..4b998f6487
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/GUI_Hatch_Muffler_Advanced.java
@@ -0,0 +1,46 @@
+package gtPlusPlus.xmod.gregtech.api.gui;
+
+
+import gregtech.api.gui.GT_GUIContainerMetaTile_Machine;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gtPlusPlus.core.lib.CORE;
+import net.minecraft.entity.player.InventoryPlayer;
+
+public class GUI_Hatch_Muffler_Advanced extends GT_GUIContainerMetaTile_Machine {
+
+	String mName = "";
+	long maxPower = 0;
+	long storedPower = 0;
+
+	public GUI_Hatch_Muffler_Advanced(final InventoryPlayer aInventoryPlayer, final IGregTechTileEntity aTileEntity, final String aName, final String aTextureFile) {
+		super(new CONTAINER_Hatch_Muffler_Advanced(aInventoryPlayer, aTileEntity), CORE.RES_PATH_GUI + (aTextureFile == null ? "MultiblockDisplay" : aTextureFile));
+		this.mName = aName;
+	}
+
+	@Override
+	protected void drawGuiContainerForegroundLayer(final int par1, final int par2) {
+		this.fontRendererObj.drawString(this.mName, 8, 8, 16448255);
+		/*
+		 * ReflectionUtils.setField(this.fontRendererObj, "underlineStyle", true);
+		 * ReflectionUtils.setField(this.fontRendererObj, "italicStyle", true);
+		 * ReflectionUtils.setField(this.fontRendererObj, "boldStyle", true); boolean
+		 * isBold = ReflectionUtils.getField(this.fontRendererObj, "boldStyle");
+		 * this.fontRendererObj.drawString("Insert Air Filters - Bold: "+isBold, 8, 18,
+		 * 16448255);
+		 */
+		if (this.mContainer != null) {
+			//this.maxPower = ((CONTAINER_TreeFarmer)this.mContainer).maxEU;
+			//this.storedPower = ((CONTAINER_TreeFarmer)this.mContainer).storedEU;			
+		}
+	}
+
+	@Override
+	protected void drawGuiContainerBackgroundLayer(final float par1, final int par2, final int par3) {
+		super.drawGuiContainerBackgroundLayer(par1, par2, par3);
+		//this.maxPower = ((CONTAINER_TreeFarmer)this.mContainer).maxEU;
+		//this.storedPower = ((CONTAINER_TreeFarmer)this.mContainer).storedEU;
+		final int x = (this.width - this.xSize) / 2;
+		final int y = (this.height - this.ySize) / 2;
+		this.drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize);
+	}
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java b/src/Java/gtPlusPlus/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java
index 721facd8d0..e4a15d34ea 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java
@@ -117,7 +117,7 @@ public interface IGregtech_RecipeAdder {
 	 * @param aEUt			= EU per tick needed for heating up (must be >= 0)
 	 * @return true if the Recipe got added, otherwise false.
 	 */
-	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack, int aChance, int aDuration, int aEUt);
+	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack, int[] aChance, int aDuration, int aEUt);
 
 	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, int aChance, int aDuration, int aEUt, int aSpecialValue);
 	
@@ -134,7 +134,7 @@ public interface IGregtech_RecipeAdder {
 	 * @param aSpecialValue			= Stores the Required Temp for the Recipe
 	 * @return true if the Recipe got added, otherwise false.
 	 */
-	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack, int aChance, int aDuration, int aEUt, int aSpecialValue);
+	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack, int[] aChance, int aDuration, int aEUt, int aSpecialValue);
 
 
 	public boolean addLFTRRecipe(ItemStack aInput1, ItemStack aInput2, ItemStack aOutput1, int aDuration, int aEUt);
@@ -252,4 +252,9 @@ public interface IGregtech_RecipeAdder {
      * @param aSpecial = EU needed for heating the Reactor up (must be >= 0)
      */		
 	public boolean addFusionReactorRecipe(ItemStack aInputStackA, ItemStack aInputStackB, FluidStack plasma, int aOutputChance, int aFusionDurationInTicks, int aEu, int aSpecial);
+
+	
+    boolean addVacuumFurnaceRecipe(ItemStack aInput1, ItemStack aInput2,
+            FluidStack aFluidInput, FluidStack aFluidOutput, ItemStack aOutput1,
+            ItemStack aOutput2, int aDuration, int aEUt, int aLevel);
 }
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler_Adv.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler_Adv.java
index 2832941bdd..5fa1fc8aba 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler_Adv.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler_Adv.java
@@ -1,11 +1,19 @@
 package gtPlusPlus.xmod.gregtech.api.metatileentity.implementations;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_Config;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.item.general.ItemAirFilter;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.minecraft.gregtech.PollutionUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_Hatch_Muffler_Advanced;
+import gtPlusPlus.xmod.gregtech.api.gui.GUI_Hatch_Muffler_Advanced;
 import gtPlusPlus.xmod.gregtech.common.StaticFields59;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 import net.minecraft.entity.player.EntityPlayer;
@@ -13,11 +21,11 @@ import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
-import gregtech.api.interfaces.ITexture;
-import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 
 public class GT_MetaTileEntity_Hatch_Muffler_Adv extends GT_MetaTileEntity_Hatch_Muffler {
 
+	protected int SLOT_FILTER = 0;
+	
 	@Override
 	public void onConfigLoad(GT_Config aConfig) {
 		super.onConfigLoad(aConfig);
@@ -38,27 +46,30 @@ public class GT_MetaTileEntity_Hatch_Muffler_Adv extends GT_MetaTileEntity_Hatch
 	
 	public GT_MetaTileEntity_Hatch_Muffler_Adv(int aID, String aName, String aNameRegional, int aTier) {
 		super(aID, aName, aNameRegional, aTier);
+		ReflectionUtils.setField(this, "mInventory", new ItemStack[1]);
 	}
 
 	public GT_MetaTileEntity_Hatch_Muffler_Adv(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
 		super(aName, aTier, aDescription, aTextures);
+		ReflectionUtils.setField(this, "mInventory", new ItemStack[1]);
 	}
 
 	public GT_MetaTileEntity_Hatch_Muffler_Adv(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
 		super(aName, aTier, aDescription[0], aTextures);
+		ReflectionUtils.setField(this, "mInventory", new ItemStack[1]);
 	}
 
 	public String[] getDescription() {
-		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
-		
-		String[] mDescArray = StaticFields59.getDescriptionArray(this);
-			
-		String[] desc = new String[mDescArray.length + 4];
+		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {		
+		String[] mDescArray = StaticFields59.getDescriptionArray(this);			
+		String[] desc = new String[mDescArray.length + 6];
 		System.arraycopy(mDescArray, 0, desc, 0, mDescArray.length);
 		desc[mDescArray.length] = "DO NOT OBSTRUCT THE OUTPUT!";
-		desc[mDescArray.length + 1] = "Requires extra Air on the exhaust face";
-		desc[mDescArray.length + 2] = "Reduces Pollution to " + this.calculatePollutionReduction(100) + "%";
-		desc[mDescArray.length + 3] = "Recovers " + (105 - this.calculatePollutionReduction(100))
+		desc[mDescArray.length + 1] = "Requires 3 Air on the exhaust face";
+		desc[mDescArray.length + 2] = "Requires Air Filters";
+		desc[mDescArray.length + 3] = "Mufflers require T2 Filters from IV-"+GT_Values.VN[9];
+		desc[mDescArray.length + 4] = "Reduces Pollution to " + this.calculatePollutionReductionForTooltip(100) + "%";
+		desc[mDescArray.length + 5] = "Recovers " + (105 - this.calculatePollutionReductionForTooltip(100))
 				+ "% of CO2/CO/SO2";
 		return desc;
 		}
@@ -76,7 +87,7 @@ public class GT_MetaTileEntity_Hatch_Muffler_Adv extends GT_MetaTileEntity_Hatch
 	}
 
 	public boolean isValidSlot(int aIndex) {
-		return false;
+		return aIndex == SLOT_FILTER;
 	}
 
 	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
@@ -88,24 +99,33 @@ public class GT_MetaTileEntity_Hatch_Muffler_Adv extends GT_MetaTileEntity_Hatch
 			EntityPlayer aPlayer) {
 		if (aBaseMetaTileEntity.isClientSide())
 			return true;
-		//aBaseMetaTileEntity.openGUI(aPlayer);
+		aBaseMetaTileEntity.openGUI(aPlayer);
 		return true;
 	}
 
-	@Override
-	public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory,
-			IGregTechTileEntity aBaseMetaTileEntity) {
-		return null;
+
+
+	public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new CONTAINER_Hatch_Muffler_Advanced(aPlayerInventory, aBaseMetaTileEntity);
 	}
 
-	@Override
-	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory,
-			IGregTechTileEntity aBaseMetaTileEntity) {
-		return null;
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GUI_Hatch_Muffler_Advanced(aPlayerInventory, aBaseMetaTileEntity, "Advanced Muffler", "machine_Charger.png");
+	}
+	
+	private boolean airCheck() {
+		if (
+		this.getBaseMetaTileEntity().getAirAtSide(this.getBaseMetaTileEntity().getFrontFacing()) &&
+		this.getBaseMetaTileEntity().getAirAtSideAndDistance(this.getBaseMetaTileEntity().getFrontFacing(), 1) &&
+		this.getBaseMetaTileEntity().getAirAtSideAndDistance(this.getBaseMetaTileEntity().getFrontFacing(), 2)
+		) {
+			return true;
+		}		
+		return false;
 	}
 
 	public boolean polluteEnvironment() {		
-		if (this.getBaseMetaTileEntity().getAirAtSide(this.getBaseMetaTileEntity().getFrontFacing()) && this.getBaseMetaTileEntity().getAirAtSideAndDistance(this.getBaseMetaTileEntity().getFrontFacing(), 1)) {
+		if (airCheck() && damageAirFilter()) {
 			int aEmission = this.calculatePollutionReduction(10000);
 			PollutionUtils.addPollution(this.getBaseMetaTileEntity(), aEmission);			
 			//Logger.INFO("Outputting "+aEmission+"gbl");
@@ -116,30 +136,134 @@ public class GT_MetaTileEntity_Hatch_Muffler_Adv extends GT_MetaTileEntity_Hatch
 		}
 	}
 
+
+	public int calculatePollutionReductionForTooltip(int aPollution) {
+		return (int) (aPollution * Math.pow(0.64D, (double) (this.mTier - 1)));	
+	}
+	
 	public int calculatePollutionReduction(int aPollution) {
-		return (int) ((double) aPollution * Math.pow(0.64D, (double) (this.mTier - 1)));
+		double aVal1 = aPollution * Math.pow(0.64D, (double) (this.mTier - 1));
+		int aVal2 = (int) aVal1;	
+		if (!hasValidFilter()) {
+			aVal2 = (int) ((double) aPollution * Math.pow(0.7D, (double) (this.mTier - 1)));;
+		}		
+		return aVal2;
 	}
 
 	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
-		return true;
+		if (aIndex == this.SLOT_FILTER) {
+			if (isAirFilter(aStack)) {
+				return true;
+			}
+		}		
+		return false;
+	}
+	
+	private ItemStack getInventoryStack() {
+		if (this.mInventory != null && this.mInventory.length > 0) {
+			if (this.mInventory.length-1 >= this.SLOT_FILTER) {
+				return this.mInventory[this.SLOT_FILTER];
+			}
+		}		
+		return null;
+	}
+	
+	private void breakAirFilter() {
+		if (this.mInventory != null && this.mInventory.length > 0) {
+			if (this.mInventory.length-1 >= this.SLOT_FILTER) {
+				Logger.INFO("Breaking Filter");
+				this.mInventory[this.SLOT_FILTER] = null;
+			}
+		}
 	}
 	
 	public boolean hasValidFilter() {
-		return false;
+		return isAirFilter(getInventoryStack());
 	}
 
-	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {		
+
+		//Logger.INFO("A1");	
+		
 		super.onPostTick(aBaseMetaTileEntity, aTick);
-		String aParticleName;
-		if (hasValidFilter()) {
-			aParticleName = "cloud";
-		} else {
-			aParticleName = "smoke";
+		
+		//Logger.INFO("A2");	
+		
+		String aParticleName;		
+		if ((aTick % 2) == 0){
+			aParticleName = "cloud";			
 		}
-		if (aBaseMetaTileEntity.isClientSide() && this.getBaseMetaTileEntity().isActive()) {
-			this.pollutionParticles(this.getBaseMetaTileEntity().getWorld(), aParticleName);
+		else {
+			aParticleName = "smoke";			
+		}	
+
+		//Logger.INFO("A3");	
+		
+		if (aBaseMetaTileEntity.isClientSide()) {
+			//Logger.INFO("B1");	
+			if (this.getBaseMetaTileEntity().isActive()) {
+				//Logger.INFO("C1");	
+				this.pollutionParticles(this.getBaseMetaTileEntity().getWorld(), aParticleName);
+			}
+			//return;
+		}
+		else {
+			//Logger.INFO("B2");	
+			if (this.getInventoryStack() == null) {
+				//Logger.INFO("D1");	
+				//Logger.INFO("Empty - "+this.mInventory.length);
+			}
+			else {
+				//Logger.INFO("D2");	
+				Logger.INFO("Has Item");			
+			}	
 		}
+		//Logger.INFO("A4");	
+		
+		
+		
+	}
+	
+	public boolean isAirFilter(ItemStack filter){
+		if (filter == null) {
+			return false;
+		}		
+		if (filter.getItem() instanceof ItemAirFilter){
+			
+			if (this.mTier < 5) {
+				return true;
+			}
+			else {
+				if (filter.getItemDamage() == 1) {
+					return true;
+				}
+			}
+		}		
+		return false;
+	}
 
+	public boolean damageAirFilter(){		
+		ItemStack filter = getInventoryStack();
+		if (filter == null) {
+			return false;
+		}		
+
+		if (isAirFilter(filter)){
+			long currentUse = ItemAirFilter.getFilterDamage(filter);
+			Logger.INFO("Filter Damage: "+currentUse);
+			//Remove broken Filter
+			if ((filter.getItemDamage() == 0 && currentUse >= 50-1) || (filter.getItemDamage() == 1 && currentUse >= 2500-1)){	
+				breakAirFilter();
+				return false;				
+			}	
+			else {
+				//Do Damage
+				ItemAirFilter.setFilterDamage(filter, currentUse+1);
+				Logger.INFO("Filter Damage now: "+currentUse);
+				return true;
+			}			
+		}		
+		return false;
 	}
 
 	public void pollutionParticles(World aWorld, String name) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Plasma.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Plasma.java
index bed80d8d13..b395bbbabe 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Plasma.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Plasma.java
@@ -8,7 +8,6 @@ import gregtech.api.enums.Textures.BlockIcons;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.api.objects.data.AutoMap;
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java
index e352712138..0e1ef0e47e 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java
@@ -1,10 +1,10 @@
 package gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base;
 
-import static gtPlusPlus.core.lib.CORE.ConfigSwitches.requireControlCores;
 import static gtPlusPlus.core.util.data.ArrayUtils.removeNulls;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
@@ -48,6 +48,7 @@ import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.LoadedMods;
 import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.core.util.reflect.ReflectionUtils;
 import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_MultiMachine;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
@@ -539,26 +540,149 @@ GT_MetaTileEntity_MultiBlockBase {
 	}
 
 
+	/*
+	 * public boolean checkRecipeGeneric( ItemStack[] aItemInputs, FluidStack[]
+	 * aFluidInputs, int aMaxParallelRecipes, int aEUPercent, int
+	 * aSpeedBonusPercent, int aOutputChanceRoll, GT_Recipe aRecipe) { // Based on
+	 * the Processing Array. A bit overkill, but very flexible.
+	 * 
+	 * 
+	 * if (this.doesMachineBoostOutput()) { log("Boosting."); return
+	 * checkRecipeBoostedOutputs(aItemInputs, aFluidInputs, aMaxParallelRecipes,
+	 * aEUPercent, aSpeedBonusPercent, aOutputChanceRoll, aRecipe); }
+	 * 
+	 * 
+	 * //Control Core to control the Multiblocks behaviour. int aControlCoreTier =
+	 * getControlCoreTier();
+	 * 
+	 * //If no core, return false; if (aControlCoreTier > 0) {
+	 * log("Control core found."); }
+	 * 
+	 * 
+	 * // Reset outputs and progress stats this.mEUt = 0; this.mMaxProgresstime = 0;
+	 * this.mOutputItems = new ItemStack[]{}; this.mOutputFluids = new
+	 * FluidStack[]{};
+	 * 
+	 * long tVoltage = getMaxInputVoltage(); byte tTier = (byte) Math.max(1,
+	 * GT_Utility.getTier(tVoltage)); log("Running checkRecipeGeneric(0)");
+	 * 
+	 * //Check to see if Voltage Tier > Control Core Tier if (tTier >
+	 * aControlCoreTier) {
+	 * log("Control core found is lower tier than power tier. OK"); tTier = (byte)
+	 * aControlCoreTier; }
+	 * 
+	 * tTier = (byte) MathUtils.getValueWithinRange(tTier, 0, 9);
+	 * 
+	 * GT_Recipe tRecipe = aRecipe != null ? aRecipe : findRecipe(
+	 * getBaseMetaTileEntity(), mLastRecipe, false,
+	 * gregtech.api.enums.GT_Values.V[tTier], aFluidInputs, aItemInputs);
+	 * 
+	 * log("Running checkRecipeGeneric(1)"); // Remember last recipe - an
+	 * optimization for findRecipe() this.mLastRecipe = tRecipe;
+	 * 
+	 * if (tRecipe == null) { log("BAD RETURN - 1"); return false; }
+	 * 
+	 * if (!this.canBufferOutputs(tRecipe, aMaxParallelRecipes)) {
+	 * log("BAD RETURN - 2"); return false; }
+	 * 
+	 * // EU discount float tRecipeEUt = (tRecipe.mEUt * aEUPercent) / 100.0f; float
+	 * tTotalEUt = 0.0f;
+	 * 
+	 * int parallelRecipes = 0;
+	 * 
+	 * log("parallelRecipes: "+parallelRecipes);
+	 * log("aMaxParallelRecipes: "+aMaxParallelRecipes);
+	 * log("tTotalEUt: "+tTotalEUt); log("tVoltage: "+tVoltage);
+	 * log("tRecipeEUt: "+tRecipeEUt); Logger.INFO("EU1: "+tRecipeEUt); // Count
+	 * recipes to do in parallel, consuming input items and fluids and considering
+	 * input voltage limits for (; parallelRecipes < aMaxParallelRecipes &&
+	 * tTotalEUt < (tVoltage - tRecipeEUt); parallelRecipes++) { if
+	 * (!tRecipe.isRecipeInputEqual(true, aFluidInputs, aItemInputs)) {
+	 * log("Broke at "+parallelRecipes+"."); break; }
+	 * log("Bumped EU from "+tTotalEUt+" to "+(tTotalEUt+tRecipeEUt)+"."); tTotalEUt
+	 * += tRecipeEUt; Logger.INFO("EU2: "+tTotalEUt); }
+	 * 
+	 * if (parallelRecipes == 0) { log("BAD RETURN - 3"); return false; }
+	 * 
+	 * Logger.INFO("EU3: "+tTotalEUt);
+	 * 
+	 * // -- Try not to fail after this point - inputs have already been consumed!
+	 * --
+	 * 
+	 * 
+	 * // Convert speed bonus to duration multiplier // e.g. 100% speed bonus = 200%
+	 * speed = 100%/200% = 50% recipe duration. aSpeedBonusPercent = Math.max(-99,
+	 * aSpeedBonusPercent); float tTimeFactor = 100.0f / (100.0f +
+	 * aSpeedBonusPercent); this.mMaxProgresstime = (int)(tRecipe.mDuration *
+	 * tTimeFactor * 10000);
+	 * 
+	 * int aTempEu = (int) Math.floor(tTotalEUt); Logger.INFO("EU4: "+aTempEu);
+	 * this.mEUt = (int) aTempEu;
+	 * 
+	 * 
+	 * this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+	 * this.mEfficiencyIncrease = 10000;
+	 * 
+	 * // Overclock if (this.mEUt <= 16) { this.mEUt = (this.mEUt * (1 << tTier - 1)
+	 * * (1 << tTier - 1)); this.mMaxProgresstime = (this.mMaxProgresstime / (1 <<
+	 * tTier - 1)); } else { while (this.mEUt <=
+	 * gregtech.api.enums.GT_Values.V[(tTier - 1)]) { this.mEUt *= 4;
+	 * this.mMaxProgresstime /= 2; } }
+	 * 
+	 * if (this.mEUt > 0) { this.mEUt = (-this.mEUt); }
+	 * 
+	 * this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+	 * 
+	 * // Collect fluid outputs FluidStack[] tOutputFluids = new
+	 * FluidStack[tRecipe.mFluidOutputs.length]; for (int h = 0; h <
+	 * tRecipe.mFluidOutputs.length; h++) { if (tRecipe.getFluidOutput(h) != null) {
+	 * tOutputFluids[h] = tRecipe.getFluidOutput(h).copy(); tOutputFluids[h].amount
+	 * *= parallelRecipes; } }
+	 * 
+	 * // Collect output item types ItemStack[] tOutputItems = new
+	 * ItemStack[tRecipe.mOutputs.length]; for (int h = 0; h <
+	 * tRecipe.mOutputs.length; h++) { if (tRecipe.getOutput(h) != null) {
+	 * tOutputItems[h] = tRecipe.getOutput(h).copy(); tOutputItems[h].stackSize = 0;
+	 * } }
+	 * 
+	 * // Set output item stack sizes (taking output chance into account) for (int f
+	 * = 0; f < tOutputItems.length; f++) { if (tRecipe.mOutputs[f] != null &&
+	 * tOutputItems[f] != null) { for (int g = 0; g < parallelRecipes; g++) { if
+	 * (getBaseMetaTileEntity().getRandomNumber(aOutputChanceRoll) <
+	 * tRecipe.getOutputChance(f)) tOutputItems[f].stackSize +=
+	 * tRecipe.mOutputs[f].stackSize; } } }
+	 * 
+	 * tOutputItems = removeNulls(tOutputItems);
+	 * 
+	 * // Sanitize item stack size, splitting any stacks greater than max stack size
+	 * List<ItemStack> splitStacks = new ArrayList<ItemStack>(); for (ItemStack
+	 * tItem : tOutputItems) { while (tItem.getMaxStackSize() < tItem.stackSize) {
+	 * ItemStack tmp = tItem.copy(); tmp.stackSize = tmp.getMaxStackSize();
+	 * tItem.stackSize = tItem.stackSize - tItem.getMaxStackSize();
+	 * splitStacks.add(tmp); } }
+	 * 
+	 * if (splitStacks.size() > 0) { ItemStack[] tmp = new
+	 * ItemStack[splitStacks.size()]; tmp = splitStacks.toArray(tmp); tOutputItems =
+	 * ArrayUtils.addAll(tOutputItems, tmp); }
+	 * 
+	 * // Strip empty stacks List<ItemStack> tSList = new ArrayList<ItemStack>();
+	 * for (ItemStack tS : tOutputItems) { if (tS.stackSize > 0) tSList.add(tS); }
+	 * tOutputItems = tSList.toArray(new ItemStack[tSList.size()]);
+	 * 
+	 * // Commit outputs this.mOutputItems = tOutputItems; this.mOutputFluids =
+	 * tOutputFluids; updateSlots();
+	 * 
+	 * // Play sounds (GT++ addition - GT multiblocks play no sounds)
+	 * startProcess();
+	 * 
+	 * log("GOOD RETURN - 1"); return true; }
+	 */
+
 	public boolean checkRecipeGeneric(
 			ItemStack[] aItemInputs, FluidStack[] aFluidInputs,
 			int aMaxParallelRecipes, int aEUPercent,
 			int aSpeedBonusPercent, int aOutputChanceRoll, GT_Recipe aRecipe) {
-		// Based on the Processing Array. A bit overkill, but very flexible.
-
-		
-		if (this.doesMachineBoostOutput()) {
-			log("Boosting.");
-			return checkRecipeBoostedOutputs(aItemInputs, aFluidInputs, aMaxParallelRecipes, aEUPercent, aSpeedBonusPercent, aOutputChanceRoll, aRecipe);
-		}
-		
-
-		//Control Core to control the Multiblocks behaviour.
-		int aControlCoreTier = getControlCoreTier();
-
-		//If no core, return false;				
-		if (aControlCoreTier > 0) {
-			log("Control core found.");
-		}
+		// Based on the Processing Array. A bit overkill, but very flexible.	
 
 
 		// Reset outputs and progress stats
@@ -571,15 +695,8 @@ GT_MetaTileEntity_MultiBlockBase {
 		byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
 		log("Running checkRecipeGeneric(0)");
 
-		//Check to see if Voltage Tier > Control Core Tier
-		if (tTier > aControlCoreTier) {
-			log("Control core found is lower tier than power tier. OK");
-			tTier = (byte) aControlCoreTier;
-		}
 
-		tTier = (byte) MathUtils.getValueWithinRange(tTier, 0, 9);
-
-		GT_Recipe tRecipe = aRecipe != null ? aRecipe : findRecipe(
+		GT_Recipe tRecipe = findRecipe(
 				getBaseMetaTileEntity(), mLastRecipe, false,
 				gregtech.api.enums.GT_Values.V[tTier], aFluidInputs, aItemInputs);
 
@@ -635,7 +752,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		this.mEUt = (int)Math.ceil(tTotalEUt);
 
 		this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
-		this.mEfficiencyIncrease = 10000;
+		this.mEfficiencyIncrease = 10000;		
 
 		// Overclock
 		if (this.mEUt <= 16) {
@@ -718,8 +835,7 @@ GT_MetaTileEntity_MultiBlockBase {
 
 		log("GOOD RETURN - 1");
 		return true;
-	}
-
+}
 
 
 
@@ -1136,6 +1252,47 @@ GT_MetaTileEntity_MultiBlockBase {
 		ItemStack guiSlot = this.mInventory[1];		
 		return guiSlot;
 	}
+	
+	protected boolean setGUIItemStack(ItemStack aNewGuiSlotContents) {
+		boolean result = false;
+		if (this.mInventory[1] == null) {
+			this.mInventory[1] = aNewGuiSlotContents != null ? aNewGuiSlotContents.copy() : null;
+			aNewGuiSlotContents = null;
+			this.updateSlots();
+			result = true;
+		}	
+		return result;
+	}
+	
+	protected boolean clearGUIItemSlot() {
+		return setGUIItemStack(null);
+	}
+	
+
+	public ItemStack findItemInInventory(Item aSearchStack) {
+		return findItemInInventory(aSearchStack, 0);
+	}
+
+	public ItemStack findItemInInventory(Item aSearchStack, int aMeta) {
+		return findItemInInventory(ItemUtils.simpleMetaStack(aSearchStack, aMeta, 1));
+	}
+	
+	public ItemStack findItemInInventory(ItemStack aSearchStack) {
+		if (aSearchStack != null && this.mInputBusses.size() > 0) {
+			for (GT_MetaTileEntity_Hatch_InputBus bus : this.mInputBusses) {
+				if (bus != null) {
+					for (ItemStack uStack : bus.mInventory) {
+						if (uStack != null) {
+							if (aSearchStack.getClass().isInstance(uStack.getItem())) {
+								return uStack;
+							}
+						}
+					}
+				}
+			}
+		}
+		return null;
+	}
 
 	@Override
 	public void updateSlots() {
@@ -1208,6 +1365,14 @@ GT_MetaTileEntity_MultiBlockBase {
 		if (aTileEntity == null) {
 			return false;
 		}		
+		
+		//Check type
+		/*
+		 * Class <?> aHatchType = ReflectionUtils.getTypeOfGenericObject(aList); if
+		 * (!aHatchType.isInstance(aTileEntity)) { return false; }
+		 */
+		
+		
 		if (aList.isEmpty()) {
 			if (aTileEntity instanceof GT_MetaTileEntity_Hatch) {
 				if (GTplusplus.CURRENT_LOAD_PHASE == INIT_PHASE.STARTED) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java b/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java
index 99563b60ef..9c552db3ad 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java
@@ -219,6 +219,57 @@ public class StaticFields59 {
 		}
 		return null;
 	}
+	
+	public static int getHeatingCapacityForCoil(Block aBlock, int aMeta) {		
+		if (aBlock == GregTech_API.sBlockCasings1 && (aMeta >= 12 && aMeta <= 14)) {
+			return getHeatingCapacityForCoilTier(aMeta == 12 ? 1 : aMeta == 13 ? 2 : 3);
+		}
+		else if (aBlock == getBlockCasings5() && (aMeta >= 0 && aMeta <= 8)) {
+			return getHeatingCapacityForCoilTier(aMeta);
+		}
+		return 0;
+	}
+	
+	public static int getHeatingCapacityForCoilTier(int aCoilTier) {
+		int mHeatingCapacity = 0;
+		switch (aCoilTier) {
+		case 0:
+			mHeatingCapacity = 1800;
+			break;
+		case 1:
+			mHeatingCapacity = 2700;
+			break;
+		case 2:
+			mHeatingCapacity = 3600;
+			break;
+		case 3:
+			mHeatingCapacity = 4500;
+			break;
+		case 4:
+			mHeatingCapacity = 5400;
+			break;
+		case 5:
+			mHeatingCapacity = 7200;
+			break;
+		case 6:
+			mHeatingCapacity = 9000;
+			break;
+		case 7:
+			mHeatingCapacity = 9900;
+			break;
+		case 8:
+			mHeatingCapacity = 10800;
+			break;
+		default:
+			Logger.INFO("Heating Coils are bad.");
+			mHeatingCapacity = 0;
+		}
+		if (CORE.GTNH && aCoilTier <= 6) {
+			mHeatingCapacity += 1;
+		}
+		
+		return mHeatingCapacity;
+	}
 
 
 }
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks4.java b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks4.java
index 54323d8c2e..5116632cf1 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks4.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks4.java
@@ -34,7 +34,7 @@ extends GregtechMetaCasingBlocksAbstract {
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".7.name", "Turbine Shaft");
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".8.name", "Low Pressure Turbine Casing"); 
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".9.name", "High Pressure Turbine Casing");
-		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".10.name", "");
+		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".10.name", "Vacuum Casing");
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".11.name", "");
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".12.name", "");
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".13.name", "");
@@ -50,8 +50,8 @@ extends GregtechMetaCasingBlocksAbstract {
 		GregtechItemList.Casing_Turbine_Shaft.set(new ItemStack(this, 1, 7));
 		GregtechItemList.Casing_Turbine_LP.set(new ItemStack(this, 1, 8));
 		GregtechItemList.Casing_Turbine_HP.set(new ItemStack(this, 1, 9));
-		/*GregtechItemList.Casing_Cyclotron_External.set(new ItemStack(this, 1, 10));
-		GregtechItemList.Casing_ThermalContainment.set(new ItemStack(this, 1, 11));
+		GregtechItemList.Casing_Vacuum_Furnace.set(new ItemStack(this, 1, 10));
+		/*GregtechItemList.Casing_ThermalContainment.set(new ItemStack(this, 1, 11));
 		GregtechItemList.Casing_Autocrafter.set(new ItemStack(this, 1, 12));
 		GregtechItemList.Casing_CuttingFactoryFrame.set(new ItemStack(this, 1, 13));
 		GregtechItemList.Casing_TeslaTower.set(new ItemStack(this, 1, 14));
@@ -112,7 +112,14 @@ extends GregtechMetaCasingBlocksAbstract {
 					
 					//Cyclotron External Casing
 				case 10:
-					return Textures.BlockIcons.MACHINE_CASING_RADIATIONPROOF.getIcon();
+					
+					if (aSide <2) {
+						return TexturesGtBlock.TEXTURE_STONE_RED_B.getIcon();					
+					}
+					else {
+						return TexturesGtBlock.TEXTURE_STONE_RED_A.getIcon();					
+					}
+					
 					//Multitank Exterior Casing
 				case 11:
 					return TexturesGtBlock.Casing_Material_Tantalloy61.getIcon();
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/textures/TexturesGtBlock.java b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/textures/TexturesGtBlock.java
index d983bd84a9..aaacbcd3a0 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/textures/TexturesGtBlock.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/textures/TexturesGtBlock.java
@@ -416,6 +416,7 @@ public class TexturesGtBlock {
 	public static final CustomIcon TEXTURE_STONE_BIRD_A_LEFT = new CustomIcon("metro/TEXTURE_STONE_BIRD_A_LEFT");
 	public static final CustomIcon TEXTURE_STONE_BIRD_A_RIGHT = new CustomIcon("metro/TEXTURE_STONE_BIRD_A_RIGHT");
 	public static final CustomIcon TEXTURE_STONE_RED_A = new CustomIcon("metro/TEXTURE_STONE_RED_A");
+	public static final CustomIcon TEXTURE_STONE_RED_B = new CustomIcon("metro/TEXTURE_STONE_RED_B");
 	public static final CustomIcon TEXTURE_STONE_BLUE_A = new CustomIcon("metro/TEXTURE_STONE_BLUE_A");
 	public static final CustomIcon TEXTURE_STONE_GREEN_A = new CustomIcon("metro/TEXTURE_STONE_GREEN_A");
 	public static final CustomIcon TEXTURE_STONE_TABLET_A = new CustomIcon("metro/TEXTURE_STONE_TABLET_A");
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/covers/GTPP_Cover_VisualPlate.java b/src/Java/gtPlusPlus/xmod/gregtech/common/covers/GTPP_Cover_VisualPlate.java
new file mode 100644
index 0000000000..7d2ed2c21a
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/covers/GTPP_Cover_VisualPlate.java
@@ -0,0 +1,67 @@
+package gtPlusPlus.xmod.gregtech.common.covers;
+
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.util.GT_CoverBehavior;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.fluids.Fluid;
+
+public class GTPP_Cover_VisualPlate extends GT_CoverBehavior {
+
+    public GTPP_Cover_VisualPlate() {
+    }
+
+    public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+            long aTimer) {
+        return aCoverVariable;
+    }
+
+    public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+            EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return aCoverVariable;
+    }
+
+    public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
+            EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return true;
+    }
+
+    public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return false;
+    }
+
+    public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java b/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
index 1a400eaa20..c9f4dd9ae2 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
@@ -29,6 +29,7 @@ import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
 import gtPlusPlus.xmod.gregtech.api.items.Gregtech_MetaItem_X32;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 import gtPlusPlus.xmod.gregtech.common.covers.GTPP_Cover_Overflow;
+import gtPlusPlus.xmod.gregtech.common.covers.GTPP_Cover_VisualPlate;
 
 public class MetaGeneratedGregtechItems extends Gregtech_MetaItem_X32 {
 
@@ -249,21 +250,7 @@ public class MetaGeneratedGregtechItems extends Gregtech_MetaItem_X32 {
 			this.setFluidContainerStats(32000 + tLastID, 16L, 64L);
 
 			GregtechItemList.Fluid_Cell_1L.set(this.addItem(tLastID = 64, "1L Wrought Iron Fluid Cell", "Holds exactly one litre worth of liquid.", new Object[]{new ItemData(Materials.WroughtIron, (OrePrefixes.plate.mMaterialAmount * 8L) + (4L * OrePrefixes.ring.mMaterialAmount), new MaterialStack[0]), getTcAspectStack(TC_Aspects.VACUOS, 2L), getTcAspectStack(TC_Aspects.AQUA, 1L)}));
-			this.setFluidContainerStats(32000 + tLastID, 1L, 64L);
-
-			if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
-
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.WroughtIron, 1L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.WroughtIron, 2L), GregtechItemList.Fluid_Cell_1L.get(1L, new Object[0]), 50, 32);
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Bronze, 1L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Bronze, 2L), GregtechItemList.Fluid_Cell_16L.get(1L, new Object[0]), 50, 32);
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Brass, 1L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Brass, 2L), GregtechItemList.Fluid_Cell_36L.get(1L, new Object[0]), 75, 32);
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Invar, 1L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Invar, 2L), GregtechItemList.Fluid_Cell_144L.get(1L, new Object[0]), 75, 32);
-
-			} else {
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 8L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.WroughtIron, 4L), GregtechItemList.Fluid_Cell_1L.get(1L, new Object[0]), 50, 32);
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Bronze, 8L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Bronze, 4L), GregtechItemList.Fluid_Cell_16L.get(1L, new Object[0]), 50, 32);
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Brass, 8L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Brass, 4L), GregtechItemList.Fluid_Cell_36L.get(1L, new Object[0]), 75, 32);
-				GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Invar, 8L), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Invar, 4L), GregtechItemList.Fluid_Cell_144L.get(1L, new Object[0]), 75, 32);
-			}
+			this.setFluidContainerStats(32000 + tLastID, 1L, 64L);			
 		}
 
 
@@ -280,8 +267,7 @@ public class MetaGeneratedGregtechItems extends Gregtech_MetaItem_X32 {
 		GregTech_API.registerCover(GregtechItemList.Cover_Overflow_MV.get(1L, new Object[0]), new GT_MultiTexture(new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[5][0], new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)}), new GTPP_Cover_Overflow(512));
 		GregTech_API.registerCover(GregtechItemList.Cover_Overflow_HV.get(1L, new Object[0]), new GT_MultiTexture(new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[5][0], new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)}), new GTPP_Cover_Overflow(4096));
 		GregTech_API.registerCover(GregtechItemList.Cover_Overflow_EV.get(1L, new Object[0]), new GT_MultiTexture(new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[8][0], new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)}), new GTPP_Cover_Overflow(32768));
-		GregTech_API.registerCover(GregtechItemList.Cover_Overflow_IV.get(1L, new Object[0]), new GT_MultiTexture(new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[8][0], new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)}), new GTPP_Cover_Overflow(262144));
-
+		GregTech_API.registerCover(GregtechItemList.Cover_Overflow_IV.get(1L, new Object[0]), new GT_MultiTexture(new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[8][0], new GT_RenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)}), new GTPP_Cover_Overflow(262144));	
 
 		//Fusion Reactor MK4 Singularity
 		GregtechItemList.Compressed_Fusion_Reactor.set(this.addItem(100, "Hypervisor Matrix (Fusion)", "A memory unit containing an RI (Restricted Intelligence)", new Object[0]));
@@ -327,7 +313,30 @@ public class MetaGeneratedGregtechItems extends Gregtech_MetaItem_X32 {
 		GregtechItemList.Farm_Processor_UV.set(this.addItem(tLastID = 128, "Farm Processor [UV]", "Reusable", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 8L), getTcAspectStack(TC_Aspects.METALLUM, 8L), getTcAspectStack(TC_Aspects.POTENTIA, 8L)}));
 		this.setElectricStats(32000 + tLastID, GT_Values.V[9]* 10 * 60 * 20, GT_Values.V[8], 8L, -3L, false);
 		
-		
+		String aTierName;
+        int aFirstMachineCasingID = 130;
+        GregtechItemList[] mMachineCasingCovers = new GregtechItemList[] {
+                GregtechItemList.FakeMachineCasingPlate_ULV,
+                GregtechItemList.FakeMachineCasingPlate_LV,
+                GregtechItemList.FakeMachineCasingPlate_MV,
+                GregtechItemList.FakeMachineCasingPlate_HV,
+                GregtechItemList.FakeMachineCasingPlate_EV,
+                GregtechItemList.FakeMachineCasingPlate_IV,
+                GregtechItemList.FakeMachineCasingPlate_LuV,
+                GregtechItemList.FakeMachineCasingPlate_ZPM,
+                GregtechItemList.FakeMachineCasingPlate_UV,
+                GregtechItemList.FakeMachineCasingPlate_MAX,
+        };
+        for (int i=0;i<10;i++) {
+            if (i==10) {
+                break;
+            }
+            else {              
+                aTierName = GT_Values.VN[i];
+                mMachineCasingCovers[i].set(this.addItem(aFirstMachineCasingID++, aTierName+" Machine Plate Cover", "Looks visually like an "+aTierName+" machine casing, apply to pipe/cable as cover", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 1L), getTcAspectStack(TC_Aspects.MACHINA, 1L)}));
+                GregTech_API.registerCover(mMachineCasingCovers[i].get(1L, new Object[0]), new GT_MultiTexture(new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[i][0]}), new GTPP_Cover_VisualPlate());
+             }
+        }
 		
 		
 	}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java b/src/Java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java
index 64676fa907..a063d334bf 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/items/behaviours/Behaviour_Electric_Lighter.java
@@ -1,5 +1,6 @@
 package gtPlusPlus.xmod.gregtech.common.items.behaviours;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import codechicken.lib.math.MathHelper;
@@ -10,12 +11,10 @@ import gregtech.api.util.GT_Utility;
 import gregtech.common.items.behaviors.Behaviour_None;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.core.entity.projectile.EntityLightningAttack;
-import gtPlusPlus.core.entity.projectile.EntityThrowableBomb;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.minecraft.NBTUtils;
 import gtPlusPlus.core.util.minecraft.PlayerUtils;
-import gtPlusPlus.core.util.sys.KeyboardUtils;
 import gtPlusPlus.xmod.gregtech.common.helpers.ChargingHelper;
 import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
 import ic2.api.item.IElectricItemManager;
@@ -24,7 +23,6 @@ import net.minecraft.entity.monster.EntityCreeper;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
@@ -42,8 +40,8 @@ public class Behaviour_Electric_Lighter extends Behaviour_None {
 		
 	}
 
-	public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) {
-		if (!aPlayer.worldObj.isRemote && aStack.stackSize == 1) {
+	public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) {		
+		if (!aPlayer.worldObj.isRemote && aStack != null && aStack.stackSize == 1) {
 			boolean rOutput = false;
 			if (aEntity instanceof EntityCreeper) {
 				if (this.prepare(aStack) || aPlayer.capabilities.isCreativeMode) {
@@ -62,7 +60,7 @@ public class Behaviour_Electric_Lighter extends Behaviour_None {
 
 	public boolean onItemUse(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX,
 			int aY, int aZ, int aSide, float hitX, float hitY, float hitZ) {
-		if (!aWorld.isRemote && aStack.stackSize == 1) {			
+		if (!aWorld.isRemote && aStack != null && aStack.stackSize == 1) {			
 			if (aPlayer.isSneaking()) {
 				Logger.INFO("Changing Mode");
 				boolean aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMod");
@@ -111,7 +109,7 @@ public class Behaviour_Electric_Lighter extends Behaviour_None {
 
 	public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX,
 			int aY, int aZ, int aSide, float hitX, float hitY, float hitZ) {
-		if (!aWorld.isRemote && aStack.stackSize == 1) {			
+		if (!aWorld.isRemote && aStack != null && aStack.stackSize == 1) {			
 			if (aPlayer.isSneaking()) {
 				Logger.INFO("Changing Mode");
 				boolean aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMod");
@@ -189,9 +187,8 @@ public class Behaviour_Electric_Lighter extends Behaviour_None {
 
 	public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) {
 		aList.add(this.mTooltip);
-		int aUses = 0;
-
-		if (aStack != null) {
+		int aUses = 0;		
+		if (aStack != null) {			
 			if (aStack.getItem() instanceof MetaGeneratedGregtechTools) {
 				if (ChargingHelper.isItemValid(aStack)) {
 					if (aStack.getItem() instanceof IElectricItemManager) {
@@ -200,24 +197,22 @@ public class Behaviour_Electric_Lighter extends Behaviour_None {
 						long aEuCost = 4096 * 2;
 						aUses = (int) (aCharge / aEuCost);
 					}
+				}				
+				boolean aCurrentMode; 		
+				if (NBTUtils.hasKey(aStack, "aFireballMode")) {
+					aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMod");
 				}
+				else {
+					aStack.getTagCompound().setBoolean("aFireballMod", false);
+					aCurrentMode = false;
+				}				
+				aList.add("Current Mode: "+EnumChatFormatting.RED+(aCurrentMode ? "Projectile" : "Fire Starter"));	
 			}
+			
 		}
 
-		NBTTagCompound tNBT = aStack.getTagCompound();
 		aList.add(this.mTooltipUses + " " + aUses);
-		aList.add(this.mTooltipUnstackable);
-		
-		
-		boolean aCurrentMode; 
-		if (NBTUtils.hasKey(aStack, "aFireballMode")) {
-			aCurrentMode = NBTUtils.getBoolean(aStack, "aFireballMod");
-		}
-		else {
-			aStack.getTagCompound().setBoolean("aFireballMod", false);
-			aCurrentMode = false;
-		}
-		aList.add("Current Mode: "+EnumChatFormatting.RED+(aCurrentMode ? "Projectile" : "Fire Starter"));		
+		aList.add(this.mTooltipUnstackable);	
 		return aList;
 	}
 }
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java b/src/Java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
index 7dd376759a..763a4a129d 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
@@ -49,6 +49,7 @@ import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.MathHelper;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.client.event.RenderPlayerEvent;
+import net.minecraftforge.common.UsernameCache;
 
 public class GTPP_CapeRenderer extends RenderPlayer {
 
@@ -91,7 +92,7 @@ public class GTPP_CapeRenderer extends RenderPlayer {
 				aEvent.setCanceled(true);
 				Logger.WARNING("A2");
 				return;
-			}		
+			}
 		}
 
 		// Make sure we don't keep checking on clients who dont have capes.
@@ -100,14 +101,35 @@ public class GTPP_CapeRenderer extends RenderPlayer {
 			// Time to Spliterate some data
 			Map<String, ResourceLocation> aPlayerData = new HashMap<String, ResourceLocation>();
 			Map<String, String> aNameMap = new HashMap<String, String>();
-			int i = 0;
-			for (String s : mData) {
-				String[] aSplit = s.split("@");
-				int a[] = new int[] { 0, mCapes.length - 1 };
-				int aID = Integer.parseInt(aSplit[1]);
-				String aPlayerName = this.getPlayerName("iteration-" + (i++), aSplit[0]);
-				aNameMap.put(aSplit[0], aPlayerName);
-				aPlayerData.put(aPlayerName, this.mCapes[Math.max(a[0], Math.min(aID, a[1]))]);
+			int i = 0;		
+			if (!CORE.DEVENV) {
+				for (String s : mData) {
+					String[] aSplit = s.split("@");
+					int a[] = new int[] { 0, mCapes.length - 1 };
+					int aID = Integer.parseInt(aSplit[1]);
+					// Quick Check to prevent lag
+					Logger.WARNING("Trying to create UUID from - " + aSplit[0]);
+					UUID aPlayerID = UUID.fromString(aSplit[0]);
+					Logger.WARNING("Result: " + aPlayerID.toString());
+					if (aPlayerID != null) {
+						if (UsernameCache.containsUUID(aPlayerID)) {
+							Logger.WARNING("UsernameCache contains a last known username for current players UUID.");
+							if (!UsernameCache.getLastKnownUsername(aPlayerID).toLowerCase()
+									.equals(ClientProxy.playerName)) {
+								Logger.WARNING("Last known name does not match current name. Checking next UUID.");
+								continue;
+							} else {
+								Logger.WARNING("Last known name does match current name.");
+							}
+						} else {
+							Logger.WARNING("UsernameCache did not hold results for current player, oops.");
+							continue;
+						}
+					}
+					String aPlayerName = this.getPlayerName("iteration-" + (i++), aSplit[0]);
+					aNameMap.put(aSplit[0], aPlayerName);
+					aPlayerData.put(aPlayerName, this.mCapes[Math.max(a[0], Math.min(aID, a[1]))]);
+				}
 			}
 
 			// Set flag to only render this event if player has a cape.
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GT_MetaTileEntity_SemiFluidGenerator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GT_MetaTileEntity_SemiFluidGenerator.java
index ef3e06086e..9f50cf6d91 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GT_MetaTileEntity_SemiFluidGenerator.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GT_MetaTileEntity_SemiFluidGenerator.java
@@ -1,9 +1,6 @@
 package gtPlusPlus.xmod.gregtech.common.tileentities.generators;
 
 import cpw.mods.fml.common.registry.GameRegistry;
-
-import net.minecraft.item.ItemStack;
-
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.ItemList;
@@ -11,7 +8,6 @@ import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator;
 import gregtech.api.objects.GT_ItemStack;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_ModHandler;
@@ -19,8 +15,8 @@ import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gregtech.api.util.Recipe_GT.Gregtech_Recipe_Map;
 import gtPlusPlus.api.objects.Logger;
-import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.custom.power.GTPP_MTE_BasicLosslessGenerator;
+import net.minecraft.item.ItemStack;
 
 public class GT_MetaTileEntity_SemiFluidGenerator extends GTPP_MTE_BasicLosslessGenerator{
 
@@ -65,7 +61,7 @@ public class GT_MetaTileEntity_SemiFluidGenerator extends GTPP_MTE_BasicLossless
 
 	@Override
 	public GT_Recipe.GT_Recipe_Map getRecipes() {
-		//Logger.INFO("Fuel Count: "+Gregtech_Recipe_Map.sSemiFluidLiquidFuels.mRecipeList.size());
+		//Logger.WARNING("Fuel Count: "+Gregtech_Recipe_Map.sSemiFluidLiquidFuels.mRecipeList.size());
 		return Gregtech_Recipe_Map.sSemiFluidLiquidFuels;
 	}
 	
@@ -95,14 +91,14 @@ public class GT_MetaTileEntity_SemiFluidGenerator extends GTPP_MTE_BasicLossless
 	@Override
 	public int getFuelValue(ItemStack aStack) {
 		if ((GT_Utility.isStackInvalid(aStack)) || (getRecipes() == null)) {
-			Logger.INFO("Bad Fuel?");
+			Logger.WARNING("Bad Fuel?");
 			return 0;
 		}
 		int rValue = Math.max(GT_ModHandler.getFuelCanValue(aStack) * 6 / 5, super.getFuelValue(aStack));
 		if (ItemList.Fuel_Can_Plastic_Filled.isStackEqual(aStack, false, true)) {
 			rValue = Math.max(rValue, GameRegistry.getFuelValue(aStack) * 3);
 		}
-		Logger.INFO("Good Fuel: "+rValue);
+		Logger.WARNING("Good Fuel: "+rValue);
 		return rValue;
 	}
 
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntity_RTG.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntity_RTG.java
index f3fd95f0c1..6f18b89c53 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntity_RTG.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntity_RTG.java
@@ -338,22 +338,22 @@ public class GregtechMetaTileEntity_RTG extends GT_MetaTileEntity_BasicGenerator
 				this.mNewTier = mTier2;
 				//ReflectionUtils.setFinalStatic(mTier2, GT_Values.V[0]);
 			} catch (Exception e) {
-				Logger.INFO("Failed setting mTier.");
+				Logger.WARNING("Failed setting mTier.");
 				e.printStackTrace();
 			}
 
 			this.mTicksToBurnFor = getTotalEUGenerated(convertDaysToTicks(tFuel.mSpecialValue), voltage);
 			if (mTicksToBurnFor >= Integer.MAX_VALUE){
 				mTicksToBurnFor = Integer.MAX_VALUE;
-				Logger.INFO("Fuel went over Int limit, setting to MAX_VALUE.");
+				Logger.WARNING("Fuel went over Int limit, setting to MAX_VALUE.");
 			}
 			this.mDaysRemaining = MathUtils.roundToClosestInt(mTicksToBurnFor/20/60/3);
-			Logger.INFO("step | "+(int) (mTicksToBurnFor * getEfficiency() / 100L));
+			Logger.WARNING("step | "+(int) (mTicksToBurnFor * getEfficiency() / 100L));
 			return (int) (mTicksToBurnFor * getEfficiency() / 100L);
 			//return (int) (tFuel.mSpecialValue * 365L * getEfficiency() / 100L);
 			//return tFuel.mEUt;
 		}
-		Logger.INFO("Not sure");
+		Logger.WARNING("Not sure");
 		return 0;
 	}
 
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaAtmosphericReconditioner.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaAtmosphericReconditioner.java
index c364fe5e9e..e277b671c6 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaAtmosphericReconditioner.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaAtmosphericReconditioner.java
@@ -127,13 +127,6 @@ public class GregtechMetaAtmosphericReconditioner extends GT_MetaTileEntity_Basi
 	}
 
 	@Override
-	public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
-		if (getBaseMetaTileEntity().isServerSide()) {
-
-		}
-	}
-
-	@Override
 	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
 		super.onPostTick(aBaseMetaTileEntity, aTick);
 		if (aBaseMetaTileEntity.isServerSide()) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaGarbageCollector.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaGarbageCollector.java
new file mode 100644
index 0000000000..0a65db7be4
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaGarbageCollector.java
@@ -0,0 +1,318 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaTileEntity;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+public class GregtechMetaGarbageCollector extends GregtechMetaTileEntity {
+
+	long mLastCleanup = 0;
+	long mLocalTickVar = 0;
+	int mFrequency = 5;
+
+	public GregtechMetaGarbageCollector(final String aName, final String aNameRegional, final String aDescription) {
+		super(991, aName, aNameRegional, 5, 0, aDescription);
+	}
+
+	public GregtechMetaGarbageCollector(final String aName, final String aDescription, final ITexture[][][] aTextures) {
+		super(aName, 5, 0, aDescription, aTextures);
+	}
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {this.mDescription, "Can request the JVM to perform garbage collection", "Configurable to run once every 5 minute interval (5-180)", "This Machine has no recipe", "Admin Tool, Limit one per world if possible"};
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(final ITexture[] aTextures) {
+		final ITexture[][][] rTextures = new ITexture[10][17][];
+		for (byte i = -1; i < 16; i++) {
+			rTextures[0][i + 1] = this.getFront(i);
+			rTextures[1][i + 1] = this.getBack(i);
+			rTextures[2][i + 1] = this.getBottom(i);
+			rTextures[3][i + 1] = this.getTop(i);
+			rTextures[4][i + 1] = this.getSides(i);
+			rTextures[5][i + 1] = this.getFrontActive(i);
+			rTextures[6][i + 1] = this.getBackActive(i);
+			rTextures[7][i + 1] = this.getBottomActive(i);
+			rTextures[8][i + 1] = this.getTopActive(i);
+			rTextures[9][i + 1] = this.getSidesActive(i);
+		}
+		return rTextures;
+	}
+
+	@Override
+	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing, final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
+		return this.mTextures[(aActive ? 5 : 0) + (aSide == aFacing ? 0 : aSide == GT_Utility.getOppositeSide(aFacing) ? 1 : aSide == 0 ? 2 : aSide == 1 ? 3 : 4)][aColorIndex + 1];
+	}
+
+
+	public ITexture[] getFront(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_RedSteel)};
+	}
+
+
+	public ITexture[] getBack(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_RedSteel)};
+	}
+
+
+	public ITexture[] getBottom(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_Grisium)};
+	}
+
+
+	public ITexture[] getTop(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_Grisium)};
+	}
+
+
+	public ITexture[] getSides(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Redox_3)};
+	}
+
+
+	public ITexture[] getFrontActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_RedSteel)};
+	}
+
+
+	public ITexture[] getBackActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_RedSteel)};
+	}
+
+
+	public ITexture[] getBottomActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_Grisium)};
+	}
+
+
+	public ITexture[] getTopActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Material_Grisium)};
+	}
+
+
+	public ITexture[] getSidesActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier+3][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Casing_Redox_3)};
+	}
+
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+		if (mFrequency < 180){
+			mFrequency += 5;
+		}
+		else {
+			mFrequency = 5;
+		}
+		PlayerUtils.messagePlayer(aPlayer, "Running every "+mFrequency+" minutes.");	
+		super.onScrewdriverRightClick(aSide, aPlayer, aX, aY, aZ);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(final IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaGarbageCollector(this.mName, this.mDescription, this.mTextures);
+	}
+
+	@Override public boolean isSimpleMachine()						{return true;}
+	@Override public boolean isElectric()							{return false;}
+	@Override public boolean isValidSlot(final int aIndex)				{return false;}
+	@Override public boolean isFacingValid(final byte aFacing)			{return true;}
+	@Override public boolean isEnetInput() 							{return false;}
+	@Override public boolean isEnetOutput() 						{return false;}
+	@Override public boolean isInputFacing(final byte aSide)				{return aSide!=this.getBaseMetaTileEntity().getFrontFacing();}
+	@Override public boolean isOutputFacing(final byte aSide)				{return aSide==this.getBaseMetaTileEntity().getFrontFacing();}
+	@Override public boolean isTeleporterCompatible()				{return false;}
+	@Override public long getMinimumStoredEU()						{return 0;}
+	@Override public long maxEUStore()								{return 0;}
+
+	@Override
+	public int getCapacity() {
+		return 0;
+	}
+
+	@Override
+	public long maxEUInput() {
+		return 0;
+	}
+
+	@Override
+	public long maxEUOutput() {
+		return 0;
+	}
+
+	@Override
+	public long maxAmperesIn() {
+		return 0;
+	}
+
+	@Override
+	public long maxAmperesOut() {
+		return 0;
+	}
+	@Override public int rechargerSlotStartIndex()					{return 0;}
+	@Override public int dechargerSlotStartIndex()					{return 0;}
+	@Override public int rechargerSlotCount()						{return 0;}
+	@Override public int dechargerSlotCount()						{return 0;}
+	@Override public int getProgresstime()							{return (int)this.getBaseMetaTileEntity().getUniversalEnergyStored();}
+	@Override public int maxProgresstime()							{return (int)this.getBaseMetaTileEntity().getUniversalEnergyCapacity();}
+	@Override public boolean isAccessAllowed(final EntityPlayer aPlayer)	{return true;}
+
+	@Override
+	public boolean onRightclick(final IGregTechTileEntity aBaseMetaTileEntity, final EntityPlayer aPlayer) {
+		if (aBaseMetaTileEntity.isClientSide())
+		{
+			return true;
+		}
+		this.showPollution(aPlayer.getEntityWorld(), aPlayer);
+		return true;
+	}
+
+	private void showPollution(final World worldIn, final EntityPlayer playerIn){
+		PlayerUtils.messagePlayer(playerIn, "Running every "+mFrequency+" minutes. Owner: "+this.getBaseMetaTileEntity().getOwnerName());
+		long aDiff = mLocalTickVar - this.mLastCleanup;	
+		PlayerUtils.messagePlayer(playerIn, "Last run: "+Utils.getSecondsFromMillis(aDiff)+" seconds ago.");		
+		
+		
+	}
+
+	@Override
+	public boolean allowPullStack(final IGregTechTileEntity aBaseMetaTileEntity, final int aIndex, final byte aSide, final ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public boolean allowPutStack(final IGregTechTileEntity aBaseMetaTileEntity, final int aIndex, final byte aSide, final ItemStack aStack) {
+		return false;
+	}
+
+
+	@Override
+	public String[] getInfoData() {
+		return new String[] {
+				this.getLocalName()
+				};
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(final int p_94128_1_) {
+		return new int[] {};
+	}
+
+	@Override
+	public boolean canInsertItem(final int p_102007_1_, final ItemStack p_102007_2_, final int p_102007_3_) {
+		return false;
+	}
+
+	@Override
+	public boolean canExtractItem(final int p_102008_1_, final ItemStack p_102008_2_, final int p_102008_3_) {
+		return false;
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(final int p_70301_1_) {
+		return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(final int p_70298_1_, final int p_70298_2_) {
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(final int p_70304_1_) {
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(final int p_70299_1_, final ItemStack p_70299_2_) {
+	}
+
+	@Override
+	public String getInventoryName() {
+		return null;
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return false;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return 0;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(final EntityPlayer p_70300_1_) {
+		return true;
+	}
+
+	@Override
+	public void openInventory() {
+	}
+
+	@Override
+	public void closeInventory() {
+	}
+
+	@Override
+	public boolean isItemValidForSlot(final int p_94041_1_, final ItemStack p_94041_2_) {
+		return false;
+	}
+
+	@Override
+	public boolean isOverclockerUpgradable() {
+		return false;
+	}
+
+	@Override
+	public boolean isTransformerUpgradable() {
+		return false;
+	}
+
+	@Override
+	public void saveNBTData(final NBTTagCompound aNBT) {
+		
+	}
+
+	@Override
+	public void loadNBTData(final NBTTagCompound aNBT) {
+		
+	}
+
+	@Override
+	public void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTick) {
+		super.onPostTick(aBaseMetaTileEntity, aTick);
+		if (this.getBaseMetaTileEntity().isServerSide()) {
+			mLocalTickVar = System.currentTimeMillis();
+			long aDiff = mLocalTickVar - this.mLastCleanup;			
+			if (Utils.getSecondsFromMillis(aDiff) >= (this.mFrequency * 60)) {
+				CORE.gc();
+				this.mLastCleanup = mLocalTickVar;
+			}
+		}		
+	}
+
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionCreator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionCreator.java
index c7f63e3bc2..4e5c296629 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionCreator.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionCreator.java
@@ -379,7 +379,7 @@ public class GregtechMetaPollutionCreator extends GregtechMetaTileEntity {
 		else {
 			returnValue = getCurrentChunkPollution();
 		}
-		Logger.INFO("| DEBUG: "+returnValue +" | ArrayPos:"+this.mArrayPos+" | Counter:"+counter+" | Total:"+total+" |");
+		//Logger.INFO("| DEBUG: "+returnValue +" | ArrayPos:"+this.mArrayPos+" | Counter:"+counter+" | Total:"+total+" |");
 		return returnValue;
 	}
 
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_CompactFusionReactor.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_CompactFusionReactor.java
index b4e819a459..477848a90f 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_CompactFusionReactor.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_CompactFusionReactor.java
@@ -131,15 +131,15 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 
 	@Override
 	public int checkRecipe() {
-		Logger.INFO("Recipe Tick 1.");
+		Logger.MACHINE_INFO("Recipe Tick 1.");
 		if (!this.mCanProcessRecipe) {
-			Logger.INFO("Recipe Tick 1.1 - Cannot Process Recipe.");
+			Logger.MACHINE_INFO("Recipe Tick 1.1 - Cannot Process Recipe.");
 			if (this.mChargeConsumed < mFusionPoint) {
-				Logger.INFO("Recipe Tick 1.2 - Cannot Ignite Fusion, Charge too low.");
+				Logger.MACHINE_INFO("Recipe Tick 1.2 - Cannot Ignite Fusion, Charge too low.");
 				this.mCharging = true;
 				this.mCanProcessRecipe = false;
 				if (this.getBaseMetaTileEntity().decreaseStoredEnergyUnits((mFusionPoint / 100), false)) {
-					Logger.INFO("Recipe Tick 1.3 - Charging Internal storage. " + (mFusionPoint / 100) + "/"
+					Logger.MACHINE_INFO("Recipe Tick 1.3 - Charging Internal storage. " + (mFusionPoint / 100) + "/"
 							+ mFusionPoint);
 					mChargeConsumed += (mFusionPoint / 100);
 				}
@@ -152,13 +152,13 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 			}
 		}
 		else {
-			Logger.INFO("Recipe Tick 1.1 - Try to Process Recipe.");
+			Logger.MACHINE_INFO("Recipe Tick 1.1 - Try to Process Recipe.");
 			if (checkRecipeMulti()) {
-				Logger.INFO("Recipe Tick 1.2 - Process Recipe was Successful.");
+				Logger.MACHINE_INFO("Recipe Tick 1.2 - Process Recipe was Successful.");
 				return 2;
 			}
 		}
-		Logger.INFO("Recipe Tick 2. - Process Recipe failed.");
+		Logger.MACHINE_INFO("Recipe Tick 2. - Process Recipe failed.");
 		return 0;
 	}
 
@@ -196,7 +196,7 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 			}
 			if ((tRecipe == null && !mRunningOnLoad) || (tRecipe != null && maxEUStore() < tRecipe.mSpecialValue)) {
 				this.mLastRecipe = null;
-				Logger.INFO("Just plain bad.");
+				Logger.MACHINE_INFO("Just plain bad.");
 				return false;
 			}
 			if (mRunningOnLoad || tRecipe.isRecipeInputEqual(true, tFluids, new ItemStack[] {})) {
@@ -397,38 +397,38 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
 		// super.onPostTick(aBaseMetaTileEntity, aTick);
 		if (aBaseMetaTileEntity.isServerSide()) {
-			// Logger.INFO("1");
+			// Logger.MACHINE_INFO("1");
 			if (mEfficiency < 0)
 				mEfficiency = 0;
 			if (mRunningOnLoad) {
-				Logger.INFO("2");
+				Logger.MACHINE_INFO("2");
 				this.mEUStore = (int) aBaseMetaTileEntity.getStoredEU();
 				checkRecipeMulti();
 			}
 			if (--mUpdate == 0 || --mStartUpCheck == 0) {
-				Logger.INFO("3");
+				Logger.MACHINE_INFO("3");
 				mMachine = true;
 			}
 			if (mStartUpCheck < 0) {
-				//Logger.INFO("4");
+				//Logger.MACHINE_INFO("4");
 				if (mMachine) {
-					//Logger.INFO("5");
+					//Logger.MACHINE_INFO("5");
 
 					if (aBaseMetaTileEntity.getStoredEU() + (2048 * tierOverclock()) < maxEUStore()) {
 						if (aBaseMetaTileEntity.increaseStoredEnergyUnits(2048 * tierOverclock(), true)) {
-							//Logger.INFO("5.5 A");							
+							//Logger.MACHINE_INFO("5.5 A");							
 						}
 						else {
-							//Logger.INFO("5.5 B");							
+							//Logger.MACHINE_INFO("5.5 B");							
 						}
 					}
 					if (this.mEUStore <= 0 && mMaxProgresstime > 0) {
-						Logger.INFO("6");
+						Logger.MACHINE_INFO("6");
 						stopMachine();
 						this.mLastRecipe = null;
 					}
 					if (mMaxProgresstime > 0) {
-						Logger.INFO("7");
+						Logger.MACHINE_INFO("7");
 						this.getBaseMetaTileEntity().decreaseStoredEnergyUnits(mEUt, true);
 						if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) {
 							if (mOutputFluids != null)
@@ -448,18 +448,18 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 						}
 					}
 					else {
-						//Logger.INFO("8");
+						//Logger.MACHINE_INFO("8");
 						this.mEUStore = (int) aBaseMetaTileEntity.getStoredEU();
 						if (aTick % 100 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled()
 								|| aBaseMetaTileEntity.hasInventoryBeenModified()) {
-							Logger.INFO("9");
+							Logger.MACHINE_INFO("9");
 							// turnCasingActive(mMaxProgresstime > 0);
 							if (aBaseMetaTileEntity.isAllowedToWork()) {
-								Logger.INFO("10");
+								Logger.MACHINE_INFO("10");
 								if (checkRecipeMulti()) {
-									Logger.INFO("11");
+									Logger.MACHINE_INFO("11");
 									if (this.mEUStore < this.mLastRecipe.mSpecialValue) {
-										Logger.INFO("12");
+										Logger.MACHINE_INFO("12");
 										mMaxProgresstime = 0;
 										// turnCasingActive(false);
 									}
@@ -473,12 +473,12 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 				}
 				else {
 					// turnCasingActive(false);
-					Logger.INFO("Bad");
+					Logger.MACHINE_INFO("Bad");
 					this.mLastRecipe = null;
 					stopMachine();
 				}
 			}
-			Logger.INFO("Good | "+mMaxProgresstime);
+			Logger.MACHINE_INFO("Good | "+mMaxProgresstime);
 			aBaseMetaTileEntity.setActive(mMaxProgresstime > 0);
 		}
 	}
@@ -489,14 +489,14 @@ public class GregtechMetaTileEntity_CompactFusionReactor extends GT_MetaTileEnti
 				if (!drainEnergyInput(((long) -mEUt * 10000) / Math.max(1000, mEfficiency))) {
 					this.mLastRecipe = null;
 					stopMachine();
-					Logger.INFO("a1");
+					Logger.MACHINE_INFO("a1");
 					return false;
 				}
 			}
 			if (this.mEUStore <= 0) {
 				this.mLastRecipe = null;
 				stopMachine();
-				Logger.INFO("a2");
+				Logger.MACHINE_INFO("a2");
 				return false;
 			}
 		}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_PocketFusion.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_PocketFusion.java
index 5a0f888ddb..8b3ada610d 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_PocketFusion.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_PocketFusion.java
@@ -131,15 +131,15 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 
 	@Override
 	public int checkRecipe() {
-		Logger.INFO("Recipe Tick 1.");
+		Logger.MACHINE_INFO("Recipe Tick 1.");
 		if (!this.mCanProcessRecipe) {
-			Logger.INFO("Recipe Tick 1.1 - Cannot Process Recipe.");
+			Logger.MACHINE_INFO("Recipe Tick 1.1 - Cannot Process Recipe.");
 			if (this.mChargeConsumed < mFusionPoint) {
-				Logger.INFO("Recipe Tick 1.2 - Cannot Ignite Fusion, Charge too low.");
+				Logger.MACHINE_INFO("Recipe Tick 1.2 - Cannot Ignite Fusion, Charge too low.");
 				this.mCharging = true;
 				this.mCanProcessRecipe = false;
 				if (this.getBaseMetaTileEntity().decreaseStoredEnergyUnits((mFusionPoint / 100), false)) {
-					Logger.INFO("Recipe Tick 1.3 - Charging Internal storage. " + (mFusionPoint / 100) + "/"
+					Logger.MACHINE_INFO("Recipe Tick 1.3 - Charging Internal storage. " + (mFusionPoint / 100) + "/"
 							+ mFusionPoint);
 					mChargeConsumed += (mFusionPoint / 100);
 				}
@@ -152,13 +152,13 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 			}
 		}
 		else {
-			Logger.INFO("Recipe Tick 1.1 - Try to Process Recipe.");
+			Logger.MACHINE_INFO("Recipe Tick 1.1 - Try to Process Recipe.");
 			if (checkRecipeMulti()) {
-				Logger.INFO("Recipe Tick 1.2 - Process Recipe was Successful.");
+				Logger.MACHINE_INFO("Recipe Tick 1.2 - Process Recipe was Successful.");
 				return 2;
 			}
 		}
-		Logger.INFO("Recipe Tick 2. - Process Recipe failed.");
+		Logger.MACHINE_INFO("Recipe Tick 2. - Process Recipe failed.");
 		return 0;
 	}
 
@@ -198,7 +198,7 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 			
 			if ((tRecipe == null && !mRunningOnLoad) || (tRecipe != null && maxEUStore() < tRecipe.mSpecialValue)) {
 				this.mLastRecipe = null;
-				Logger.INFO("Just plain bad.");
+				Logger.MACHINE_INFO("Just plain bad.");
 				return false;
 			}
 			if (mRunningOnLoad || tRecipe.isRecipeInputEqual(true, tFluids, new ItemStack[] {})) {
@@ -399,38 +399,38 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
 		// super.onPostTick(aBaseMetaTileEntity, aTick);
 		if (aBaseMetaTileEntity.isServerSide()) {
-			// Logger.INFO("1");
+			// Logger.MACHINE_INFO("1");
 			if (mEfficiency < 0)
 				mEfficiency = 0;
 			if (mRunningOnLoad) {
-				Logger.INFO("2");
+				Logger.MACHINE_INFO("2");
 				this.mEUStore = (int) aBaseMetaTileEntity.getStoredEU();
 				checkRecipeMulti();
 			}
 			if (--mUpdate == 0 || --mStartUpCheck == 0) {
-				Logger.INFO("3");
+				Logger.MACHINE_INFO("3");
 				mMachine = true;
 			}
 			if (mStartUpCheck < 0) {
-				//Logger.INFO("4");
+				//Logger.MACHINE_INFO("4");
 				if (mMachine) {
-					//Logger.INFO("5");
+					//Logger.MACHINE_INFO("5");
 
 					if (aBaseMetaTileEntity.getStoredEU() + (2048 * tierOverclock()) < maxEUStore()) {
 						if (aBaseMetaTileEntity.increaseStoredEnergyUnits(2048 * tierOverclock(), true)) {
-							//Logger.INFO("5.5 A");							
+							//Logger.MACHINE_INFO("5.5 A");							
 						}
 						else {
-							//Logger.INFO("5.5 B");							
+							//Logger.MACHINE_INFO("5.5 B");							
 						}
 					}
 					if (this.mEUStore <= 0 && mMaxProgresstime > 0) {
-						Logger.INFO("6");
+						Logger.MACHINE_INFO("6");
 						stopMachine();
 						this.mLastRecipe = null;
 					}
 					if (mMaxProgresstime > 0) {
-						Logger.INFO("7");
+						Logger.MACHINE_INFO("7");
 						this.getBaseMetaTileEntity().decreaseStoredEnergyUnits(mEUt, true);
 						if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) {
 							if (mOutputFluids != null)
@@ -450,18 +450,18 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 						}
 					}
 					else {
-						//Logger.INFO("8");
+						//Logger.MACHINE_INFO("8");
 						this.mEUStore = (int) aBaseMetaTileEntity.getStoredEU();
 						if (aTick % 100 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled()
 								|| aBaseMetaTileEntity.hasInventoryBeenModified()) {
-							Logger.INFO("9");
+							Logger.MACHINE_INFO("9");
 							// turnCasingActive(mMaxProgresstime > 0);
 							if (aBaseMetaTileEntity.isAllowedToWork()) {
-								Logger.INFO("10");
+								Logger.MACHINE_INFO("10");
 								if (checkRecipeMulti()) {
-									Logger.INFO("11");
+									Logger.MACHINE_INFO("11");
 									if (this.mEUStore < this.mLastRecipe.mSpecialValue) {
-										Logger.INFO("12");
+										Logger.MACHINE_INFO("12");
 										mMaxProgresstime = 0;
 										// turnCasingActive(false);
 									}
@@ -475,12 +475,12 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 				}
 				else {
 					// turnCasingActive(false);
-					Logger.INFO("Bad");
+					Logger.MACHINE_INFO("Bad");
 					this.mLastRecipe = null;
 					stopMachine();
 				}
 			}
-			Logger.INFO("Good | "+mMaxProgresstime);
+			Logger.MACHINE_INFO("Good | "+mMaxProgresstime);
 			aBaseMetaTileEntity.setActive(mMaxProgresstime > 0);
 		}
 	}
@@ -491,14 +491,14 @@ public class GregtechMetaTileEntity_PocketFusion extends GT_MetaTileEntity_Delux
 				if (!drainEnergyInput(((long) -mEUt * 10000) / Math.max(1000, mEfficiency))) {
 					this.mLastRecipe = null;
 					stopMachine();
-					Logger.INFO("a1");
+					Logger.MACHINE_INFO("a1");
 					return false;
 				}
 			}
 			if (this.mEUStore <= 0) {
 				this.mLastRecipe = null;
 				stopMachine();
-				Logger.INFO("a2");
+				Logger.MACHINE_INFO("a2");
 				return false;
 			}
 		}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialCentrifuge.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialCentrifuge.java
index 3f3a276f0c..9490fc678b 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialCentrifuge.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialCentrifuge.java
@@ -11,7 +11,6 @@ import gregtech.api.util.GT_Utility;
 import gregtech.api.util.Recipe_GT;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.core.block.ModBlocks;
-import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.minecraft.PlayerUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock.CustomIcon;
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java
new file mode 100644
index 0000000000..4cead1c2a8
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialDehydrator.java
@@ -0,0 +1,379 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing;
+
+import static gtPlusPlus.core.util.data.ArrayUtils.removeNulls;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import gregtech.api.enums.TAE;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.Recipe_GT;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import gtPlusPlus.xmod.gregtech.common.StaticFields59;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class GregtechMetaTileEntity_IndustrialDehydrator extends GregtechMeta_MultiBlockBase {
+	
+	private static int CASING_TEXTURE_ID;
+	private static String mCasingName = "Vacuum Casing";	
+	private int mHeatingCapacity = 0;
+	private boolean mDehydratorMode = false;
+
+	public GregtechMetaTileEntity_IndustrialDehydrator(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+		CASING_TEXTURE_ID = TAE.getIndexFromPage(3, 10);
+		mCasingName = ItemUtils.getLocalizedNameOfBlock(ModBlocks.blockCasings4Misc, 10);
+	}
+
+	public GregtechMetaTileEntity_IndustrialDehydrator(String aName) {
+		super(aName);
+		CASING_TEXTURE_ID = TAE.getIndexFromPage(3, 10);
+		mCasingName = ItemUtils.getLocalizedNameOfBlock(ModBlocks.blockCasings4Misc, 10);
+	}
+
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntity_IndustrialDehydrator(mName);
+	}
+
+	public String[] getTooltip() {		
+		if (mCasingName.toLowerCase().contains(".name")) {
+			mCasingName = ItemUtils.getLocalizedNameOfBlock(ModBlocks.blockCasings4Misc, 10);
+		}		
+		return new String[] { 				
+				"Factory Grade Vacuum Furnace",
+				"Can toggle the operation temperature with a Screwdriver",
+				"All Dehydrator recipes are Low Temp recipes",
+				"Speed: 120% | Eu Usage: 50% | Parallel: 4",
+				"Constructed exactly the same as a normal EBF",
+				"Has three layers of coils instead (24)",
+				"Use "+mCasingName+"s (10 at least!)",
+				"Each 900K over the min. Heat Capacity grants 5% speedup (multiplicatively)",
+				"Each 1800K over the min. Heat Capacity allows for one upgraded overclock",
+				"Upgraded overclocks reduce recipe time to 25% and increase EU/t to 400%",				
+		};
+	}
+
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex,
+			boolean aActive, boolean aRedstone) {
+		if (aSide == aFacing) {
+			return new ITexture[] { Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID],
+					new GT_RenderedTexture(aActive ? TexturesGtBlock.Overlay_Machine_Controller_Advanced_Active
+							: TexturesGtBlock.Overlay_Machine_Controller_Advanced) };
+		}
+		return new ITexture[] { Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID] };
+	}
+
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+		return mDehydratorMode ? Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes : Recipe_GT.Gregtech_Recipe_Map.sVacuumFurnaceRecipes;
+	}
+
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+		return true;
+	}
+
+	public boolean isFacingValid(byte aFacing) {
+		return aFacing > 1;
+	}
+
+
+	public boolean checkMultiblock(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+
+		this.mHeatingCapacity = 0;
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 1, zDir)) {
+			return false;
+		}
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 2, zDir)) {
+			return false;
+		}
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 3, zDir)) {
+			return false;
+		}
+		Block tUsedBlock = aBaseMetaTileEntity.getBlockOffset(xDir + 1, 2, zDir);
+		byte tUsedMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + 1, 2, zDir);
+		this.mHeatingCapacity = StaticFields59.getHeatingCapacityForCoil(tUsedBlock, tUsedMeta);
+
+		for (int i = -1; i < 2; i++) {
+			for (int j = -1; j < 2; j++) {
+				if ((i != 0) || (j != 0)) {					
+					//Coils 1
+					if (!isValidBlockForStructure(null, CASING_TEXTURE_ID, false, aBaseMetaTileEntity.getBlockOffset(xDir + i, 1, zDir + j), (int) aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 1, zDir + j), StaticFields59.getBlockCasings5(), tUsedMeta)) {
+						Logger.INFO("Heating Coils missing.");
+						return false;
+					}
+
+					//Coils 2
+					if (!isValidBlockForStructure(null, CASING_TEXTURE_ID, false, aBaseMetaTileEntity.getBlockOffset(xDir + i, 2, zDir + j), (int) aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 2, zDir + j), StaticFields59.getBlockCasings5(), tUsedMeta)) {
+						Logger.INFO("Heating Coils missing.");
+						return false;
+					}	
+					
+					//Coils 3
+					if (!isValidBlockForStructure(null, CASING_TEXTURE_ID, false, aBaseMetaTileEntity.getBlockOffset(xDir + i, 3, zDir + j), (int) aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 2, zDir + j), StaticFields59.getBlockCasings5(), tUsedMeta)) {
+						Logger.INFO("Heating Coils missing.");
+						return false;
+					}					
+				}
+				
+				//Top Layer
+				final IGregTechTileEntity tTileEntity2 = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 4, zDir + j);					
+				if (!isValidBlockForStructure(tTileEntity2, CASING_TEXTURE_ID, true, aBaseMetaTileEntity.getBlockOffset(xDir + i, 4, zDir + j), (int) aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 4, zDir + j), ModBlocks.blockCasings4Misc, 10)) {
+					Logger.INFO("Top Layer missing.");
+					return false;
+				}
+			}
+		}
+		for (int i = -1; i < 2; i++) {
+			for (int j = -1; j < 2; j++) {
+				if ((xDir + i != 0) || (zDir + j != 0)) {
+					IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 0,zDir + j);					
+					if (!isValidBlockForStructure(tTileEntity, CASING_TEXTURE_ID, true, aBaseMetaTileEntity.getBlockOffset(xDir + i, 0, zDir + j), (int) aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 0, zDir + j), ModBlocks.blockCasings4Misc, 10)) {
+						Logger.INFO("Bottom Layer missing.");
+						return false;
+					}					
+				}
+			}
+		}
+		return true;
+	}
+
+	public int getMaxEfficiency(ItemStack aStack) {
+		return 10000;
+	}
+
+	public int getPollutionPerTick(ItemStack aStack) {
+		return 25;
+	}
+
+	@Override
+	public boolean hasSlotInGUI() {
+		return true;
+	}
+
+	@Override
+	public String getMachineType() {
+		return "Vacuum Furnace / Dehydrator";
+	}
+
+	@Override
+	public int getMaxParallelRecipes() {
+		return 4;
+	}
+
+	@Override
+	public int getEuDiscountForParallelism() {
+		return 50;
+	}
+
+	@Override
+	public boolean requiresVanillaGtGUI() {
+		return true;
+	}
+
+	@Override
+	public String getCustomGUIResourceName() {
+		return "ElectricBlastFurnace";
+	}
+
+	public boolean checkRecipe(ItemStack aStack) {
+		return checkRecipeGeneric(getMaxParallelRecipes(), getEuDiscountForParallelism(), 120);
+	}
+
+	@Override
+	public boolean checkRecipeGeneric(ItemStack[] aItemInputs, FluidStack[] aFluidInputs, int aMaxParallelRecipes,
+			int aEUPercent, int aSpeedBonusPercent, int aOutputChanceRoll) {
+		// Based on the Processing Array. A bit overkill, but very flexible.
+
+		// Reset outputs and progress stats
+		this.mEUt = 0;
+		this.mMaxProgresstime = 0;
+		this.mOutputItems = new ItemStack[] {};
+		this.mOutputFluids = new FluidStack[] {};
+
+		long tVoltage = getMaxInputVoltage();
+		byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+		Logger.WARNING("Running checkRecipeGeneric(0)");
+
+		GT_Recipe tRecipe = this.getRecipeMap().findRecipe(getBaseMetaTileEntity(), mLastRecipe, false,
+				gregtech.api.enums.GT_Values.V[tTier], aFluidInputs, aItemInputs);
+
+		Logger.WARNING("Running checkRecipeGeneric(1)");
+		// Remember last recipe - an optimization for findRecipe()
+		this.mLastRecipe = tRecipe;
+
+		if (tRecipe == null || this.mHeatingCapacity < tRecipe.mSpecialValue) {
+			Logger.WARNING("BAD RETURN - 1");
+			return false;
+		}
+
+		if (!this.canBufferOutputs(tRecipe, aMaxParallelRecipes)) {
+			Logger.WARNING("BAD RETURN - 2");
+			return false;
+		}
+
+		// EU discount
+		float tRecipeEUt = (tRecipe.mEUt * aEUPercent) / 100.0f;
+		int tHeatCapacityDivTiers = (mHeatingCapacity - tRecipe.mSpecialValue) / 900;
+		float tTotalEUt = 0.0f;
+
+		int parallelRecipes = 0;
+		// Count recipes to do in parallel, consuming input items and fluids and
+		// considering input voltage limits
+		for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tVoltage - tRecipeEUt); parallelRecipes++) {
+			if (!tRecipe.isRecipeInputEqual(true, aFluidInputs, aItemInputs)) {
+				Logger.WARNING("Broke at " + parallelRecipes + ".");
+				break;
+			}
+			Logger.WARNING("Bumped EU from " + tTotalEUt + " to " + (tTotalEUt + tRecipeEUt) + ".");
+			tTotalEUt += tRecipeEUt;
+		}
+
+		if (parallelRecipes == 0) {
+			Logger.WARNING("BAD RETURN - 3");
+			return false;
+		}
+
+		// -- Try not to fail after this point - inputs have already been consumed! --
+
+		// Convert speed bonus to duration multiplier
+		// e.g. 100% speed bonus = 200% speed = 100%/200% = 50% recipe duration.
+		aSpeedBonusPercent = Math.max(-99, aSpeedBonusPercent);
+		float tTimeFactor = 100.0f / (100.0f + aSpeedBonusPercent);
+		this.mMaxProgresstime = (int) (tRecipe.mDuration * tTimeFactor);
+		int rInt = 2;
+
+		this.mEUt = (int) Math.ceil(tTotalEUt);
+
+		this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+		this.mEfficiencyIncrease = 10000;
+
+		// Overclock
+		if (this.mEUt <= 16) {
+			this.mEUt = (this.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+			this.mMaxProgresstime = (this.mMaxProgresstime / (1 << tTier - 1));
+		} else {
+			while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+				this.mEUt *= 4;
+				this.mMaxProgresstime /= (tHeatCapacityDivTiers >= rInt ? 4 : 2);
+			}
+		}
+
+		if (tHeatCapacityDivTiers > 0) {
+			this.mEUt = (int) (this.mEUt * (Math.pow(0.95, tHeatCapacityDivTiers)));
+		}
+		if (this.mEUt > 0) {
+			this.mEUt = (-this.mEUt);
+		}
+
+		this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+
+		// Collect fluid outputs
+		FluidStack[] tOutputFluids = new FluidStack[tRecipe.mFluidOutputs.length];
+		for (int h = 0; h < tRecipe.mFluidOutputs.length; h++) {
+			if (tRecipe.getFluidOutput(h) != null) {
+				tOutputFluids[h] = tRecipe.getFluidOutput(h).copy();
+				tOutputFluids[h].amount *= parallelRecipes;
+			}
+		}
+
+		// Collect output item types
+		ItemStack[] tOutputItems = new ItemStack[tRecipe.mOutputs.length];
+		for (int h = 0; h < tRecipe.mOutputs.length; h++) {
+			if (tRecipe.getOutput(h) != null) {
+				tOutputItems[h] = tRecipe.getOutput(h).copy();
+				tOutputItems[h].stackSize = 0;
+			}
+		}
+
+		// Set output item stack sizes (taking output chance into account)
+		for (int f = 0; f < tOutputItems.length; f++) {
+			if (tRecipe.mOutputs[f] != null && tOutputItems[f] != null) {
+				for (int g = 0; g < parallelRecipes; g++) {
+					if (getBaseMetaTileEntity().getRandomNumber(aOutputChanceRoll) < tRecipe.getOutputChance(f))
+						tOutputItems[f].stackSize += tRecipe.mOutputs[f].stackSize;
+				}
+			}
+		}
+
+		tOutputItems = removeNulls(tOutputItems);
+
+		// Sanitize item stack size, splitting any stacks greater than max stack size
+		List<ItemStack> splitStacks = new ArrayList<ItemStack>();
+		for (ItemStack tItem : tOutputItems) {
+			while (tItem.getMaxStackSize() < tItem.stackSize) {
+				ItemStack tmp = tItem.copy();
+				tmp.stackSize = tmp.getMaxStackSize();
+				tItem.stackSize = tItem.stackSize - tItem.getMaxStackSize();
+				splitStacks.add(tmp);
+			}
+		}
+
+		if (splitStacks.size() > 0) {
+			ItemStack[] tmp = new ItemStack[splitStacks.size()];
+			tmp = splitStacks.toArray(tmp);
+			tOutputItems = ArrayUtils.addAll(tOutputItems, tmp);
+		}
+
+		// Strip empty stacks
+		List<ItemStack> tSList = new ArrayList<ItemStack>();
+		for (ItemStack tS : tOutputItems) {
+			if (tS.stackSize > 0)
+				tSList.add(tS);
+		}
+		tOutputItems = tSList.toArray(new ItemStack[tSList.size()]);
+
+		// Commit outputs
+		this.mOutputItems = tOutputItems;
+		this.mOutputFluids = tOutputFluids;
+		updateSlots();
+
+		// Play sounds (GT++ addition - GT multiblocks play no sounds)
+		startProcess();
+
+		Logger.WARNING("GOOD RETURN - 1");
+		return true;
+
+	}
+
+	@Override
+	public void onModeChangeByScrewdriver(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+		mDehydratorMode = Utils.invertBoolean(mDehydratorMode);		
+		String aMode = mDehydratorMode ? "Dehydrator" : "Vacuum Furnace";		
+		PlayerUtils.messagePlayer(aPlayer, "Mode: "+aMode);
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		super.saveNBTData(aNBT);
+		aNBT.setBoolean("mDehydratorMode", mDehydratorMode);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		super.loadNBTData(aNBT);
+		mDehydratorMode = aNBT.getBoolean("mDehydratorMode");
+	}
+
+}
+
+
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialSifter.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialSifter.java
index 7c57f799d7..38306d914d 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialSifter.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialSifter.java
@@ -120,7 +120,7 @@ extends GregtechMeta_MultiBlockBase {
 	
 	@Override
 	protected boolean doesMachineBoostOutput() {
-		return true;
+		return false;
 	}
 	
 	@Override
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java
index ac362e2c40..dd00c9731d 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_EBF.java
@@ -28,6 +28,7 @@ import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 import gtPlusPlus.xmod.gregtech.common.StaticFields59;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
@@ -171,68 +172,9 @@ public class GregtechMetaTileEntity_Adv_EBF extends GregtechMeta_MultiBlockBase
 				CASING_TEXTURE_ID)) {
 			return false;
 		}*/
+		Block tUsedBlock = aBaseMetaTileEntity.getBlockOffset(xDir + 1, 2, zDir);
 		byte tUsedMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + 1, 2, zDir);
-
-		if (!CORE.GTNH) {
-			switch (tUsedMeta) {
-			case 0:
-				this.mHeatingCapacity = 1800;
-				break;
-			case 1:
-				this.mHeatingCapacity = 2700;
-				break;
-			case 2:
-				this.mHeatingCapacity = 3600;
-				break;
-			case 3:
-				this.mHeatingCapacity = 4500;
-				break;
-			case 4:
-				this.mHeatingCapacity = 5400;
-				break;
-			case 5:
-				this.mHeatingCapacity = 7200;
-				break;
-			case 6:
-				this.mHeatingCapacity = 9001;
-				break;
-			default:Logger.INFO("Heating Coils are bad.");
-				return false;
-			}
-		} else {
-			switch (tUsedMeta) {
-			case 0:
-				this.mHeatingCapacity = 1801;
-				break;
-			case 1:
-				this.mHeatingCapacity = 2701;
-				break;
-			case 2:
-				this.mHeatingCapacity = 3601;
-				break;
-			case 3:
-				this.mHeatingCapacity = 4501;
-				break;
-			case 4:
-				this.mHeatingCapacity = 5401;
-				break;
-			case 5:
-				this.mHeatingCapacity = 7201;
-				break;
-			case 6:
-				this.mHeatingCapacity = 9001;
-				break;
-			case 7:
-				this.mHeatingCapacity = 9901;
-				break;
-			case 8:
-				this.mHeatingCapacity = 10801;
-				break;
-			default:
-				Logger.INFO("Heating Coils are bad.");
-				return false;
-			}
-		}
+		this.mHeatingCapacity = StaticFields59.getHeatingCapacityForCoil(tUsedBlock, tUsedMeta);
 
 		for (int i = -1; i < 2; i++) {
 			for (int j = -1; j < 2; j++) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java
index 5ab9cd9795..c55fe10829 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java
@@ -7,6 +7,7 @@ import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Recipe;
@@ -19,6 +20,7 @@ import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.Gregtech
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
@@ -68,13 +70,29 @@ extends GregtechMeta_MultiBlockBase
 
 	@Override
 	public int getDamageToComponent(ItemStack aStack){
-		Logger.INFO("Trying to damage component.");
+		//log("Trying to damage component.");
 		return ItemList.Component_LavaFilter.get(1L).getClass().isInstance(aStack) ? 1 : 0;
 	}
+	
+	private static Item mLavaFilter;
 
 	@Override
-	public boolean checkRecipe(final ItemStack aStack) {
+	public boolean checkRecipe(ItemStack aStack) {
 		this.mSuperEfficencyIncrease=0;
+		
+		if (mLavaFilter == null) {
+			mLavaFilter = ItemList.Component_LavaFilter.getItem();
+		}
+		
+		//Try reload new Lava Filter
+		if (aStack == null) {
+			ItemStack uStack = this.findItemInInventory(mLavaFilter);
+			if (uStack != null) {				
+				this.setGUIItemStack(uStack);
+				aStack = this.getGUIItemStack();
+			}
+		}
+		
 
 		for (GT_Recipe tRecipe : Recipe_GT.Gregtech_Recipe_Map.sThermalFuels.mRecipeList) {
 			FluidStack tFluid = tRecipe.mFluidInputs[0];
@@ -85,7 +103,7 @@ extends GregtechMeta_MultiBlockBase
 					this.mEfficiencyIncrease = (this.mMaxProgresstime * getEfficiencyIncrease());
 
 					int loot_MAXCHANCE = 100000;
-					if (ItemList.Component_LavaFilter.get(1L).getClass().isInstance(aStack)) {
+					if (mLavaFilter.getClass().isInstance(aStack.getItem())) {
 
 						if ((tRecipe.getOutput(0) != null) && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE) < tRecipe.getOutputChance(0))) {
 							this.mOutputItems = new ItemStack[] { GT_Utility.copy(new Object[] { tRecipe.getOutput(0) }) };
@@ -199,8 +217,9 @@ extends GregtechMeta_MultiBlockBase
 				"Size: 3x3x3 (Hollow)",
 				"Thermal Containment Casings (10 at least!)",
 				"Controller (front middle)",
-				"2x Input Hatch",
+				"2x Input Hatch (Water/Thermal Fluid)",
 				"1x Output Hatch (Steam)",
+				"1x Input Bus (Supplies controller with Lava Filters, optional)",
 				"1x Output Bus (Filter results, optional)",
 				};
 	}
@@ -234,7 +253,7 @@ extends GregtechMeta_MultiBlockBase
 
 							if (!isValidBlockForStructure(tTileEntity, 1, true, aBlock, aMeta,
 									ModBlocks.blockCasings2Misc, 11)) {
-								Logger.INFO("Bad Thermal Boiler casing");
+								log("Bad Thermal Boiler casing");
 								return false;
 							}
 							++tAmount;
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java
index 5791cfbf73..33555c8f51 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java
@@ -2,7 +2,6 @@ package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production;
 
 import java.util.concurrent.ScheduledExecutorService;
 
-import gregtech.api.GregTech_API;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.TAE;
 import gregtech.api.enums.Textures;
@@ -19,9 +18,7 @@ import gtPlusPlus.api.objects.data.AutoMap;
 import gtPlusPlus.api.objects.minecraft.ThreadFakeWorldGenerator;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.util.math.MathUtils;
-import gtPlusPlus.core.util.minecraft.EnergyUtils;
 import gtPlusPlus.core.util.minecraft.EnergyUtils.EU;
-import gtPlusPlus.core.util.minecraft.FluidUtils;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
@@ -31,7 +28,6 @@ import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.FluidStack;
 
 public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase {
 
@@ -105,6 +101,7 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase
 		}
 
 		return new String[]{
+                "[WIP] Disabled",
 				"Converts EU to Oak Logs",
 				"Speed: Very Fast | Eu Usage: 100% | Parallel: 1",				
 				"Requires a Saw, Buzz Saw or Chainsaw in GUI slot",
@@ -152,6 +149,12 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase
 	}
 
 	public boolean checkRecipe(final ItemStack aStack) {
+	    
+	    if (true) {
+	        return false;
+	    }
+	    
+	    
 		//Logger.WARNING("Trying to process virtual tree farming");
 		if (mTreeData != null) {
 			//Logger.WARNING("Tree Data is valid");
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/bedrock/GregtechMetaTileEntity_BedrockMiningPlatformBase.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/bedrock/GregtechMetaTileEntity_BedrockMiningPlatformBase.java
index d264a759ec..736d0bc389 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/bedrock/GregtechMetaTileEntity_BedrockMiningPlatformBase.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/bedrock/GregtechMetaTileEntity_BedrockMiningPlatformBase.java
@@ -106,6 +106,11 @@ public abstract class GregtechMetaTileEntity_BedrockMiningPlatformBase extends G
 	public boolean checkRecipe(final ItemStack aStack) {
 		//this.setElectricityStats();
 
+	    
+	    if (true) {
+	        return false;
+	    }
+	    
 		boolean[] didWork = new boolean[5];
 		
 		if (!this.tryConsumeDrillingFluid()) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tools/TOOL_Gregtech_ElectricLighter.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tools/TOOL_Gregtech_ElectricLighter.java
index 36e1161e83..395a7c42cb 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tools/TOOL_Gregtech_ElectricLighter.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tools/TOOL_Gregtech_ElectricLighter.java
@@ -150,7 +150,7 @@ extends GT_Tool {
 
 	@Override
 	public IChatComponent getDeathMessage(final EntityLivingBase aPlayer, final EntityLivingBase aEntity) {
-		return new ChatComponentText(EnumChatFormatting.RED + aEntity.getCommandSenderName() + EnumChatFormatting.WHITE + " has been prodded out of existence by " + EnumChatFormatting.GREEN + aPlayer.getCommandSenderName() + EnumChatFormatting.WHITE);
+		return new ChatComponentText(EnumChatFormatting.RED + aEntity.getCommandSenderName() + EnumChatFormatting.WHITE + " has been burnt out of existence by " + EnumChatFormatting.GREEN + aPlayer.getCommandSenderName() + EnumChatFormatting.WHITE);
 	}
 
 	@Override
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java b/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java
index 461ac256f4..d8a5617b2e 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java
@@ -20,7 +20,6 @@ import gtPlusPlus.core.material.state.MaterialState;
 import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.math.MathUtils;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
-import gtPlusPlus.core.util.minecraft.MaterialUtils;
 import gtPlusPlus.core.util.minecraft.RecipeUtils;
 import net.minecraftforge.fluids.FluidStack;
 
@@ -193,16 +192,18 @@ public class RecipeGen_DustGeneration extends RecipeGen_Base {
 								if (x != null){
 									if (x.getStackMaterial() != null){
 										if (x.getStackMaterial().getDust(1) == null){
-											if (x.getStackMaterial().getState() == MaterialState.GAS || x.getStackMaterial().getState() == MaterialState.LIQUID || x.getStackMaterial().getState() == MaterialState.PURE_LIQUID){
+											if (x.getStackMaterial().getState() != MaterialState.SOLID && x.getStackMaterial().getState() != MaterialState.ORE && x.getStackMaterial().getState() != MaterialState.PLASMA){
 												oxygen = x.getStackMaterial().getFluid(1000);
+												break;
 											}
 										}
 									}
 								}
 							}
 						}
-
 					}
+					
+					input = ItemUtils.cleanItemStackArray(input);
 
 					//Add mixer Recipe
 					if (GT_Values.RA.addMixerRecipe(
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java b/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java
index f705ac9673..007f390112 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java
@@ -41,7 +41,9 @@ public class RecipeGen_Plates extends RecipeGen_Base {
 		final ItemStack shape_Mold = ItemList.Shape_Mold_Plate.get(0);
 		final ItemStack plate_Single = material.getPlate(1);
 		final ItemStack plate_SingleTwo = material.getPlate(2);
+		final ItemStack plate_SingleNine = material.getPlate(9);
 		final ItemStack plate_Double = material.getPlateDouble(1);
+		final ItemStack block = material.getBlock(1);
 
 		Logger.WARNING("Generating Plate recipes for "+material.getLocalizedName());
 
@@ -82,6 +84,19 @@ public class RecipeGen_Plates extends RecipeGen_Base {
 		else {
 			Logger.WARNING("Alloy Smelter Recipe: "+material.getLocalizedName()+" - Failed");
 		}
+		//Cutting Machine
+		if (ItemUtils.checkForInvalidItems(block) && ItemUtils.checkForInvalidItems(plate_Single))
+		if (GT_Values.RA.addCutterRecipe(
+				block,
+				null,
+				plate_SingleNine,
+				(int) Math.max(material.getMass() * 10L, 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Cutting Machine Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("ACutting Machine Recipe: "+material.getLocalizedName()+" - Failed");
+		}
 
 
 		//Making Double Plates
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java b/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java
index d16bffef86..7ef3b0b6dd 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java
@@ -12,7 +12,6 @@ import gregtech.api.enums.Materials;
 import gregtech.api.interfaces.internal.IGT_RecipeAdder;
 import gregtech.api.util.CustomRecipeMap;
 import gregtech.api.util.GT_Recipe;
-import gregtech.api.util.GT_Recipe.GT_Recipe_AssemblyLine;
 import gregtech.api.util.GT_Utility;
 import gregtech.api.util.Recipe_GT;
 import gregtech.api.util.SemiFluidFuelHandler;
@@ -23,7 +22,6 @@ import gtPlusPlus.core.lib.LoadedMods;
 import gtPlusPlus.core.material.MaterialGenerator;
 import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.data.ArrayUtils;
-import gtPlusPlus.core.util.minecraft.FluidUtils;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.core.util.reflect.ReflectionUtils;
 import gtPlusPlus.xmod.gregtech.api.interfaces.internal.IGregtech_RecipeAdder;
@@ -35,951 +33,953 @@ import net.minecraftforge.oredict.OreDictionary;
 
 public class GregtechRecipeAdder implements IGregtech_RecipeAdder {
 
-	@Override
-	public boolean addCokeOvenRecipe(final ItemStack aInput1, final ItemStack aInput2, final FluidStack aFluidInput,
-			final FluidStack aFluidOutput, final ItemStack aOutput, int aDuration, final int aEUt) {
-		try {
-			try {
-				// RECIPEHANDLER_CokeOven.debug1();
-				if (((aInput1 == null) /* && (aFluidInput == null) */)
-						|| ((aOutput == null) || (aFluidOutput == null))) {
-					// Utils.LOG_WARNING("aInput1:"+aInput1.toString()+"
-					// aInput2:"+aInput2.toString()+"
-					// aFluidInput:"+aFluidInput.toString()+"
-					// aFluidOutput:"+aFluidOutput.toString()+"
-					// aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
-					// aEU/t:"+aEUt);
-					Logger.WARNING("Something was null, returning false");
-					return false;
-				}
-
-			}
-			catch (final NullPointerException e) {
-				e.getStackTrace();
-			}
-			try {
-				// RECIPEHANDLER_CokeOven.debug2(aInput1, aInput2, aFluidInput,
-				// aFluidOutput, aOutput, aDuration, aEUt);
-				if ((aOutput != null)
-						&& ((aDuration = GregTech_API.sRecipeFile.get("cokeoven", aOutput, aDuration)) <= 0)) {
-					// Utils.LOG_WARNING("aInput1:"+aInput1.toString()+"
-					// aInput2:"+aInput2.toString()+"
-					// aFluidInput:"+aFluidInput.toString()+"
-					// aFluidOutput:"+aFluidOutput.toString()+"
-					// aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
-					// aEU/t:"+aEUt);
-					Logger.WARNING("Something was null, returning false");
-					return false;
-				}
-
-			}
-			catch (final NullPointerException e) {
-				e.getStackTrace();
-			}
-			try {
-				// RECIPEHANDLER_CokeOven.debug3(aInput1, aInput2, aFluidInput,
-				// aFluidOutput, aOutput, aDuration, aEUt);
-				if ((aFluidOutput == null) || ((aDuration = GregTech_API.sRecipeFile.get("cokeoven",
-						aFluidOutput.getFluid().getName(), aDuration)) <= 0)) {
-					// Utils.LOG_WARNING("aInput1:"+aInput1.toString()+"
-					// aInput2:"+aInput2.toString()+"
-					// aFluidInput:"+aFluidInput.toString()+"
-					// aFluidOutput:"+aFluidOutput.toString()+"
-					// aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
-					// aEU/t:"+aEUt);
-					Logger.WARNING("Something was null, returning false");
-					return false;
-				}
-
-			}
-			catch (final NullPointerException e) {
-				e.getStackTrace();
-			}
-			try {
-				// RECIPEHANDLER_CokeOven.debug4(aInput1, aInput2, aFluidInput,
-				// aFluidOutput, aOutput, aDuration, aEUt);
-				if (aFluidInput == null && aInput2 != null) {
-					Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.addRecipe(true, new ItemStack[] { aInput1, aInput2 },
-							new ItemStack[] { aOutput }, null, null, null, new FluidStack[] { aFluidOutput }, aDuration,
-							aEUt, 0);
-				}
-				else if (aFluidInput == null && aInput2 == null) {
-					Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.addRecipe(true, new ItemStack[] { aInput1 },
-							new ItemStack[] { aOutput }, null, null, null, new FluidStack[] { aFluidOutput }, aDuration,
-							aEUt, 0);
-				}
-				else {
-					Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.addRecipe(true, new ItemStack[] { aInput1, aInput2 },
-							new ItemStack[] { aOutput }, null, null, new FluidStack[] { aFluidInput },
-							new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
-				}
-				// RECIPEHANDLER_CokeOven.debug5(aInput1, aInput2, aFluidInput,
-				// aFluidOutput, aOutput, aDuration, aEUt);
-
-				return true;
-
-			}
-			catch (final NullPointerException e) {
-				Logger.WARNING("Something was null, returning false");
-				return false;
-			}
-		}
-		catch (final Throwable e) {
-			// Logger.WARNING("aInput1:"+aInput1.toString()+"
-			// aInput2:"+aInput2.toString()+"
-			// aFluidInput:"+aFluidInput.toString()+"
-			// aFluidOutput:"+aFluidOutput.toString()+"
-			// aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
-			// aEU/t:"+aEUt);
-			Logger.WARNING("Failed.");
-			e.getStackTrace();
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addMatterFabricatorRecipe(final FluidStack aFluidInput, final FluidStack aFluidOutput,
-			final int aDuration, final int aEUt) {
-		try {
-			try {
-				// RECIPEHANDLER_MatterFabricator.debug1();
-				if (aFluidOutput == null) {
-					// Utils.LOG_WARNING("aFluidInput:"+aFluidInput.toString()+"
-					// aFluidOutput:"+aFluidOutput.toString()+"
-					// aDuration:"+aDuration+" aEU/t:"+aEUt);
-					Logger.WARNING("Something was null, returning false");
-					return false;
-				}
-
-			}
-			catch (final NullPointerException e) {
-				e.getStackTrace();
-			}
-			try {
-
-				// RECIPEHANDLER_MatterFabricator.debug4(aFluidInput,
-				// aFluidOutput, aDuration, aEUt);
-				if (aFluidInput == null) {
-					// Recipe_GT.Gregtech_Recipe_Map.sMatterFabRecipes.addRecipe(true,
-					// null, new FluidStack[]{aFluidOutput}, aDuration, aEUt,
-					// 0);
-					Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, null, null, null, null,
-							new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
-				}
-				else {
-					// Recipe_GT.Gregtech_Recipe_Map.sMatterFabRecipes.addRecipe(true,
-					// new FluidStack[]{aFluidInput}, new
-					// FluidStack[]{aFluidOutput}, aDuration, aEUt, 0);
-					Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, null, null, null,
-							new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
-				}
-				RECIPEHANDLER_MatterFabricator.debug5(aFluidInput, aFluidOutput, aDuration, aEUt);
-
-				return true;
-
-			}
-			catch (final NullPointerException e) {
-				return false;
-			}
-		}
-		catch (final Throwable e) {
-			// Utils.LOG_WARNING("aFluidInput:"+aFluidInput.toString()+"
-			// aFluidOutput:"+aFluidOutput.toString()+" aDuration:"+aDuration+"
-			// aEU/t:"+aEUt);
-			Logger.WARNING("Failed.");
-			e.getStackTrace();
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addMatterFabricatorRecipe(final ItemStack aInputStack, final FluidStack aFluidInput,
-			final FluidStack aFluidOutput, final int aDuration, final int aEUt) {
-		try {
-			try {
-				if ((aFluidOutput == null) || (aInputStack == null)) {
-					return false;
-				}
-			}
-			catch (final NullPointerException e) {
-			}
-			try {
-				if (aFluidInput == null) {
-					Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, new ItemStack[] { aInputStack },
-							null, null, null, new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
-				}
-				else {
-					Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, new ItemStack[] { aInputStack },
-							null, null, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration,
-							aEUt, 0);
-				}
-				RECIPEHANDLER_MatterFabricator.debug5(aFluidInput, aFluidOutput, aDuration, aEUt);
-				return true;
-			}
-			catch (final NullPointerException e) {
-				return false;
-			}
-		}
-		catch (final Throwable e) {
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addFuel(final ItemStack aInput1, final ItemStack aOutput1, final int aEU, final int aType) {
-		if (aInput1 == null) {
-			Logger.WARNING("Fuel Input is Invalid.");
-			return false;
-		}
-		// new GregtechRecipe(aInput1, aOutput1,
-		// GregTech_API.sRecipeFile.get("fuel_" + aType, aInput1, aEU), aType);
-		return true;
-	}
-
-	/*
-	 * @Override public boolean addDehydratorRecipe(ItemStack aItemA, ItemStack
-	 * aItemB, FluidStack aFluid, ItemStack[] aOutputItems, FluidStack
-	 * aOutputFluid, int aDuration, int aEUt) { if ((aItemA == null) || (aItemB
-	 * == null) || (aOutputItems == null)) { return false; } for (ItemStack
-	 * tStack : aOutputItems) { if (tStack != null) { if ((aDuration =
-	 * GregTech_API.sRecipeFile.get("dehydrator", aItemA, aDuration)) <= 0) {
-	 * return false; }
-	 * Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true,
-	 * new ItemStack[]{aItemA, aItemB}, aOutputItems, null, null, null,
-	 * aDuration, aEUt, 0); RECIPEHANDLER_Dehydrator.debug5(aItemA, aItemB,
-	 * aFluid, aOutputFluid, aOutputItems, aDuration, aEUt); return true; } }
-	 * return false; }
-	 * @Override public boolean addDehydratorRecipe(ItemStack aItemA, ItemStack
-	 * aItemB, ItemStack[] aOutputItems, int aDuration, int aEUt) { if ((aItemA
-	 * == null) || (aItemB == null) || (aOutputItems == null)) { return false; }
-	 * if ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aItemA,
-	 * aDuration)) <= 0) { return false; }
-	 * Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true,
-	 * new ItemStack[]{aItemA, aItemB}, aOutputItems, null, null, null,
-	 * aDuration, aEUt, 0); RECIPEHANDLER_Dehydrator.debug5(aItemA, aItemB,
-	 * null, null, aOutputItems, aDuration, aEUt); return true; }
-	 * @Override public boolean addDehydratorRecipe(FluidStack aFluid,
-	 * FluidStack aOutputFluid, ItemStack[] aOutputItems, int aDuration, int
-	 * aEUt){ if ((aFluid == null) || (aOutputFluid == null || aOutputItems ==
-	 * null)) { return false; } if ((aDuration =
-	 * GregTech_API.sRecipeFile.get("dehydrator", aFluid.getUnlocalizedName(),
-	 * aDuration)) <= 0) { return false; }
-	 * Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true,
-	 * null, aOutputItems, null, new FluidStack[]{aFluid}, new
-	 * FluidStack[]{aOutputFluid}, aDuration, aEUt, 0);
-	 * RECIPEHANDLER_Dehydrator.debug5(null, null, aFluid, aOutputFluid,
-	 * aOutputItems, aDuration, aEUt); return true; }
-	 */
-
-	@Override
-	public boolean addDehydratorRecipe(final ItemStack aInput, final FluidStack aFluid, final ItemStack[] aOutput,
-			int aDuration, final int aEUt) {
-		Logger.WARNING("Trying to add a Dehydrator recipe.");
-		try {
-			if ((aInput == null) || (aFluid == null) || (aOutput == null)) {
-				return false;
-			}
-			if ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aInput, aDuration)) <= 0) {
-				return false;
-			}
-			Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, new ItemStack[] { aInput },
-					aOutput, null, new FluidStack[] { aFluid }, null, aDuration, aEUt, 0);
-			// RECIPEHANDLER_Dehydrator.debug5(aInput, null, aFluid, null,
-			// aOutput, aDuration, aEUt);
-			return true;
-		}
-		catch (final NullPointerException e) {
-			Logger.WARNING("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addDehydratorRecipe(final ItemStack[] aInput, final FluidStack aFluidInput,
-			final FluidStack aFluidOutput, final ItemStack[] aOutputItems, final int[] aChances, int aDuration,
-			final int aEUt) throws IndexOutOfBoundsException {
-		Logger.WARNING("Trying to add a Dehydrator recipe.");
-		try {
-			if (aInput[0] != null) {
-				Logger.WARNING("Recipe requires input: " + aInput[0].getDisplayName() + " x" + aInput[0].stackSize);
-			}
-			if (aInput.length > 1) {
-				if (aInput[1] != null) {
-					Logger.WARNING("Recipe requires input: " + aInput[1].getDisplayName() + " x" + aInput[1].stackSize);
-				}
-			}
-			if (aFluidInput != null) {
-				Logger.WARNING("Recipe requires input: " + aFluidInput.getFluid().getName() + " " + aFluidInput.amount
-						+ "mbst");
-			}
-			if (((aInput[0] == null) && (aFluidInput == null)) || ((aOutputItems == null) && (aFluidOutput == null))) {
-				return false;
-			}
-			if ((aOutputItems != null)
-					&& ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aOutputItems[0], aDuration)) <= 0)) {
-				return false;
-			}
-			if (aOutputItems != null) {
-				Logger.WARNING("Recipe will output: " + ItemUtils.getArrayStackNames(aOutputItems));
-			}
-			if ((aFluidOutput != null) && ((aDuration = GregTech_API.sRecipeFile.get("dehydrator",
-					aFluidOutput.getFluid().getName(), aDuration)) <= 0)) {
-				return false;
-			}
-			if (aFluidOutput != null) {
-				Logger.WARNING("Recipe will output: " + aFluidOutput.getFluid().getName());
-			}
-
-			if (aInput.length == 1) {
-				Logger.WARNING("Dehydrator recipe only has a single input item.");
-				Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, aInput, aOutputItems, null,
-						aChances, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt,
-						0);
-
-			}
-			else {
-				Logger.WARNING("Dehydrator recipe has two input items.");
-				Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, aInput, aOutputItems, null,
-						aChances, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt,
-						0);
-
-			}
-
-			return true;
-		}
-		catch (final NullPointerException e) {
-			Logger.WARNING("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addBlastSmelterRecipe(final ItemStack[] aInput, FluidStack aOutput, final int aChance, int aDuration,
-			final int aEUt) {
-		return addBlastSmelterRecipe(aInput, null, aOutput, new ItemStack[] {}, aChance, aDuration, aEUt, 3700);
-	}
-
-	@Override
-	public boolean addBlastSmelterRecipe(final ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput,
-			final int aChance, int aDuration, final int aEUt) {
-		return addBlastSmelterRecipe(aInput, aInputFluid, aOutput, new ItemStack[] {}, aChance, aDuration, aEUt, 3700);
-	}
-
-	@Override
-	public boolean addBlastSmelterRecipe(final ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack,
-			final int aChance, int aDuration, final int aEUt) {
-		return addBlastSmelterRecipe(aInput, aInputFluid, aOutput, aOutputStack, aChance, aDuration, aEUt, 3700);
-	}
-
-	@Override
-	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, int aChance,
-			int aDuration, int aEUt, int aSpecialValue) {
-		return addBlastSmelterRecipe(aInput, aInputFluid, aOutput, new ItemStack[] {}, aChance, aDuration, aEUt, aSpecialValue);		
-	}
-
-	@Override
-	public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack, int aChance,
-			int aDuration, int aEUt, int aSpecialValue) {
-		if ((aInput == null) || (aOutput == null)) {
-			Logger.WARNING("Fail - Input or Output was null.");
-			return false;
-		}
-
-		if (aOutput.isFluidEqual(Materials.PhasedGold.getMolten(1))) {
-			aOutput = Materials.VibrantAlloy.getMolten(aOutput.amount);
-		}
-		if (aOutput.isFluidEqual(Materials.PhasedIron.getMolten(1))) {
-			aOutput = Materials.PulsatingIron.getMolten(aOutput.amount);
-		}
-		if ((aDuration = GregTech_API.sRecipeFile.get("blastsmelter", aOutput.getFluid().getName(), aDuration)) <= 0) {
-			Logger.WARNING("Recipe did not register.");
-			return false;
-		}
-
-		for (int das = 0; das < aInput.length; das++) {
-			if (aInput[das] != null) {
-				Logger.WARNING("tMaterial[" + das + "]: " + aInput[das].getDisplayName() + ", Amount: "
-						+ aInput[das].stackSize);
-			}
-		}
-
-		ArrayUtils.removeNulls(aInput);
-		if (aInput.length <= 1) {
-			return false;
-		}		
-
-		Recipe_GT.Gregtech_Recipe_Map.sAlloyBlastSmelterRecipes.addRecipe(true, aInput, aOutputStack, null,
-				new int[] {}, new FluidStack[] { aInputFluid }, new FluidStack[] { aOutput }, aDuration, aEUt,
-				aSpecialValue);
-		return true;
-	}
-
-	@Override
-	public boolean addLFTRRecipe(final ItemStack aInput1, final FluidStack aInput2, final ItemStack aOutput1,
-			final FluidStack aOutput2, final int aDuration, final int aEUt) {
-		// TODO Auto-generated method stub
-		return false;
-	}
-
-	@Override
-	public boolean addLFTRRecipe(final ItemStack aInput1, final ItemStack aInput2, final ItemStack aOutput1,
-			final int aDuration, final int aEUt) {
-		return false;
-	}
-
-	@Override
-	public boolean addLFTRRecipe(final FluidStack aInput1, final FluidStack aInput2, final FluidStack aOutput1,
-			final int aDuration, final int aEUt) {
-		if ((aInput1 == null) || (aInput2 == null) || (aOutput1 == null) || (aDuration < 1) || (aEUt < 1)) {
-			return false;
-		}
-		Recipe_GT.Gregtech_Recipe_Map.sLiquidFluorineThoriumReactorRecipes.addRecipe(null,
-				new FluidStack[] { aInput1, aInput2 }, new FluidStack[] { aOutput1 }, aDuration, aEUt, 16000);
-		return true;
-	}
-
-	@Override
-	public boolean addFissionFuel(final FluidStack aInput1, final FluidStack aInput2, final FluidStack aInput3,
-			final FluidStack aInput4, final FluidStack aInput5, final FluidStack aInput6, final FluidStack aInput7,
-			final FluidStack aInput8, final FluidStack aInput9, final FluidStack aOutput1, final FluidStack aOutput2,
-			final int aDuration, final int aEUt) {
-
-		if ((aInput1 == null) || (aInput2 == null) || (aOutput1 == null) || (aDuration < 1) || (aEUt < 1)) {
-			return false;
-		}
-		final FluidStack inputs[] = { aInput1, aInput2, aInput3, aInput4, aInput5, aInput6, aInput7, aInput8, aInput9 };
-		final FluidStack outputs[] = { aOutput1, aOutput2 };
-		// Recipe_GT.Gregtech_Recipe_Map.sFissionFuelProcessing.addRecipe(null,
-		// inputs, outputs, aDuration, aEUt, 0);
-		CustomRecipeMap.sFissionFuelProcessing.addRecipe(null, inputs, outputs, aDuration, aEUt, 0);
-		return true;
-	}
-
-	@Override
-	public boolean addCyclotronRecipe(ItemStack aInputs, FluidStack aFluidInput, ItemStack[] aOutputs,
-			FluidStack aFluidOutput, int[] aChances, int aDuration, int aEUt, int aSpecialValue) {
-		return addCyclotronRecipe(new ItemStack[] {aInputs}, aFluidInput, aOutputs, aFluidOutput, aChances, aDuration, aEUt, aSpecialValue);
-	}
-
-	@Override
-	public boolean addCyclotronRecipe(ItemStack[] aInputs, FluidStack aFluidInput, ItemStack[] aOutput,
-			FluidStack aFluidOutput, int[] aChances, int aDuration, int aEUt, int aSpecialValue) {
-		if (aOutput == null || aOutput.length < 1 || !ItemUtils.checkForInvalidItems(aOutput)) {
-			return false;
-		}
-		if (Recipe_GT.Gregtech_Recipe_Map.sCyclotronRecipes.addRecipe(true, aInputs, aOutput,
-				null, aChances, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput },
-				Math.max(1, aDuration), Math.max(1, aEUt), aSpecialValue) != null) {
-			return true;
-		}
-
-		return false;
-	}
-
-	@Override
-	public boolean addMixerRecipe(ItemStack aInput1, ItemStack aInput2, ItemStack aInput3, ItemStack aInput4,
-			FluidStack aFluidInput, FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3,
-			ItemStack aOutput4, int aDuration, int aEUt) {
-		if (((aInput1 == null) && (aFluidInput == null)) || ((aOutput1 == null) && (aFluidOutput == null))) {
-			return false;
-		}
-		if ((aOutput1 != null)
-				&& ((aDuration = GregTech_API.sRecipeFile.get("advancedmixer", aOutput1, aDuration)) <= 0)) {
-			return false;
-		}
-		if ((aFluidOutput != null) && ((aDuration = GregTech_API.sRecipeFile.get("advancedmixer",
-				aFluidOutput.getFluid().getName(), aDuration)) <= 0)) {
-			return false;
-		}
-		Recipe_GT.Gregtech_Recipe_Map.sAdvancedMixerRecipes.addRecipe(true,
-				new ItemStack[] { aInput1, aInput2, aInput3, aInput4 },
-				new ItemStack[] { aOutput1, aOutput2, aOutput3, aOutput4 }, null, null,
-				new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
-		return true;
-	}
-
-	// Machine Component Assembler
-	@Override
-	public boolean addComponentMakerRecipe(ItemStack[] aInputs, FluidStack aFluidInput, ItemStack aOutput1,
-			int aDuration, int aEUt) {
-		if (areItemsAndFluidsBothNull(aInputs, new FluidStack[] { aFluidInput })) {
-			return false;
-		}
-		if (aOutput1 == null) {
-			return false;
-		}
-		if ((aDuration = GregTech_API.sRecipeFile.get("machinecomponents", aOutput1, aDuration)) <= 0) {
-			return false;
-		}
-		if (GTNH) {
-			return false;
-		}
-		Recipe_GT.Gregtech_Recipe_Map.sComponentAssemblerRecipes.addRecipe(true, aInputs, new ItemStack[] { aOutput1 },
-				null, new FluidStack[] { aFluidInput }, null, aDuration, aEUt, 0);
-		return true;
-	}
-
-
-	public boolean addMultiblockCentrifugeRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, int aSpecial){
-		if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) || aEUtick <= 0) {
-			return false;
-		}
-
-		if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) {
-			Logger.INFO("[Recipe] Error generating Large Centrifuge recipe.");
-			Logger.INFO("Inputs: "+ItemUtils.getArrayStackNames(aInputs));
-			Logger.INFO("Fluid Inputs: "+ItemUtils.getArrayStackNames(aFluidInputs));
-			Logger.INFO("Outputs: "+ItemUtils.getArrayStackNames(aOutputs));
-			Logger.INFO("Fluid Outputs: "+ItemUtils.getArrayStackNames(aFluidOutputs));
-			return false;
-		}
-		Recipe_GT.Gregtech_Recipe_Map.sMultiblockCentrifugeRecipes.addRecipe(true, aInputs, aOutputs, null, aChances, aFluidInputs, aFluidOutputs, aDuration, aEUtick, aSpecial);
-		return true;
-	}
-
-	public boolean addMultiblockElectrolyzerRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, int aSpecial){
-		if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) || aEUtick <= 0) {
-			return false;
-		}
-		if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) {
-			Logger.INFO("[Recipe] Error generating Large Electrolyzer recipe.");
-			Logger.INFO("Inputs: "+ItemUtils.getArrayStackNames(aInputs));
-			Logger.INFO("Fluid Inputs: "+ItemUtils.getArrayStackNames(aFluidInputs));
-			Logger.INFO("Outputs: "+ItemUtils.getArrayStackNames(aOutputs));
-			Logger.INFO("Fluid Outputs: "+ItemUtils.getArrayStackNames(aFluidOutputs));
-			return false;
-		}
-		Recipe_GT.Gregtech_Recipe_Map.sMultiblockElectrolyzerRecipes.addRecipe(true, aInputs, aOutputs, null, aChances, aFluidInputs, aFluidOutputs, aDuration, aEUtick, aSpecial);
-		return true;
-	}
-
-
-	public boolean addAdvancedFreezerRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, int aSpecial) {
-		if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) || aEUtick <= 0) {
-			return false;
-		}
-
-		if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) {
-			Logger.INFO("[Recipe] Error generating Adv. Vac Freezer recipe.");
-			Logger.INFO("Inputs: "+ItemUtils.getArrayStackNames(aInputs));
-			Logger.INFO("Fluid Inputs: "+ItemUtils.getArrayStackNames(aFluidInputs));
-			Logger.INFO("Outputs: "+ItemUtils.getArrayStackNames(aOutputs));
-			Logger.INFO("Fluid Outputs: "+ItemUtils.getArrayStackNames(aFluidOutputs));
-			return false;
-		}
-		if (Recipe_GT.Gregtech_Recipe_Map.sAdvFreezerRecipes.addRecipe(true, aInputs, aOutputs, null, aChances, aFluidInputs, aFluidOutputs, aDuration, aEUtick, aSpecial) != null) {
-			return true;
-		}
-		return false;	
-
-	}
-
-	public boolean addAssemblerRecipeWithOreDict(Object aInput1, int aAmount1, Object aInput2, int aAmount2, ItemStack aOutput, int a1, int a2) {		
-		if (aInput1 instanceof String || aInput2 instanceof String) {
-			int mCompleted = 0;
-			if (aInput1 instanceof String && aInput2 instanceof String) {
-				List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);
-				List<ItemStack> x1 = OreDictionary.getOres((String) aInput2, false);
-				if (x != null && x.size() > 0 && x1 != null && x1.size() > 0) {
-					for (ItemStack r : x) {
-						r.stackSize = aAmount1;
-						for (ItemStack r1 : x1) {
-							r1.stackSize = aAmount2;
-							if (GT_Values.RA.addAssemblerRecipe(r, r1, aOutput, a1, a2)) {
-								mCompleted++;
-							}
-						}
-					}
-				}
-			}
-			else if (aInput1 instanceof String) {
-				List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);				
-				if (x != null && x.size() > 0) {
-					for (ItemStack r : x) {
-						r.stackSize = aAmount1;
-						if (GT_Values.RA.addAssemblerRecipe(r, (ItemStack) aInput2, aOutput, a1, a2)) {
-							mCompleted++;
-						}
-					}
-				}
-
-			}
-			else {
-				List<ItemStack> x = OreDictionary.getOres((String) aInput2, false);	
-				if (x != null && x.size() > 0) {
-					for (ItemStack r : x) {
-						r.stackSize = aAmount1;
-						if (GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, r, aOutput, a1, a2)) {
-							mCompleted++;
-						}
-					}
-				}
-			}
-			return mCompleted > 0;
-		}
-		else {
-			return GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, (ItemStack) aInput2, aOutput, a1, a2);			
-		}		
-	}
-
-	public boolean addAssemblerRecipeWithOreDict(Object aInput1, int aAmount1, Object aInput2, int aAmount2, FluidStack aInputFluid, ItemStack aOutput, int a1, int a2) {
-		if (aInput1 instanceof String || aInput2 instanceof String) {
-			int mCompleted = 0;
-			if (aInput1 instanceof String && aInput2 instanceof String) {
-				List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);
-				List<ItemStack> x1 = OreDictionary.getOres((String) aInput2, false);
-				if (x != null && x.size() > 0 && x1 != null && x1.size() > 0) {
-					for (ItemStack r : x) {
-						r.stackSize = aAmount1;
-						for (ItemStack r1 : x1) {
-							r1.stackSize = aAmount2;
-							if (GT_Values.RA.addAssemblerRecipe(r, r1, aInputFluid, aOutput, a1, a2)) {
-								mCompleted++;
-							}
-						}
-					}
-				}
-			}
-			else if (aInput1 instanceof String) {
-				List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);				
-				if (x != null && x.size() > 0) {
-					for (ItemStack r : x) {
-						r.stackSize = aAmount1;
-						if (GT_Values.RA.addAssemblerRecipe(r, (ItemStack) aInput2, aInputFluid, aOutput, a1, a2)) {
-							mCompleted++;
-						}
-					}
-				}
-
-			}
-			else {
-				List<ItemStack> x = OreDictionary.getOres((String) aInput2, false);	
-				if (x != null && x.size() > 0) {
-					for (ItemStack r : x) {
-						r.stackSize = aAmount1;
-						if (GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, r, aInputFluid, aOutput, a1, a2)) {
-							mCompleted++;
-						}
-					}
-				}
-			}
-			return mCompleted > 0;
-		}
-		else {
-			return GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, (ItemStack) aInput2, aInputFluid, aOutput, a1, a2);			
-		}
-	}
-
-	/*
-	 * Reflection Based Recipe Additions with Fallbacks
-	 */
-
-	private static final  Method mSixSlotAssembly;
-	private static final  Method mAssemblyLine;
-	private static final  Method mScannerTT;
-	private static final  Method[] mChemicalRecipe = new Method[3];
-	private static final  Method mLargeChemReactor;
-
-	static {
-
-		//Get GT's RA class;
-		Class<? extends IGT_RecipeAdder> clazz = GT_Values.RA.getClass();		
-
-		mChemicalRecipe[0] = ReflectionUtils.getMethod(clazz, "addChemicalRecipe", ItemStack.class, ItemStack.class, FluidStack.class, FluidStack.class, ItemStack.class, int.class);
-
-
-		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK || CORE.GTNH) {	
-			//6 Slot Assembler
-			mSixSlotAssembly = ReflectionUtils.getMethod(clazz, "addAssemblerRecipe", ItemStack[].class, FluidStack.class, ItemStack.class, int.class, int.class);
-			//Assembly Line
-			mAssemblyLine = ReflectionUtils.getMethod(clazz, "addAssemblylineRecipe", ItemStack.class, int.class, ItemStack[].class, FluidStack[].class, ItemStack.class, int.class, int.class);
-
-
-			Method T = null;
-			if (LoadedMods.TecTech) {
-					Class TTRecipeAdder = ReflectionUtils.getClass("com.github.technus.tectech.recipe.TT_recipeAdder");
-					if (TTRecipeAdder != null) {
-						Method ttTest = ReflectionUtils.getMethod(TTRecipeAdder, "addResearchableAssemblylineRecipe",
-								ItemStack.class, int.class, int.class, int.class, int.class, Object[].class,
-								FluidStack[].class, ItemStack.class, int.class, int.class);
-						if (ttTest != null) {
-							T = ttTest;
-						}
-					}
-			}
-			else {
-				T = null;
-			}
-			mScannerTT = T;
-
-			mChemicalRecipe[1] = ReflectionUtils.getMethod(clazz, "addChemicalRecipe", ItemStack.class, ItemStack.class, FluidStack.class, FluidStack.class, ItemStack.class, int.class, int.class);
-			mChemicalRecipe[2] = ReflectionUtils.getMethod(clazz, "addChemicalRecipe", ItemStack.class, ItemStack.class, FluidStack.class, FluidStack.class, ItemStack.class, ItemStack.class, int.class);
-
-			mLargeChemReactor = ReflectionUtils.getMethod(clazz, "addMultiblockChemicalRecipe", ItemStack[].class, FluidStack[].class, FluidStack[].class, ItemStack[].class, int.class, int.class);
-
-
-
-		}
-		else {
-			mSixSlotAssembly = null;
-			mAssemblyLine = null;
-			mLargeChemReactor = null;
-			mScannerTT = null;
-		}
-
-
-	}
-
-
-
-
-
-
-	public boolean addSixSlotAssemblingRecipe(ItemStack[] aInputs, FluidStack aInputFluid, ItemStack aOutput1, int aDuration, int aEUt) {
-		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK || CORE.GTNH) {			
-			if (mSixSlotAssembly != null) {
-				try {
-					return (boolean) mSixSlotAssembly.invoke(GT_Values.RA, aInputs, aInputFluid, aOutput1, aDuration, aEUt);
-				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-					if (CORE.GTNH) {
-						return false;
-					}
-				}
-			}		
-		}
-		return CORE.RA.addComponentMakerRecipe(aInputs, aInputFluid, aOutput1, aDuration, aEUt);		
-	}
-
-	public boolean addAssemblylineRecipe(ItemStack aResearchItem, int aResearchTime, ItemStack[] aInputs, FluidStack[] aFluidInputs_OLD, ItemStack aOutput, int aDuration, int aEUt) {
-		
-		FluidStack[] aFluidInputs = new FluidStack[4];	
-		AutoMap<FluidStack> aNewFluidMap = new AutoMap<FluidStack>();
-		if (aFluidInputs_OLD.length > 4) {
-			for (FluidStack s : aFluidInputs_OLD) {
-				aNewFluidMap.put(s);
-			}
-			for (int i = 0; i < 4; i++) {
-				aFluidInputs[i] = aNewFluidMap.get(i);				
-			}
-		}
-		else {
-			aFluidInputs = aFluidInputs_OLD;
-		}
-		
-		
-		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
-			if (aInputs.length < 6 && aFluidInputs.length < 2) {
-				ItemStack[] aInputStack = new ItemStack[] {aResearchItem, aInputs[0], aInputs[1], aInputs[2], aInputs[3], aInputs[4]};
-				return addSixSlotAssemblingRecipe(aInputStack, aFluidInputs[0], aOutput, aDuration, aEUt);
-			}        	
-			return false;
-		}
-		else {
-			if ((aResearchItem==null)||(aResearchTime<=0)||(aInputs == null) || (aOutput == null) || aInputs.length>15 || aInputs.length<4) {
-				return false;
-			}
-			else {
-				if (mAssemblyLine != null) {
-					try {						
-						if (!tryAddTecTechScannerRecipe(aResearchItem, aInputs, aFluidInputs, aOutput, aDuration, aEUt)) {
-							try {								
-								Logger.INFO("Failed to generate TecTech recipe for "+ItemUtils.getItemName(aResearchItem)+", please report this to Alkalus.");
-							}
-							catch (Throwable t) {
-								
-							}
-						}
-						return (boolean) mAssemblyLine.invoke(GT_Values.RA, aResearchItem, aResearchTime, aInputs,
-								aFluidInputs, aOutput, aDuration, aEUt);
-					} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-						if (aInputs.length < 6 && aFluidInputs.length < 2) {
-							ItemStack[] aInputStack = new ItemStack[] { aResearchItem, aInputs[0], aInputs[1],
-									aInputs[2], aInputs[3], aInputs[4] };
-							return addSixSlotAssemblingRecipe(aInputStack, aFluidInputs[0], aOutput, aDuration,
-									aEUt);
-						}
-						return false;
-					}
-				} else {
-					if (aInputs.length < 6 && aFluidInputs.length < 2) {
-						ItemStack[] aInputStack = new ItemStack[] { aResearchItem, aInputs[0], aInputs[1], aInputs[2],
-								aInputs[3], aInputs[4] };
-						return addSixSlotAssemblingRecipe(aInputStack, aFluidInputs[0], aOutput, aDuration,
-								aEUt);
-					}
-					return false;
-				}
-			}		
-		}
-	}
-
-	private boolean tryAddTecTechScannerRecipe(ItemStack aResearchItem,	Object[] aInputs, FluidStack[] aFluidInputs, ItemStack aOutput, int assDuration, int assEUt) {
-		if (!LoadedMods.TecTech) {
-			return true;
-		}
-		else {
-
-			int compSec = (GT_Utility.getTier(assEUt)+1) * 16;
-			int compMax = (GT_Utility.getTier(assEUt)+1) * 10000;
-
-			if (mScannerTT != null) {
-				try {
-					boolean aResult = (boolean) mScannerTT.invoke(null, aResearchItem, compMax, compSec,
-							(assEUt/2), 16, aInputs, aFluidInputs, aOutput, assDuration, assEUt);					
-					Logger.INFO("Added TecTech Scanner Recipe for "+ItemUtils.getItemName(aResearchItem)+"? "+aResult);
-					return aResult;
-					
-				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-					Logger.INFO("Failed to generate TecTech recipe for "+ItemUtils.getItemName(aResearchItem)+", please report this to Alkalus. [Severe]");
-					e.printStackTrace();
-				}
-			}			
-		}
-		return false;
-	}
-
-
-	public boolean addChemicalRecipe(ItemStack input1, ItemStack input2, FluidStack inputFluid, FluidStack outputFluid, ItemStack output, int time, int eu){
-		return addChemicalRecipe(input1, input2, inputFluid, outputFluid, output, null, time, eu);
-	}
-
-	@Override
-	public boolean addChemicalRecipe(ItemStack input1, ItemStack input2, FluidStack inputFluid, FluidStack outputFluid,	ItemStack output, Object object, int time, int eu) {
-		try {
-			if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
-				return (boolean) mChemicalRecipe[0].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, time);
-			}
-			else {
-				return (boolean) mChemicalRecipe[1].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, time, eu);
-			}
-		}
-		catch (Throwable t) {
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addChemicalRecipe(ItemStack input1, ItemStack input2, FluidStack inputFluid, FluidStack outputFluid,	ItemStack output, ItemStack output2, int time) {
-		try {
-			if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
-				return (boolean) mChemicalRecipe[0].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, time);
-			}
-			else {
-				return (boolean) mChemicalRecipe[2].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, output2, time);
-			}
-		}
-		catch (Throwable t) {
-			return false;
-		}
-	}
-
-	@Override
-	public boolean addMultiblockChemicalRecipe(ItemStack[] itemStacks, FluidStack[] fluidStacks, FluidStack[] fluidStacks2, ItemStack[] outputs, int time, int eu) {
-		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK || mLargeChemReactor == null) {
-			return false;
-		}		
-		try {			
-			return (boolean) mLargeChemReactor.invoke(GT_Values.RA, itemStacks, fluidStacks, fluidStacks2, outputs, time, eu);
-		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-			return false;
-		}		
-	}
-
-
-
-
-
-
-
-
-	private boolean areItemsAndFluidsBothNull(final ItemStack[] items, final FluidStack[] fluids) {
-		boolean itemsNull = true;
-		if (items != null) {
-			for (final ItemStack itemStack : items) {
-				if (itemStack != null) {
-					itemsNull = false;
-					break;
-				}
-			}
-		}
-		boolean fluidsNull = true;
-		if (fluids != null) {
-			for (final FluidStack fluidStack : fluids) {
-				if (fluidStack != null) {
-					fluidsNull = false;
-					break;
-				}
-			}
-		}
-		return itemsNull && fluidsNull;
-	}
-
-	@Override
-	public boolean addCompressorRecipe(ItemStack aInput1, ItemStack aOutput1, int aDuration, int aEUt) {
-		if ((aInput1 == null) || (aOutput1 == null)) {
-			return false;
-		}
-		if ((aInput1 != null) && ((aDuration = GregTech_API.sRecipeFile.get("compressor", aInput1, aDuration)) <= 0)) {
-			return false;
-		}
-		GT_Recipe.GT_Recipe_Map.sCompressorRecipes.addRecipe(true, new ItemStack[]{aInput1}, new ItemStack[]{aOutput1}, null, null, null, aDuration, aEUt, 0);
-		return true;
-	}
-
-	@Override
-	public boolean addBrewingRecipe(int aCircuit, FluidStack aInput, FluidStack aOutput, int aTime, int aEu, boolean aHidden) {
-		return addBrewingRecipe(CI.getNumberedCircuit(aCircuit), aInput, aOutput, aTime, aEu, aHidden);
-	}
-
-	@Override
-	public boolean addBrewingRecipe(ItemStack aIngredient, FluidStack aInput, FluidStack aOutput, int aTime, int aEu, boolean aHidden) {
-		if ((aIngredient == null) || (aInput == null) || (aOutput == null)) {
-			return false;
-		}
-		if (!GregTech_API.sRecipeFile.get("brewing", aOutput.getUnlocalizedName(), true)) {
-			return false;
-		}
-		GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sBrewingRecipes.addRecipe(false, new ItemStack[]{aIngredient}, null, null, new FluidStack[]{aInput}, new FluidStack[]{aOutput}, aTime, aEu, 0);
-		if ((aHidden) && (tRecipe != null)) {
-			tRecipe.mHidden = true;
-		}
-		return true;
-	}
-
-
-	/**
-	 *  Lets me add recipes for GT 5.08 & 5.09, since someone broke the method headers.
-	 */
-	@Override
-	public boolean addSmeltingAndAlloySmeltingRecipe(ItemStack aDust, ItemStack aOutput) {		
-		Method m = StaticFields59.mAddFurnaceRecipe;		
-		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
-			try {
-				return (boolean) m.invoke(null, aDust, aOutput);
-			} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-				return false;
-			}
-		}
-		else {
-			try {
-				return (boolean) m.invoke(null, aDust, aOutput, true);
-			} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-				return false;
-			}
-		}
-	}
-
-	@Override
-	public void addFluidExtractionRecipe(ItemStack input, Object input2, FluidStack output, int aTime, int aEu,	int aSpecial) {
-		MaterialGenerator.addFluidExtractionRecipe(input, input2, output, aSpecial, aTime, aEu);
-		
-	}
-	
-	
-
-
-	 
-	/**
+    @Override
+    public boolean addCokeOvenRecipe(final ItemStack aInput1, final ItemStack aInput2, final FluidStack aFluidInput,
+            final FluidStack aFluidOutput, final ItemStack aOutput, int aDuration, final int aEUt) {
+        try {
+            try {
+                // RECIPEHANDLER_CokeOven.debug1();
+                if (((aInput1 == null) /* && (aFluidInput == null) */)
+                        || ((aOutput == null) || (aFluidOutput == null))) {
+                    // Utils.LOG_WARNING("aInput1:"+aInput1.toString()+"
+                    // aInput2:"+aInput2.toString()+"
+                    // aFluidInput:"+aFluidInput.toString()+"
+                    // aFluidOutput:"+aFluidOutput.toString()+"
+                    // aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
+                    // aEU/t:"+aEUt);
+                    Logger.WARNING("Something was null, returning false");
+                    return false;
+                }
+
+            }
+            catch (final NullPointerException e) {
+                e.getStackTrace();
+            }
+            try {
+                // RECIPEHANDLER_CokeOven.debug2(aInput1, aInput2, aFluidInput,
+                // aFluidOutput, aOutput, aDuration, aEUt);
+                if ((aOutput != null)
+                        && ((aDuration = GregTech_API.sRecipeFile.get("cokeoven", aOutput, aDuration)) <= 0)) {
+                    // Utils.LOG_WARNING("aInput1:"+aInput1.toString()+"
+                    // aInput2:"+aInput2.toString()+"
+                    // aFluidInput:"+aFluidInput.toString()+"
+                    // aFluidOutput:"+aFluidOutput.toString()+"
+                    // aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
+                    // aEU/t:"+aEUt);
+                    Logger.WARNING("Something was null, returning false");
+                    return false;
+                }
+
+            }
+            catch (final NullPointerException e) {
+                e.getStackTrace();
+            }
+            try {
+                // RECIPEHANDLER_CokeOven.debug3(aInput1, aInput2, aFluidInput,
+                // aFluidOutput, aOutput, aDuration, aEUt);
+                if ((aFluidOutput == null) || ((aDuration = GregTech_API.sRecipeFile.get("cokeoven",
+                        aFluidOutput.getFluid().getName(), aDuration)) <= 0)) {
+                    // Utils.LOG_WARNING("aInput1:"+aInput1.toString()+"
+                    // aInput2:"+aInput2.toString()+"
+                    // aFluidInput:"+aFluidInput.toString()+"
+                    // aFluidOutput:"+aFluidOutput.toString()+"
+                    // aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
+                    // aEU/t:"+aEUt);
+                    Logger.WARNING("Something was null, returning false");
+                    return false;
+                }
+
+            }
+            catch (final NullPointerException e) {
+                e.getStackTrace();
+            }
+            try {
+                // RECIPEHANDLER_CokeOven.debug4(aInput1, aInput2, aFluidInput,
+                // aFluidOutput, aOutput, aDuration, aEUt);
+                if (aFluidInput == null && aInput2 != null) {
+                    Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.addRecipe(true, new ItemStack[] { aInput1, aInput2 },
+                            new ItemStack[] { aOutput }, null, null, null, new FluidStack[] { aFluidOutput }, aDuration,
+                            aEUt, 0);
+                }
+                else if (aFluidInput == null && aInput2 == null) {
+                    Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.addRecipe(true, new ItemStack[] { aInput1 },
+                            new ItemStack[] { aOutput }, null, null, null, new FluidStack[] { aFluidOutput }, aDuration,
+                            aEUt, 0);
+                }
+                else {
+                    Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.addRecipe(true, new ItemStack[] { aInput1, aInput2 },
+                            new ItemStack[] { aOutput }, null, null, new FluidStack[] { aFluidInput },
+                            new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
+                }
+                // RECIPEHANDLER_CokeOven.debug5(aInput1, aInput2, aFluidInput,
+                // aFluidOutput, aOutput, aDuration, aEUt);
+
+                return true;
+
+            }
+            catch (final NullPointerException e) {
+                Logger.WARNING("Something was null, returning false");
+                return false;
+            }
+        }
+        catch (final Throwable e) {
+            // Logger.WARNING("aInput1:"+aInput1.toString()+"
+            // aInput2:"+aInput2.toString()+"
+            // aFluidInput:"+aFluidInput.toString()+"
+            // aFluidOutput:"+aFluidOutput.toString()+"
+            // aOutput:"+aOutput.toString()+" aDuration:"+aDuration+"
+            // aEU/t:"+aEUt);
+            Logger.WARNING("Failed.");
+            e.getStackTrace();
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addMatterFabricatorRecipe(final FluidStack aFluidInput, final FluidStack aFluidOutput,
+            final int aDuration, final int aEUt) {
+        try {
+            try {
+                // RECIPEHANDLER_MatterFabricator.debug1();
+                if (aFluidOutput == null) {
+                    // Utils.LOG_WARNING("aFluidInput:"+aFluidInput.toString()+"
+                    // aFluidOutput:"+aFluidOutput.toString()+"
+                    // aDuration:"+aDuration+" aEU/t:"+aEUt);
+                    Logger.WARNING("Something was null, returning false");
+                    return false;
+                }
+
+            }
+            catch (final NullPointerException e) {
+                e.getStackTrace();
+            }
+            try {
+
+                // RECIPEHANDLER_MatterFabricator.debug4(aFluidInput,
+                // aFluidOutput, aDuration, aEUt);
+                if (aFluidInput == null) {
+                    // Recipe_GT.Gregtech_Recipe_Map.sMatterFabRecipes.addRecipe(true,
+                    // null, new FluidStack[]{aFluidOutput}, aDuration, aEUt,
+                    // 0);
+                    Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, null, null, null, null,
+                            new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
+                }
+                else {
+                    // Recipe_GT.Gregtech_Recipe_Map.sMatterFabRecipes.addRecipe(true,
+                    // new FluidStack[]{aFluidInput}, new
+                    // FluidStack[]{aFluidOutput}, aDuration, aEUt, 0);
+                    Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, null, null, null,
+                            new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
+                }
+                RECIPEHANDLER_MatterFabricator.debug5(aFluidInput, aFluidOutput, aDuration, aEUt);
+
+                return true;
+
+            }
+            catch (final NullPointerException e) {
+                return false;
+            }
+        }
+        catch (final Throwable e) {
+            // Utils.LOG_WARNING("aFluidInput:"+aFluidInput.toString()+"
+            // aFluidOutput:"+aFluidOutput.toString()+" aDuration:"+aDuration+"
+            // aEU/t:"+aEUt);
+            Logger.WARNING("Failed.");
+            e.getStackTrace();
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addMatterFabricatorRecipe(final ItemStack aInputStack, final FluidStack aFluidInput,
+            final FluidStack aFluidOutput, final int aDuration, final int aEUt) {
+        try {
+            try {
+                if ((aFluidOutput == null) || (aInputStack == null)) {
+                    return false;
+                }
+            }
+            catch (final NullPointerException e) {
+            }
+            try {
+                if (aFluidInput == null) {
+                    Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, new ItemStack[] { aInputStack },
+                            null, null, null, new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
+                }
+                else {
+                    Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.addRecipe(true, new ItemStack[] { aInputStack },
+                            null, null, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration,
+                            aEUt, 0);
+                }
+                RECIPEHANDLER_MatterFabricator.debug5(aFluidInput, aFluidOutput, aDuration, aEUt);
+                return true;
+            }
+            catch (final NullPointerException e) {
+                return false;
+            }
+        }
+        catch (final Throwable e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addFuel(final ItemStack aInput1, final ItemStack aOutput1, final int aEU, final int aType) {
+        if (aInput1 == null) {
+            Logger.WARNING("Fuel Input is Invalid.");
+            return false;
+        }
+        // new GregtechRecipe(aInput1, aOutput1,
+        // GregTech_API.sRecipeFile.get("fuel_" + aType, aInput1, aEU), aType);
+        return true;
+    }
+
+    /*
+     * @Override public boolean addDehydratorRecipe(ItemStack aItemA, ItemStack
+     * aItemB, FluidStack aFluid, ItemStack[] aOutputItems, FluidStack
+     * aOutputFluid, int aDuration, int aEUt) { if ((aItemA == null) || (aItemB
+     * == null) || (aOutputItems == null)) { return false; } for (ItemStack
+     * tStack : aOutputItems) { if (tStack != null) { if ((aDuration =
+     * GregTech_API.sRecipeFile.get("dehydrator", aItemA, aDuration)) <= 0) {
+     * return false; }
+     * Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true,
+     * new ItemStack[]{aItemA, aItemB}, aOutputItems, null, null, null,
+     * aDuration, aEUt, 0); RECIPEHANDLER_Dehydrator.debug5(aItemA, aItemB,
+     * aFluid, aOutputFluid, aOutputItems, aDuration, aEUt); return true; } }
+     * return false; }
+     * @Override public boolean addDehydratorRecipe(ItemStack aItemA, ItemStack
+     * aItemB, ItemStack[] aOutputItems, int aDuration, int aEUt) { if ((aItemA
+     * == null) || (aItemB == null) || (aOutputItems == null)) { return false; }
+     * if ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aItemA,
+     * aDuration)) <= 0) { return false; }
+     * Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true,
+     * new ItemStack[]{aItemA, aItemB}, aOutputItems, null, null, null,
+     * aDuration, aEUt, 0); RECIPEHANDLER_Dehydrator.debug5(aItemA, aItemB,
+     * null, null, aOutputItems, aDuration, aEUt); return true; }
+     * @Override public boolean addDehydratorRecipe(FluidStack aFluid,
+     * FluidStack aOutputFluid, ItemStack[] aOutputItems, int aDuration, int
+     * aEUt){ if ((aFluid == null) || (aOutputFluid == null || aOutputItems ==
+     * null)) { return false; } if ((aDuration =
+     * GregTech_API.sRecipeFile.get("dehydrator", aFluid.getUnlocalizedName(),
+     * aDuration)) <= 0) { return false; }
+     * Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true,
+     * null, aOutputItems, null, new FluidStack[]{aFluid}, new
+     * FluidStack[]{aOutputFluid}, aDuration, aEUt, 0);
+     * RECIPEHANDLER_Dehydrator.debug5(null, null, aFluid, aOutputFluid,
+     * aOutputItems, aDuration, aEUt); return true; }
+     */
+
+    @Override
+    public boolean addDehydratorRecipe(final ItemStack aInput, final FluidStack aFluid, final ItemStack[] aOutput,
+            int aDuration, final int aEUt) {
+        Logger.WARNING("Trying to add a Dehydrator recipe.");
+        try {
+            if ((aInput == null) || (aFluid == null) || (aOutput == null)) {
+                return false;
+            }
+            if ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aInput, aDuration)) <= 0) {
+                return false;
+            }
+            Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, new ItemStack[] { aInput },
+                    aOutput, null, new FluidStack[] { aFluid }, null, aDuration, aEUt, 0);
+            // RECIPEHANDLER_Dehydrator.debug5(aInput, null, aFluid, null,
+            // aOutput, aDuration, aEUt);
+            return true;
+        }
+        catch (final NullPointerException e) {
+            Logger.WARNING("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addDehydratorRecipe(final ItemStack[] aInput, final FluidStack aFluidInput,
+            final FluidStack aFluidOutput, final ItemStack[] aOutputItems, final int[] aChances, int aDuration,
+            final int aEUt) throws IndexOutOfBoundsException {
+        Logger.WARNING("Trying to add a Dehydrator recipe.");
+        try {
+            if (aInput[0] != null) {
+                Logger.WARNING("Recipe requires input: " + aInput[0].getDisplayName() + " x" + aInput[0].stackSize);
+            }
+            if (aInput.length > 1) {
+                if (aInput[1] != null) {
+                    Logger.WARNING("Recipe requires input: " + aInput[1].getDisplayName() + " x" + aInput[1].stackSize);
+                }
+            }
+            if (aFluidInput != null) {
+                Logger.WARNING("Recipe requires input: " + aFluidInput.getFluid().getName() + " " + aFluidInput.amount
+                        + "mbst");
+            }
+            if (((aInput[0] == null) && (aFluidInput == null)) || ((aOutputItems == null) && (aFluidOutput == null))) {
+                return false;
+            }
+            if ((aOutputItems != null)
+                    && ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aOutputItems[0], aDuration)) <= 0)) {
+                return false;
+            }
+            if (aOutputItems != null) {
+                Logger.WARNING("Recipe will output: " + ItemUtils.getArrayStackNames(aOutputItems));
+            }
+            if ((aFluidOutput != null) && ((aDuration = GregTech_API.sRecipeFile.get("dehydrator",
+                    aFluidOutput.getFluid().getName(), aDuration)) <= 0)) {
+                return false;
+            }
+            if (aFluidOutput != null) {
+                Logger.WARNING("Recipe will output: " + aFluidOutput.getFluid().getName());
+            }
+
+            if (aInput.length == 1) {
+                Logger.WARNING("Dehydrator recipe only has a single input item.");
+                Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, aInput, aOutputItems, null,
+                        aChances, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt,
+                        0);
+
+            }
+            else {
+                Logger.WARNING("Dehydrator recipe has two input items.");
+                Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, aInput, aOutputItems, null,
+                        aChances, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt,
+                        0);
+
+            }
+
+            return true;
+        }
+        catch (final NullPointerException e) {
+            Logger.WARNING("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addBlastSmelterRecipe(final ItemStack[] aInput, FluidStack aOutput, final int aChance, int aDuration,
+            final int aEUt) {
+        return addBlastSmelterRecipe(aInput, null, aOutput, new ItemStack[] {}, new int[] {aChance}, aDuration, aEUt, 3700);
+    }
+
+    @Override
+    public boolean addBlastSmelterRecipe(final ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput,
+            final int aChance, int aDuration, final int aEUt) {
+        return addBlastSmelterRecipe(aInput, aInputFluid, aOutput, new ItemStack[] {}, new int[] {aChance}, aDuration, aEUt, 3700);
+    }
+
+    @Override
+    public boolean addBlastSmelterRecipe(final ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack,
+            final int aChance[], int aDuration, final int aEUt) {
+        return addBlastSmelterRecipe(aInput, aInputFluid, aOutput, aOutputStack, aChance, aDuration, aEUt, 3700);
+    }
+
+    @Override
+    public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, int aChance,
+            int aDuration, int aEUt, int aSpecialValue) {
+        return addBlastSmelterRecipe(aInput, aInputFluid, aOutput, new ItemStack[] {}, new int[] {aChance}, aDuration, aEUt, aSpecialValue);		
+    }
+
+    @Override
+    public boolean addBlastSmelterRecipe(ItemStack[] aInput, FluidStack aInputFluid, FluidStack aOutput, ItemStack[] aOutputStack, int[] aChance,
+            int aDuration, int aEUt, int aSpecialValue) {
+        if ((aInput == null) || (aOutput == null)) {
+            Logger.WARNING("Fail - Input or Output was null.");
+            return false;
+        }
+
+        if (aOutput.isFluidEqual(Materials.PhasedGold.getMolten(1))) {
+            aOutput = Materials.VibrantAlloy.getMolten(aOutput.amount);
+        }
+        if (aOutput.isFluidEqual(Materials.PhasedIron.getMolten(1))) {
+            aOutput = Materials.PulsatingIron.getMolten(aOutput.amount);
+        }
+        if ((aDuration = GregTech_API.sRecipeFile.get("blastsmelter", aOutput.getFluid().getName(), aDuration)) <= 0) {
+            Logger.WARNING("Recipe did not register.");
+            return false;
+        }
+
+        for (int das = 0; das < aInput.length; das++) {
+            if (aInput[das] != null) {
+                Logger.WARNING("tMaterial[" + das + "]: " + aInput[das].getDisplayName() + ", Amount: "
+                        + aInput[das].stackSize);
+            }
+        }
+
+        ArrayUtils.removeNulls(aInput);
+        if (aInput.length <= 1) {
+            return false;
+        }		
+
+
+
+        Recipe_GT.Gregtech_Recipe_Map.sAlloyBlastSmelterRecipes.addRecipe(true, aInput, aOutputStack, null,
+                aChance, new FluidStack[] { aInputFluid }, new FluidStack[] { aOutput }, aDuration, aEUt,
+                aSpecialValue);
+        return true;
+    }
+
+    @Override
+    public boolean addLFTRRecipe(final ItemStack aInput1, final FluidStack aInput2, final ItemStack aOutput1,
+            final FluidStack aOutput2, final int aDuration, final int aEUt) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public boolean addLFTRRecipe(final ItemStack aInput1, final ItemStack aInput2, final ItemStack aOutput1,
+            final int aDuration, final int aEUt) {
+        return false;
+    }
+
+    @Override
+    public boolean addLFTRRecipe(final FluidStack aInput1, final FluidStack aInput2, final FluidStack aOutput1,
+            final int aDuration, final int aEUt) {
+        if ((aInput1 == null) || (aInput2 == null) || (aOutput1 == null) || (aDuration < 1) || (aEUt < 1)) {
+            return false;
+        }
+        Recipe_GT.Gregtech_Recipe_Map.sLiquidFluorineThoriumReactorRecipes.addRecipe(null,
+                new FluidStack[] { aInput1, aInput2 }, new FluidStack[] { aOutput1 }, aDuration, aEUt, 16000);
+        return true;
+    }
+
+    @Override
+    public boolean addFissionFuel(final FluidStack aInput1, final FluidStack aInput2, final FluidStack aInput3,
+            final FluidStack aInput4, final FluidStack aInput5, final FluidStack aInput6, final FluidStack aInput7,
+            final FluidStack aInput8, final FluidStack aInput9, final FluidStack aOutput1, final FluidStack aOutput2,
+            final int aDuration, final int aEUt) {
+
+        if ((aInput1 == null) || (aInput2 == null) || (aOutput1 == null) || (aDuration < 1) || (aEUt < 1)) {
+            return false;
+        }
+        final FluidStack inputs[] = { aInput1, aInput2, aInput3, aInput4, aInput5, aInput6, aInput7, aInput8, aInput9 };
+        final FluidStack outputs[] = { aOutput1, aOutput2 };
+        // Recipe_GT.Gregtech_Recipe_Map.sFissionFuelProcessing.addRecipe(null,
+        // inputs, outputs, aDuration, aEUt, 0);
+        CustomRecipeMap.sFissionFuelProcessing.addRecipe(null, inputs, outputs, aDuration, aEUt, 0);
+        return true;
+    }
+
+    @Override
+    public boolean addCyclotronRecipe(ItemStack aInputs, FluidStack aFluidInput, ItemStack[] aOutputs,
+            FluidStack aFluidOutput, int[] aChances, int aDuration, int aEUt, int aSpecialValue) {
+        return addCyclotronRecipe(new ItemStack[] {aInputs}, aFluidInput, aOutputs, aFluidOutput, aChances, aDuration, aEUt, aSpecialValue);
+    }
+
+    @Override
+    public boolean addCyclotronRecipe(ItemStack[] aInputs, FluidStack aFluidInput, ItemStack[] aOutput,
+            FluidStack aFluidOutput, int[] aChances, int aDuration, int aEUt, int aSpecialValue) {
+        if (aOutput == null || aOutput.length < 1 || !ItemUtils.checkForInvalidItems(aOutput)) {
+            return false;
+        }
+        if (Recipe_GT.Gregtech_Recipe_Map.sCyclotronRecipes.addRecipe(true, aInputs, aOutput,
+                null, aChances, new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput },
+                Math.max(1, aDuration), Math.max(1, aEUt), aSpecialValue) != null) {
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean addMixerRecipe(ItemStack aInput1, ItemStack aInput2, ItemStack aInput3, ItemStack aInput4,
+            FluidStack aFluidInput, FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3,
+            ItemStack aOutput4, int aDuration, int aEUt) {
+        if (((aInput1 == null) && (aFluidInput == null)) || ((aOutput1 == null) && (aFluidOutput == null))) {
+            return false;
+        }
+        if ((aOutput1 != null)
+                && ((aDuration = GregTech_API.sRecipeFile.get("advancedmixer", aOutput1, aDuration)) <= 0)) {
+            return false;
+        }
+        if ((aFluidOutput != null) && ((aDuration = GregTech_API.sRecipeFile.get("advancedmixer",
+                aFluidOutput.getFluid().getName(), aDuration)) <= 0)) {
+            return false;
+        }
+        Recipe_GT.Gregtech_Recipe_Map.sAdvancedMixerRecipes.addRecipe(true,
+                new ItemStack[] { aInput1, aInput2, aInput3, aInput4 },
+                new ItemStack[] { aOutput1, aOutput2, aOutput3, aOutput4 }, null, null,
+                new FluidStack[] { aFluidInput }, new FluidStack[] { aFluidOutput }, aDuration, aEUt, 0);
+        return true;
+    }
+
+    // Machine Component Assembler
+    @Override
+    public boolean addComponentMakerRecipe(ItemStack[] aInputs, FluidStack aFluidInput, ItemStack aOutput1,
+            int aDuration, int aEUt) {
+        if (areItemsAndFluidsBothNull(aInputs, new FluidStack[] { aFluidInput })) {
+            return false;
+        }
+        if (aOutput1 == null) {
+            return false;
+        }
+        if ((aDuration = GregTech_API.sRecipeFile.get("machinecomponents", aOutput1, aDuration)) <= 0) {
+            return false;
+        }
+        if (GTNH) {
+            return false;
+        }
+        Recipe_GT.Gregtech_Recipe_Map.sComponentAssemblerRecipes.addRecipe(true, aInputs, new ItemStack[] { aOutput1 },
+                null, new FluidStack[] { aFluidInput }, null, aDuration, aEUt, 0);
+        return true;
+    }
+
+
+    public boolean addMultiblockCentrifugeRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, int aSpecial){
+        if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) || aEUtick <= 0) {
+            return false;
+        }
+
+        if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) {
+            Logger.INFO("[Recipe] Error generating Large Centrifuge recipe.");
+            Logger.INFO("Inputs: "+ItemUtils.getArrayStackNames(aInputs));
+            Logger.INFO("Fluid Inputs: "+ItemUtils.getArrayStackNames(aFluidInputs));
+            Logger.INFO("Outputs: "+ItemUtils.getArrayStackNames(aOutputs));
+            Logger.INFO("Fluid Outputs: "+ItemUtils.getArrayStackNames(aFluidOutputs));
+            return false;
+        }
+        Recipe_GT.Gregtech_Recipe_Map.sMultiblockCentrifugeRecipes.addRecipe(true, aInputs, aOutputs, null, aChances, aFluidInputs, aFluidOutputs, aDuration, aEUtick, aSpecial);
+        return true;
+    }
+
+    public boolean addMultiblockElectrolyzerRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, int aSpecial){
+        if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) || aEUtick <= 0) {
+            return false;
+        }
+        if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) {
+            Logger.INFO("[Recipe] Error generating Large Electrolyzer recipe.");
+            Logger.INFO("Inputs: "+ItemUtils.getArrayStackNames(aInputs));
+            Logger.INFO("Fluid Inputs: "+ItemUtils.getArrayStackNames(aFluidInputs));
+            Logger.INFO("Outputs: "+ItemUtils.getArrayStackNames(aOutputs));
+            Logger.INFO("Fluid Outputs: "+ItemUtils.getArrayStackNames(aFluidOutputs));
+            return false;
+        }
+        Recipe_GT.Gregtech_Recipe_Map.sMultiblockElectrolyzerRecipes.addRecipe(true, aInputs, aOutputs, null, aChances, aFluidInputs, aFluidOutputs, aDuration, aEUtick, aSpecial);
+        return true;
+    }
+
+
+    public boolean addAdvancedFreezerRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, int aSpecial) {
+        if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) || aEUtick <= 0) {
+            return false;
+        }
+
+        if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) {
+            Logger.INFO("[Recipe] Error generating Adv. Vac Freezer recipe.");
+            Logger.INFO("Inputs: "+ItemUtils.getArrayStackNames(aInputs));
+            Logger.INFO("Fluid Inputs: "+ItemUtils.getArrayStackNames(aFluidInputs));
+            Logger.INFO("Outputs: "+ItemUtils.getArrayStackNames(aOutputs));
+            Logger.INFO("Fluid Outputs: "+ItemUtils.getArrayStackNames(aFluidOutputs));
+            return false;
+        }
+        if (Recipe_GT.Gregtech_Recipe_Map.sAdvFreezerRecipes.addRecipe(true, aInputs, aOutputs, null, aChances, aFluidInputs, aFluidOutputs, aDuration, aEUtick, aSpecial) != null) {
+            return true;
+        }
+        return false;	
+
+    }
+
+    public boolean addAssemblerRecipeWithOreDict(Object aInput1, int aAmount1, Object aInput2, int aAmount2, ItemStack aOutput, int a1, int a2) {		
+        if (aInput1 instanceof String || aInput2 instanceof String) {
+            int mCompleted = 0;
+            if (aInput1 instanceof String && aInput2 instanceof String) {
+                List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);
+                List<ItemStack> x1 = OreDictionary.getOres((String) aInput2, false);
+                if (x != null && x.size() > 0 && x1 != null && x1.size() > 0) {
+                    for (ItemStack r : x) {
+                        r.stackSize = aAmount1;
+                        for (ItemStack r1 : x1) {
+                            r1.stackSize = aAmount2;
+                            if (GT_Values.RA.addAssemblerRecipe(r, r1, aOutput, a1, a2)) {
+                                mCompleted++;
+                            }
+                        }
+                    }
+                }
+            }
+            else if (aInput1 instanceof String) {
+                List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);				
+                if (x != null && x.size() > 0) {
+                    for (ItemStack r : x) {
+                        r.stackSize = aAmount1;
+                        if (GT_Values.RA.addAssemblerRecipe(r, (ItemStack) aInput2, aOutput, a1, a2)) {
+                            mCompleted++;
+                        }
+                    }
+                }
+
+            }
+            else {
+                List<ItemStack> x = OreDictionary.getOres((String) aInput2, false);	
+                if (x != null && x.size() > 0) {
+                    for (ItemStack r : x) {
+                        r.stackSize = aAmount1;
+                        if (GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, r, aOutput, a1, a2)) {
+                            mCompleted++;
+                        }
+                    }
+                }
+            }
+            return mCompleted > 0;
+        }
+        else {
+            return GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, (ItemStack) aInput2, aOutput, a1, a2);			
+        }		
+    }
+
+    public boolean addAssemblerRecipeWithOreDict(Object aInput1, int aAmount1, Object aInput2, int aAmount2, FluidStack aInputFluid, ItemStack aOutput, int a1, int a2) {
+        if (aInput1 instanceof String || aInput2 instanceof String) {
+            int mCompleted = 0;
+            if (aInput1 instanceof String && aInput2 instanceof String) {
+                List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);
+                List<ItemStack> x1 = OreDictionary.getOres((String) aInput2, false);
+                if (x != null && x.size() > 0 && x1 != null && x1.size() > 0) {
+                    for (ItemStack r : x) {
+                        r.stackSize = aAmount1;
+                        for (ItemStack r1 : x1) {
+                            r1.stackSize = aAmount2;
+                            if (GT_Values.RA.addAssemblerRecipe(r, r1, aInputFluid, aOutput, a1, a2)) {
+                                mCompleted++;
+                            }
+                        }
+                    }
+                }
+            }
+            else if (aInput1 instanceof String) {
+                List<ItemStack> x = OreDictionary.getOres((String) aInput1, false);				
+                if (x != null && x.size() > 0) {
+                    for (ItemStack r : x) {
+                        r.stackSize = aAmount1;
+                        if (GT_Values.RA.addAssemblerRecipe(r, (ItemStack) aInput2, aInputFluid, aOutput, a1, a2)) {
+                            mCompleted++;
+                        }
+                    }
+                }
+
+            }
+            else {
+                List<ItemStack> x = OreDictionary.getOres((String) aInput2, false);	
+                if (x != null && x.size() > 0) {
+                    for (ItemStack r : x) {
+                        r.stackSize = aAmount1;
+                        if (GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, r, aInputFluid, aOutput, a1, a2)) {
+                            mCompleted++;
+                        }
+                    }
+                }
+            }
+            return mCompleted > 0;
+        }
+        else {
+            return GT_Values.RA.addAssemblerRecipe((ItemStack) aInput1, (ItemStack) aInput2, aInputFluid, aOutput, a1, a2);			
+        }
+    }
+
+    /*
+     * Reflection Based Recipe Additions with Fallbacks
+     */
+
+    private static final  Method mSixSlotAssembly;
+    private static final  Method mAssemblyLine;
+    private static final  Method mScannerTT;
+    private static final  Method[] mChemicalRecipe = new Method[3];
+    private static final  Method mLargeChemReactor;
+
+    static {
+
+        //Get GT's RA class;
+        Class<? extends IGT_RecipeAdder> clazz = GT_Values.RA.getClass();		
+
+        mChemicalRecipe[0] = ReflectionUtils.getMethod(clazz, "addChemicalRecipe", ItemStack.class, ItemStack.class, FluidStack.class, FluidStack.class, ItemStack.class, int.class);
+
+
+        if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK || CORE.GTNH) {	
+            //6 Slot Assembler
+            mSixSlotAssembly = ReflectionUtils.getMethod(clazz, "addAssemblerRecipe", ItemStack[].class, FluidStack.class, ItemStack.class, int.class, int.class);
+            //Assembly Line
+            mAssemblyLine = ReflectionUtils.getMethod(clazz, "addAssemblylineRecipe", ItemStack.class, int.class, ItemStack[].class, FluidStack[].class, ItemStack.class, int.class, int.class);
+
+
+            Method T = null;
+            if (LoadedMods.TecTech) {
+                Class TTRecipeAdder = ReflectionUtils.getClass("com.github.technus.tectech.recipe.TT_recipeAdder");
+                if (TTRecipeAdder != null) {
+                    Method ttTest = ReflectionUtils.getMethod(TTRecipeAdder, "addResearchableAssemblylineRecipe",
+                            ItemStack.class, int.class, int.class, int.class, int.class, Object[].class,
+                            FluidStack[].class, ItemStack.class, int.class, int.class);
+                    if (ttTest != null) {
+                        T = ttTest;
+                    }
+                }
+            }
+            else {
+                T = null;
+            }
+            mScannerTT = T;
+
+            mChemicalRecipe[1] = ReflectionUtils.getMethod(clazz, "addChemicalRecipe", ItemStack.class, ItemStack.class, FluidStack.class, FluidStack.class, ItemStack.class, int.class, int.class);
+            mChemicalRecipe[2] = ReflectionUtils.getMethod(clazz, "addChemicalRecipe", ItemStack.class, ItemStack.class, FluidStack.class, FluidStack.class, ItemStack.class, ItemStack.class, int.class);
+
+            mLargeChemReactor = ReflectionUtils.getMethod(clazz, "addMultiblockChemicalRecipe", ItemStack[].class, FluidStack[].class, FluidStack[].class, ItemStack[].class, int.class, int.class);
+
+
+
+        }
+        else {
+            mSixSlotAssembly = null;
+            mAssemblyLine = null;
+            mLargeChemReactor = null;
+            mScannerTT = null;
+        }
+
+
+    }
+
+
+
+
+
+
+    public boolean addSixSlotAssemblingRecipe(ItemStack[] aInputs, FluidStack aInputFluid, ItemStack aOutput1, int aDuration, int aEUt) {
+        if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK || CORE.GTNH) {			
+            if (mSixSlotAssembly != null) {
+                try {
+                    return (boolean) mSixSlotAssembly.invoke(GT_Values.RA, aInputs, aInputFluid, aOutput1, aDuration, aEUt);
+                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                    if (CORE.GTNH) {
+                        return false;
+                    }
+                }
+            }		
+        }
+        return CORE.RA.addComponentMakerRecipe(aInputs, aInputFluid, aOutput1, aDuration, aEUt);		
+    }
+
+    public boolean addAssemblylineRecipe(ItemStack aResearchItem, int aResearchTime, ItemStack[] aInputs, FluidStack[] aFluidInputs_OLD, ItemStack aOutput, int aDuration, int aEUt) {
+
+        FluidStack[] aFluidInputs = new FluidStack[4];	
+        AutoMap<FluidStack> aNewFluidMap = new AutoMap<FluidStack>();
+        if (aFluidInputs_OLD.length > 4) {
+            for (FluidStack s : aFluidInputs_OLD) {
+                aNewFluidMap.put(s);
+            }
+            for (int i = 0; i < 4; i++) {
+                aFluidInputs[i] = aNewFluidMap.get(i);				
+            }
+        }
+        else {
+            aFluidInputs = aFluidInputs_OLD;
+        }
+
+
+        if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+            if (aInputs.length < 6 && aFluidInputs.length < 2) {
+                ItemStack[] aInputStack = new ItemStack[] {aResearchItem, aInputs[0], aInputs[1], aInputs[2], aInputs[3], aInputs[4]};
+                return addSixSlotAssemblingRecipe(aInputStack, aFluidInputs[0], aOutput, aDuration, aEUt);
+            }        	
+            return false;
+        }
+        else {
+            if ((aResearchItem==null)||(aResearchTime<=0)||(aInputs == null) || (aOutput == null) || aInputs.length>15 || aInputs.length<4) {
+                return false;
+            }
+            else {
+                if (mAssemblyLine != null) {
+                    try {						
+                        if (!tryAddTecTechScannerRecipe(aResearchItem, aInputs, aFluidInputs, aOutput, aDuration, aEUt)) {
+                            try {								
+                                Logger.INFO("Failed to generate TecTech recipe for "+ItemUtils.getItemName(aResearchItem)+", please report this to Alkalus.");
+                            }
+                            catch (Throwable t) {
+
+                            }
+                        }
+                        return (boolean) mAssemblyLine.invoke(GT_Values.RA, aResearchItem, aResearchTime, aInputs,
+                                aFluidInputs, aOutput, aDuration, aEUt);
+                    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                        if (aInputs.length < 6 && aFluidInputs.length < 2) {
+                            ItemStack[] aInputStack = new ItemStack[] { aResearchItem, aInputs[0], aInputs[1],
+                                    aInputs[2], aInputs[3], aInputs[4] };
+                            return addSixSlotAssemblingRecipe(aInputStack, aFluidInputs[0], aOutput, aDuration,
+                                    aEUt);
+                        }
+                        return false;
+                    }
+                } else {
+                    if (aInputs.length < 6 && aFluidInputs.length < 2) {
+                        ItemStack[] aInputStack = new ItemStack[] { aResearchItem, aInputs[0], aInputs[1], aInputs[2],
+                                aInputs[3], aInputs[4] };
+                        return addSixSlotAssemblingRecipe(aInputStack, aFluidInputs[0], aOutput, aDuration,
+                                aEUt);
+                    }
+                    return false;
+                }
+            }		
+        }
+    }
+
+    private boolean tryAddTecTechScannerRecipe(ItemStack aResearchItem,	Object[] aInputs, FluidStack[] aFluidInputs, ItemStack aOutput, int assDuration, int assEUt) {
+        if (!LoadedMods.TecTech) {
+            return true;
+        }
+        else {
+
+            int compSec = (GT_Utility.getTier(assEUt)+1) * 16;
+            int compMax = (GT_Utility.getTier(assEUt)+1) * 10000;
+
+            if (mScannerTT != null) {
+                try {
+                    boolean aResult = (boolean) mScannerTT.invoke(null, aResearchItem, compMax, compSec,
+                            (assEUt/2), 16, aInputs, aFluidInputs, aOutput, assDuration, assEUt);					
+                    Logger.INFO("Added TecTech Scanner Recipe for "+ItemUtils.getItemName(aResearchItem)+"? "+aResult);
+                    return aResult;
+
+                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                    Logger.INFO("Failed to generate TecTech recipe for "+ItemUtils.getItemName(aResearchItem)+", please report this to Alkalus. [Severe]");
+                    e.printStackTrace();
+                }
+            }			
+        }
+        return false;
+    }
+
+
+    public boolean addChemicalRecipe(ItemStack input1, ItemStack input2, FluidStack inputFluid, FluidStack outputFluid, ItemStack output, int time, int eu){
+        return addChemicalRecipe(input1, input2, inputFluid, outputFluid, output, null, time, eu);
+    }
+
+    @Override
+    public boolean addChemicalRecipe(ItemStack input1, ItemStack input2, FluidStack inputFluid, FluidStack outputFluid,	ItemStack output, Object object, int time, int eu) {
+        try {
+            if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+                return (boolean) mChemicalRecipe[0].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, time);
+            }
+            else {
+                return (boolean) mChemicalRecipe[1].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, time, eu);
+            }
+        }
+        catch (Throwable t) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addChemicalRecipe(ItemStack input1, ItemStack input2, FluidStack inputFluid, FluidStack outputFluid,	ItemStack output, ItemStack output2, int time) {
+        try {
+            if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+                return (boolean) mChemicalRecipe[0].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, time);
+            }
+            else {
+                return (boolean) mChemicalRecipe[2].invoke(GT_Values.RA, input1, input2, inputFluid, outputFluid, output, output2, time);
+            }
+        }
+        catch (Throwable t) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean addMultiblockChemicalRecipe(ItemStack[] itemStacks, FluidStack[] fluidStacks, FluidStack[] fluidStacks2, ItemStack[] outputs, int time, int eu) {
+        if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK || mLargeChemReactor == null) {
+            return false;
+        }		
+        try {			
+            return (boolean) mLargeChemReactor.invoke(GT_Values.RA, itemStacks, fluidStacks, fluidStacks2, outputs, time, eu);
+        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            return false;
+        }		
+    }
+
+
+
+
+
+
+
+
+    private boolean areItemsAndFluidsBothNull(final ItemStack[] items, final FluidStack[] fluids) {
+        boolean itemsNull = true;
+        if (items != null) {
+            for (final ItemStack itemStack : items) {
+                if (itemStack != null) {
+                    itemsNull = false;
+                    break;
+                }
+            }
+        }
+        boolean fluidsNull = true;
+        if (fluids != null) {
+            for (final FluidStack fluidStack : fluids) {
+                if (fluidStack != null) {
+                    fluidsNull = false;
+                    break;
+                }
+            }
+        }
+        return itemsNull && fluidsNull;
+    }
+
+    @Override
+    public boolean addCompressorRecipe(ItemStack aInput1, ItemStack aOutput1, int aDuration, int aEUt) {
+        if ((aInput1 == null) || (aOutput1 == null)) {
+            return false;
+        }
+        if ((aInput1 != null) && ((aDuration = GregTech_API.sRecipeFile.get("compressor", aInput1, aDuration)) <= 0)) {
+            return false;
+        }
+        GT_Recipe.GT_Recipe_Map.sCompressorRecipes.addRecipe(true, new ItemStack[]{aInput1}, new ItemStack[]{aOutput1}, null, null, null, aDuration, aEUt, 0);
+        return true;
+    }
+
+    @Override
+    public boolean addBrewingRecipe(int aCircuit, FluidStack aInput, FluidStack aOutput, int aTime, int aEu, boolean aHidden) {
+        return addBrewingRecipe(CI.getNumberedCircuit(aCircuit), aInput, aOutput, aTime, aEu, aHidden);
+    }
+
+    @Override
+    public boolean addBrewingRecipe(ItemStack aIngredient, FluidStack aInput, FluidStack aOutput, int aTime, int aEu, boolean aHidden) {
+        if ((aIngredient == null) || (aInput == null) || (aOutput == null)) {
+            return false;
+        }
+        if (!GregTech_API.sRecipeFile.get("brewing", aOutput.getUnlocalizedName(), true)) {
+            return false;
+        }
+        GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sBrewingRecipes.addRecipe(false, new ItemStack[]{aIngredient}, null, null, new FluidStack[]{aInput}, new FluidStack[]{aOutput}, aTime, aEu, 0);
+        if ((aHidden) && (tRecipe != null)) {
+            tRecipe.mHidden = true;
+        }
+        return true;
+    }
+
+
+    /**
+     *  Lets me add recipes for GT 5.08 & 5.09, since someone broke the method headers.
+     */
+    @Override
+    public boolean addSmeltingAndAlloySmeltingRecipe(ItemStack aDust, ItemStack aOutput) {		
+        Method m = StaticFields59.mAddFurnaceRecipe;		
+        if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+            try {
+                return (boolean) m.invoke(null, aDust, aOutput);
+            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                return false;
+            }
+        }
+        else {
+            try {
+                return (boolean) m.invoke(null, aDust, aOutput, true);
+            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                return false;
+            }
+        }
+    }
+
+    @Override
+    public void addFluidExtractionRecipe(ItemStack input, Object input2, FluidStack output, int aTime, int aEu,	int aSpecial) {
+        MaterialGenerator.addFluidExtractionRecipe(input, input2, output, aSpecial, aTime, aEu);
+
+    }
+
+
+
+
+
+    /**
      * Adds a Fusion reactor Recipe
      *
      * @param aInputStackA                        = first Input (not null, and respects StackSize)
@@ -990,105 +990,122 @@ public class GregtechRecipeAdder implements IGregtech_RecipeAdder {
      * @param aEu           = The EU generated per Tick (can even be negative!)
      * @param aSpecial = EU needed for heating the Reactor up (must be >= 0)
      */	
-		@Override
-		public boolean addFusionReactorRecipe(FluidStack aInputStackA, FluidStack aInputStackB, FluidStack plasma,
-				int aOutputChance, int aFusionDurationInTicks, int aEu, int aSpecial) {
-			if (aInputStackA == null || aInputStackB == null || plasma == null || aFusionDurationInTicks < 1 || aEu < 1 || aSpecial < 1) {
-	            return false;
-	        }			
-			Recipe_GT aFusionCustom = new Recipe_GT(
-					true,
-					null, 
-					null, 
-					null,
-					new int[] {aOutputChance},
-					new FluidStack[]{aInputStackA, aInputStackB}, 
-					new FluidStack[]{plasma},
-					aFusionDurationInTicks, 
-					aEu, 
-					aSpecial);		
-	        GT_Recipe.GT_Recipe_Map.sFusionRecipes.addRecipe(aFusionCustom);
-	        return true;
-		}
-	
-	
-	
-	
-	
-	 
-		/**
-	     * Adds a Fusion reactor Recipe
-	     *
-	     * @param aInputStackA                        = first Input (not null, and respects StackSize)
-	     * @param aInputStackB                        = second Input (not null, and respects StackSize)
-	     * @param plasma                        = Output of the Fusion (can be null, and respects StackSize)
-	     * @param aFusionDurationInTicks         = How many ticks the Fusion lasts (must be > 0)
-	     * @param aEu           = The EU generated per Tick (can even be negative!)
-	     * @param aSpecial = EU needed for heating the Reactor up (must be >= 0)
-	     */		
-	@Override
-	public boolean addFusionReactorRecipe(ItemStack aInputStackA, ItemStack aInputStackB, FluidStack plasma,
-			int aFusionDurationInTicks, int aEu, int aSpecial) {		
-		return addFusionReactorRecipe(aInputStackA, aInputStackB, plasma, 10000, aFusionDurationInTicks, aEu, aSpecial);		
-	}
-
-		 
-		/**
-	     * Adds a Fusion reactor Recipe
-	     *
-	     * @param aInputStackA                        = first Input (not null, and respects StackSize)
-	     * @param aInputStackB                        = second Input (not null, and respects StackSize)
-	     * @param plasma                        = Output of the Fusion (can be null, and respects StackSize)
+    @Override
+    public boolean addFusionReactorRecipe(FluidStack aInputStackA, FluidStack aInputStackB, FluidStack plasma,
+            int aOutputChance, int aFusionDurationInTicks, int aEu, int aSpecial) {
+        if (aInputStackA == null || aInputStackB == null || plasma == null || aFusionDurationInTicks < 1 || aEu < 1 || aSpecial < 1) {
+            return false;
+        }			
+        Recipe_GT aFusionCustom = new Recipe_GT(
+                true,
+                null, 
+                null, 
+                null,
+                new int[] {aOutputChance},
+                new FluidStack[]{aInputStackA, aInputStackB}, 
+                new FluidStack[]{plasma},
+                aFusionDurationInTicks, 
+                aEu, 
+                aSpecial);		
+        GT_Recipe.GT_Recipe_Map.sFusionRecipes.addRecipe(aFusionCustom);
+        return true;
+    }
+
+
+
+
+
+
+    /**
+     * Adds a Fusion reactor Recipe
+     *
+     * @param aInputStackA                        = first Input (not null, and respects StackSize)
+     * @param aInputStackB                        = second Input (not null, and respects StackSize)
+     * @param plasma                        = Output of the Fusion (can be null, and respects StackSize)
+     * @param aFusionDurationInTicks         = How many ticks the Fusion lasts (must be > 0)
+     * @param aEu           = The EU generated per Tick (can even be negative!)
+     * @param aSpecial = EU needed for heating the Reactor up (must be >= 0)
+     */		
+    @Override
+    public boolean addFusionReactorRecipe(ItemStack aInputStackA, ItemStack aInputStackB, FluidStack plasma,
+            int aFusionDurationInTicks, int aEu, int aSpecial) {		
+        return addFusionReactorRecipe(aInputStackA, aInputStackB, plasma, 10000, aFusionDurationInTicks, aEu, aSpecial);		
+    }
+
+
+    /**
+     * Adds a Fusion reactor Recipe
+     *
+     * @param aInputStackA                        = first Input (not null, and respects StackSize)
+     * @param aInputStackB                        = second Input (not null, and respects StackSize)
+     * @param plasma                        = Output of the Fusion (can be null, and respects StackSize)
      * @param aOutputChance = chance to output plasma (can be 0)
-	     * @param aFusionDurationInTicks         = How many ticks the Fusion lasts (must be > 0)
-	     * @param aEu           = The EU generated per Tick (can even be negative!)
-	     * @param aSpecial = EU needed for heating the Reactor up (must be >= 0)
-	     */	
-		@Override
-		public boolean addFusionReactorRecipe(ItemStack aInputStackA, ItemStack aInputStackB, FluidStack plasma,
-				int aOutputChance, int aFusionDurationInTicks, int aEu, int aSpecial) {
-			if (aInputStackA == null || aInputStackB == null || plasma == null || aFusionDurationInTicks < 1 || aEu < 1 || aSpecial < 1) {
-	            return false;
-	        }			
-			Recipe_GT aFusionCustom = new Recipe_GT(
-					true,
-					new ItemStack[]{aInputStackA, aInputStackB}, 
-					null, 
-					null,
-					new int[] {aOutputChance},
-					null, 
-					new FluidStack[]{plasma},
-					aFusionDurationInTicks, 
-					aEu, 
-					aSpecial);		
-	        GT_Recipe.GT_Recipe_Map.sFusionRecipes.addRecipe(aFusionCustom);
-	        return true;
-			
-		}
-
-		@Override
-		public boolean addSemifluidFuel(ItemStack aFuelItem, int aFuelValue) {
-			return SemiFluidFuelHandler.addSemiFluidFuel(aFuelItem, aFuelValue);
-		}
-
-		@Override
-		public boolean addSemifluidFuel(FluidStack aFuelItem, int aFuelValue) {
-			return SemiFluidFuelHandler.addSemiFluidFuel(aFuelItem, aFuelValue);
-		}
-		
-		
-		
-		
-		
-		
-		
-		
-		
-		
-		
-		
-		
-		
+     * @param aFusionDurationInTicks         = How many ticks the Fusion lasts (must be > 0)
+     * @param aEu           = The EU generated per Tick (can even be negative!)
+     * @param aSpecial = EU needed for heating the Reactor up (must be >= 0)
+     */	
+    @Override
+    public boolean addFusionReactorRecipe(ItemStack aInputStackA, ItemStack aInputStackB, FluidStack plasma,
+            int aOutputChance, int aFusionDurationInTicks, int aEu, int aSpecial) {
+        if (aInputStackA == null || aInputStackB == null || plasma == null || aFusionDurationInTicks < 1 || aEu < 1 || aSpecial < 1) {
+            return false;
+        }			
+        Recipe_GT aFusionCustom = new Recipe_GT(
+                true,
+                new ItemStack[]{aInputStackA, aInputStackB}, 
+                null, 
+                null,
+                new int[] {aOutputChance},
+                null, 
+                new FluidStack[]{plasma},
+                aFusionDurationInTicks, 
+                aEu, 
+                aSpecial);		
+        GT_Recipe.GT_Recipe_Map.sFusionRecipes.addRecipe(aFusionCustom);
+        return true;
+
+    }
+
+    @Override
+    public boolean addSemifluidFuel(ItemStack aFuelItem, int aFuelValue) {
+        return SemiFluidFuelHandler.addSemiFluidFuel(aFuelItem, aFuelValue);
+    }
+
+    @Override
+    public boolean addSemifluidFuel(FluidStack aFuelItem, int aFuelValue) {
+        return SemiFluidFuelHandler.addSemiFluidFuel(aFuelItem, aFuelValue);
+    }
+
+
+
+
+    @Override
+    public boolean addVacuumFurnaceRecipe(ItemStack aInput1, ItemStack aInput2, FluidStack aFluidInput, FluidStack aFluidOutput,
+            ItemStack aOutput1, ItemStack aOutput2, int aDuration, int aEUt, int aLevel) {
+        if (aInput1 != null && aOutput1 != null) {
+            if ((aDuration = GregTech_API.sRecipeFile.get("vacuumfurnace", aInput1, aDuration)) <= 0) {
+                return false;
+            } else {
+                Recipe_GT.Gregtech_Recipe_Map.sVacuumFurnaceRecipes.addRecipe(true, new ItemStack[]{aInput1, aInput2},
+                        new ItemStack[]{aOutput1, aOutput2}, (Object) null, (int[]) null, new FluidStack[]{aFluidInput},
+                        new FluidStack[]{aFluidOutput}, aDuration, aEUt, aLevel);
+                return true;
+            }
+        } else {
+            return false;
+        }
+    }
+
+
+
+
+
+
+
+
+
+
+
 
 
 }
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechDehydrator.java b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechDehydrator.java
index 54ab6d45bb..a3aa7e5e78 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechDehydrator.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechDehydrator.java
@@ -14,6 +14,8 @@ import gtPlusPlus.core.material.ALLOY;
 import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.GregtechMetaTileEntity_IndustrialDehydrator;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.advanced.GregtechMetaTileEntity_Adv_EBF;
 
 public class GregtechDehydrator {
 	public static void run() {
@@ -73,6 +75,10 @@ public class GregtechDehydrator {
 				"You can definitely make space icecream with this.. ",
 				Recipe_GT.Gregtech_Recipe_Map.sChemicalDehydratorRecipes, 2, 9, 10000, 2, 5, "Dehydrator.png", "",
 				false, false, 0, "UNBOXINATOR", null).getStackForm(1L));
+		
+		//Advanced
+		GregtechItemList.Controller_Vacuum_Furnace.set(new GregtechMetaTileEntity_IndustrialDehydrator(995, "multimachine.adv.vacuumfurnace", "Utupu-Tanuri").getStackForm(1L));
+		
 
 		ItemStack coilWire1 = ItemUtils.getItemStackWithMeta(true, "miscutils:itemDehydratorCoilWire", "coilWire1", 0,
 				4);
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialCryogenicFreezer.java b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechFactoryGradeReplacementMultis.java
index 65f3e41911..2b683dd888 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialCryogenicFreezer.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechFactoryGradeReplacementMultis.java
@@ -7,12 +7,10 @@ import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.ad
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.advanced.GregtechMetaTileEntity_Adv_Fusion_MK4;
 import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.advanced.GregtechMetaTileEntity_Adv_Implosion;
 
-public class GregtechIndustrialCryogenicFreezer {
+public class GregtechFactoryGradeReplacementMultis {
 
 	public static void run() {
-		if (gtPlusPlus.core.lib.LoadedMods.Gregtech) {
-			run1();
-		}	
+		run1();
 	}
 
 	private static void run1() {