+ Added some base Meta Tile Entities to handle my custom recipe system.

+ Added some Test recipes for the Dehydrator.
+ Added 3 different recipe handlers for the Dehydrator.

% Added a new Method in FluidUtils that accepts a fluidstack and amount to return a fluidstack[].

6 files changed, 1580 insertions, 25 deletions

diff --git a/src/Java/miscutil/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java b/src/Java/miscutil/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java
index b39c206ecd..32d370d4b1 100644
--- a/src/Java/miscutil/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java
+++ b/src/Java/miscutil/xmod/gregtech/api/interfaces/internal/IGregtech_RecipeAdder.java
@@ -31,6 +31,24 @@ public interface IGregtech_RecipeAdder {
 	 * @param aEUt			= EU needed for heating up (must be >= 0)
 	 * @return true if the Recipe got added, otherwise false.
 	 */
-	public boolean addMattrFabricatorRecipe(FluidStack aFluidInput, FluidStack aFluidOutput, int aDuration, int aEUt);
-
+	public boolean addMatterFabricatorRecipe(FluidStack aFluidInput, FluidStack aFluidOutput, int aDuration, int aEUt);
+	
+	
+	
+	
+	/**
+     * Adds a Recipe for the Sifter. (up to 9 Outputs)
+     *
+	 * @param aFluidOutput   = Output of the UU-Matter (not null, and respects StackSize)
+	 * @param aFluidInput   = fluid Input (can be UU_Amp or null, and respects StackSize)
+	 * @param aDuration 	= Duration (must be >= 0)
+	 * @param aEUt			= EU needed for heating up (must be >= 0)
+	 * @return true if the Recipe got added, otherwise false.
+     */
+    
+    public boolean addDehydratorRecipe(ItemStack aInput, FluidStack aFluid, ItemStack[] aOutputItems, int aDuration, int aEUt);
+    public boolean addDehydratorRecipe(ItemStack aItemA, ItemStack aItemB, ItemStack[] aOutputItems, int aDuration, int aEUt);
+    public boolean addDehydratorRecipe(ItemStack aItemA, ItemStack aItemB, FluidStack aFluid, ItemStack[] aOutputItems, FluidStack aOutputFluid, int aDuration, int aEUt);
+    
+    
 }
diff --git a/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/base/GT_MTE_BasicMachine_Custom_Recipe.java b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/base/GT_MTE_BasicMachine_Custom_Recipe.java
new file mode 100644
index 0000000000..e051a54fb3
--- /dev/null
+++ b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/base/GT_MTE_BasicMachine_Custom_Recipe.java
@@ -0,0 +1,623 @@
+package miscutil.xmod.gregtech.api.metatileentity.implementations.base;
+
+import static gregtech.api.enums.GT_Values.V;
+import static gregtech.api.enums.GT_Values.W;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.Textures;
+import gregtech.api.enums.Tier;
+import gregtech.api.gui.GT_Container_BasicMachine;
+import gregtech.api.gui.GT_GUIContainer_BasicMachine;
+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_ModHandler;
+import gregtech.api.util.GT_ModHandler.RecipeBits;
+import gregtech.api.util.GT_Utility;
+
+import java.util.Random;
+
+import miscutil.xmod.gregtech.api.util.GregtechRecipe.Gregtech_Recipe_Map;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * This is the main construct for my Basic Machines such as the Automatic Extractor
+ * Extend this class to make a simple Machine
+ */
+public class GT_MTE_BasicMachine_Custom_Recipe extends GT_MTE_CustomRecipe_BasicMachine {
+    private final Gregtech_Recipe_Map mRecipes;
+    private final int mTankCapacity, mSpecialEffect;
+    private final String mSound;
+    private final boolean mSharedTank, mRequiresFluidForFiltering;
+    private final byte mGUIParameterA, mGUIParameterB;
+    public GT_MTE_BasicMachine_Custom_Recipe(int aID, String aName, String aNameRegional, int aTier, String aDescription, Gregtech_Recipe_Map aRecipes, int aInputSlots, int aOutputSlots, int aTankCapacity, int aGUIParameterA, int aGUIParameterB, String aGUIName, String aSound, boolean aSharedTank, boolean aRequiresFluidForFiltering, int aSpecialEffect, String aOverlays, Object[] aRecipe) {
+        super(aID, aName, aNameRegional, aTier, aRecipes.mAmperage, aDescription, aInputSlots, aOutputSlots, aGUIName, aRecipes.mNEIName, new ITexture[]{new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_SIDE_ACTIVE")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_SIDE")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_FRONT_ACTIVE")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_FRONT")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_TOP_ACTIVE")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_TOP")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_BOTTOM_ACTIVE")), new GT_RenderedTexture(new Textures.BlockIcons.CustomIcon("basicmachines/" + aOverlays.toLowerCase() + "/OVERLAY_BOTTOM"))});
+        mSharedTank = aSharedTank;
+        mTankCapacity = aTankCapacity;
+        mSpecialEffect = aSpecialEffect;
+        mRequiresFluidForFiltering = aRequiresFluidForFiltering;
+        mRecipes = aRecipes;
+        mSound = aSound;
+        mGUIParameterA = (byte) aGUIParameterA;
+        mGUIParameterB = (byte) aGUIParameterB;
+
+        if (aRecipe != null) {
+            for (int i = 3; i < aRecipe.length; i++) {
+                if (aRecipe[i] == X.CIRCUIT) {
+                    aRecipe[i] = Tier.ELECTRIC[mTier].mManagingObject;
+                    continue;
+                }
+                if (aRecipe[i] == X.BETTER_CIRCUIT) {
+                    aRecipe[i] = Tier.ELECTRIC[mTier].mBetterManagingObject;
+                    continue;
+                }
+                if (aRecipe[i] == X.HULL) {
+                    aRecipe[i] = Tier.ELECTRIC[mTier].mHullObject;
+                    continue;
+                }
+                if (aRecipe[i] == X.WIRE) {
+                    aRecipe[i] = Tier.ELECTRIC[mTier].mConductingObject;
+                    continue;
+                }
+                if (aRecipe[i] == X.WIRE4) {
+                    aRecipe[i] = Tier.ELECTRIC[mTier].mLargerConductingObject;
+                    continue;
+                }
+
+                if (aRecipe[i] == X.GLASS) {
+                    switch (mTier) {
+                        default:
+                            aRecipe[i] = new ItemStack(Blocks.glass, 1, W);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.PLATE) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.plate.get(Materials.Steel);
+                            break;
+                        case 2:
+                            aRecipe[i] = OrePrefixes.plate.get(Materials.Aluminium);
+                            break;
+                        case 3:
+                            aRecipe[i] = OrePrefixes.plate.get(Materials.StainlessSteel);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.plate.get(Materials.Titanium);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.plate.get(Materials.TungstenSteel);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.PIPE) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.pipeMedium.get(Materials.Bronze);
+                            break;
+                        case 2:
+                            aRecipe[i] = OrePrefixes.pipeMedium.get(Materials.Steel);
+                            break;
+                        case 3:
+                            aRecipe[i] = OrePrefixes.pipeMedium.get(Materials.StainlessSteel);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.pipeMedium.get(Materials.Titanium);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.pipeMedium.get(Materials.TungstenSteel);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.COIL_HEATING) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.wireGt02.get(Materials.AnyCopper);
+                            break;
+                        case 2:
+                            aRecipe[i] = OrePrefixes.wireGt02.get(Materials.Cupronickel);
+                            break;
+                        case 3:
+                            aRecipe[i] = OrePrefixes.wireGt02.get(Materials.Kanthal);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.wireGt02.get(Materials.Nichrome);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.wireGt08.get(Materials.Nichrome);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.COIL_HEATING_DOUBLE) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.wireGt04.get(Materials.AnyCopper);
+                            break;
+                        case 2:
+                            aRecipe[i] = OrePrefixes.wireGt04.get(Materials.Cupronickel);
+                            break;
+                        case 3:
+                            aRecipe[i] = OrePrefixes.wireGt04.get(Materials.Kanthal);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.wireGt04.get(Materials.Nichrome);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.wireGt16.get(Materials.Nichrome);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.STICK_DISTILLATION) {
+                    switch (mTier) {
+                        default:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.Blaze);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.STICK_MAGNETIC) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.IronMagnetic);
+                            break;
+                        case 2:
+                        case 3:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.SteelMagnetic);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.NeodymiumMagnetic);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.STICK_ELECTROMAGNETIC) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.AnyIron);
+                            break;
+                        case 2:
+                        case 3:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.Steel);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.Neodymium);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.stick.get(Materials.VanadiumGallium);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.COIL_ELECTRIC) {
+                    switch (mTier) {
+                        case 0:
+                            aRecipe[i] = OrePrefixes.wireGt01.get(Materials.Tin);
+                            break;
+                        case 1:
+                            aRecipe[i] = OrePrefixes.wireGt02.get(Materials.Tin);
+                            break;
+                        case 2:
+                            aRecipe[i] = OrePrefixes.wireGt02.get(Materials.AnyCopper);
+                            break;
+                        case 3:
+                            aRecipe[i] = OrePrefixes.wireGt04.get(Materials.AnyCopper);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.wireGt08.get(Materials.AnnealedCopper);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.wireGt16.get(Materials.AnnealedCopper);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.ROBOT_ARM) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Robot_Arm_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Robot_Arm_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Robot_Arm_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Robot_Arm_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Robot_Arm_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Robot_Arm_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Robot_Arm_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Robot_Arm_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.PUMP) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Electric_Pump_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Electric_Pump_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Electric_Pump_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Electric_Pump_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Electric_Pump_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Electric_Pump_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Electric_Pump_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Electric_Pump_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.ROTOR) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.Tin);
+                            break;
+                        case 2:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.Bronze);
+                            break;
+                        case 3:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.Steel);
+                            break;
+                        case 4:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.StainlessSteel);
+                            break;
+                        case 5:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.TungstenSteel);
+                            break;
+                        case 6:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.TungstenSteel);
+                            break;
+                        case 7:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.TungstenSteel);
+                            break;
+                        default:
+                            aRecipe[i] = OrePrefixes.rotor.get(Materials.TungstenSteel);
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.MOTOR) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Electric_Motor_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Electric_Motor_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Electric_Motor_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Electric_Motor_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Electric_Motor_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Electric_Motor_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Electric_Motor_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Electric_Motor_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.PISTON) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Electric_Piston_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Electric_Piston_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Electric_Piston_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Electric_Piston_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Electric_Piston_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Electric_Piston_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Electric_Piston_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Electric_Piston_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.CONVEYOR) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Conveyor_Module_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Conveyor_Module_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Conveyor_Module_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Conveyor_Module_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Conveyor_Module_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Conveyor_Module_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Conveyor_Module_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Conveyor_Module_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.EMITTER) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Emitter_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Emitter_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Emitter_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Emitter_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Emitter_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Emitter_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Emitter_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Emitter_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.SENSOR) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Sensor_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Sensor_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Sensor_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Sensor_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Sensor_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Sensor_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Sensor_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Sensor_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] == X.FIELD_GENERATOR) {
+                    switch (mTier) {
+                        case 0:
+                        case 1:
+                            aRecipe[i] = ItemList.Field_Generator_LV;
+                            break;
+                        case 2:
+                            aRecipe[i] = ItemList.Field_Generator_MV;
+                            break;
+                        case 3:
+                            aRecipe[i] = ItemList.Field_Generator_HV;
+                            break;
+                        case 4:
+                            aRecipe[i] = ItemList.Field_Generator_EV;
+                            break;
+                        case 5:
+                            aRecipe[i] = ItemList.Field_Generator_IV;
+                            break;
+                        case 6:
+                            aRecipe[i] = ItemList.Field_Generator_LuV;
+                            break;
+                        case 7:
+                            aRecipe[i] = ItemList.Field_Generator_ZPM;
+                            break;
+                        default:
+                            aRecipe[i] = ItemList.Field_Generator_UV;
+                            break;
+                    }
+                    continue;
+                }
+
+                if (aRecipe[i] instanceof X)
+                    throw new IllegalArgumentException("MISSING TIER MAPPING FOR: " + aRecipe[i] + " AT TIER " + mTier);
+            }
+
+            if (!GT_ModHandler.addCraftingRecipe(getStackForm(1), RecipeBits.DISMANTLEABLE | RecipeBits.BUFFERED | RecipeBits.NOT_REMOVABLE | RecipeBits.REVERSIBLE, aRecipe)) {
+                throw new IllegalArgumentException("INVALID CRAFTING RECIPE FOR: " + getStackForm(1).getDisplayName());
+            }
+        }
+    }
+
+    public GT_MTE_BasicMachine_Custom_Recipe(String aName, int aTier, String aDescription, Gregtech_Recipe_Map aRecipes, int aInputSlots, int aOutputSlots, int aTankCapacity, int aAmperage, int aGUIParameterA, int aGUIParameterB, ITexture[][][] aTextures, String aGUIName, String aNEIName, String aSound, boolean aSharedTank, boolean aRequiresFluidForFiltering, int aSpecialEffect) {
+        super(aName, aTier, aAmperage, aDescription, aTextures, aInputSlots, aOutputSlots, aGUIName, aNEIName);
+        mSharedTank = aSharedTank;
+        mTankCapacity = aTankCapacity;
+        mSpecialEffect = aSpecialEffect;
+        mRequiresFluidForFiltering = aRequiresFluidForFiltering;
+        mRecipes = aRecipes;
+        mSound = aSound;
+        mGUIParameterA = (byte) aGUIParameterA;
+        mGUIParameterB = (byte) aGUIParameterB;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MTE_BasicMachine_Custom_Recipe(mName, mTier, mDescription, mRecipes, mInputSlotCount, mOutputItems == null ? 0 : mOutputItems.length, mTankCapacity, mAmperage, mGUIParameterA, mGUIParameterB, mTextures, mGUIName, mNEIName, mSound, mSharedTank, mRequiresFluidForFiltering, mSpecialEffect);
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_Container_BasicMachine(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), mGUIName, GT_Utility.isStringValid(mNEIName) ? mNEIName : getRecipeList() != null ? getRecipeList().mUnlocalizedName : "", mGUIParameterA, mGUIParameterB);
+    }
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) return false;
+		if (mInventory[aIndex] != null) return true;
+		switch (mInputSlotCount) {
+		case  0: return false;
+		case  1: return getFillableStack() == null ? !mRequiresFluidForFiltering && getRecipeList().containsInput(aStack) : null!=getRecipeList().findRecipe(getBaseMetaTileEntity(), mLastRecipe, true, V[mTier], new FluidStack[] {getFillableStack()}, getSpecialSlot(), new ItemStack[] {aStack});
+		case  2: return (!mRequiresFluidForFiltering || getFillableStack() != null) && (((getInputAt(0)!=null&&getInputAt(1)!=null) || (getInputAt(0)==null&&getInputAt(1)==null?getRecipeList().containsInput(aStack):(getRecipeList().containsInput(aStack)&&null!=getRecipeList().findRecipe(getBaseMetaTileEntity(), mLastRecipe, true, V[mTier], new FluidStack[] {getFillableStack()}, getSpecialSlot(), aIndex == getInputSlot() ? new ItemStack[] {aStack, getInputAt(1)} : new ItemStack[] {getInputAt(0), aStack})))));
+		default: return getRecipeList().containsInput(aStack);
+		}
+	}
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPreTick(aBaseMetaTileEntity, aTick);
+        if (aBaseMetaTileEntity.isClientSide() && aBaseMetaTileEntity.isActive()) {
+            switch (mSpecialEffect) {
+                case 0:
+                    break;
+                case 1:
+                    if (aBaseMetaTileEntity.getFrontFacing() != 1 && aBaseMetaTileEntity.getCoverIDAtSide((byte) 1) == 0 && !aBaseMetaTileEntity.getOpacityAtSide((byte) 1)) {
+                        Random tRandom = aBaseMetaTileEntity.getWorld().rand;
+                        aBaseMetaTileEntity.getWorld().spawnParticle("smoke", aBaseMetaTileEntity.getXCoord() + 0.8F - tRandom.nextFloat() * 0.6F, aBaseMetaTileEntity.getYCoord() + 0.9F + tRandom.nextFloat() * 0.2F, aBaseMetaTileEntity.getZCoord() + 0.8F - tRandom.nextFloat() * 0.6F, 0.0D, 0.0D, 0.0D);
+                    }
+                    break;
+            }
+        }
+    }
+
+    
+    public Gregtech_Recipe_Map getRecipeList() {
+        return mRecipes;
+    }
+
+    @Override
+    public int getCapacity() {
+        return mTankCapacity;
+    }
+
+    @Override
+    public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) {
+        super.startSoundLoop(aIndex, aX, aY, aZ);
+        if (aIndex == 1 && GT_Utility.isStringValid(mSound)) GT_Utility.doSoundAtClient(mSound, 100, 1.0F, aX, aY, aZ);
+    }
+
+    @Override
+    public void startProcess() {
+        if (GT_Utility.isStringValid(mSound)) sendLoopStart((byte) 1);
+    }
+
+    @Override
+    public FluidStack getFillableStack() {
+        return mSharedTank ? getDrainableStack() : super.getFillableStack();
+    }
+
+    @Override
+    public FluidStack setFillableStack(FluidStack aFluid) {
+        return mSharedTank ? setDrainableStack(aFluid) : super.setFillableStack(aFluid);
+    }
+
+    @Override
+    protected boolean displaysOutputFluid() {
+        return !mSharedTank;
+    }
+
+    public static enum X {PUMP, WIRE, WIRE4, HULL, PIPE, GLASS, PLATE, MOTOR, ROTOR, SENSOR, PISTON, CIRCUIT, EMITTER, CONVEYOR, ROBOT_ARM, COIL_HEATING, COIL_ELECTRIC, STICK_MAGNETIC, STICK_DISTILLATION, BETTER_CIRCUIT, FIELD_GENERATOR, COIL_HEATING_DOUBLE, STICK_ELECTROMAGNETIC;}
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/base/GT_MTE_CustomRecipe_BasicMachine.java b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/base/GT_MTE_CustomRecipe_BasicMachine.java
new file mode 100644
index 0000000000..a3042a4144
--- /dev/null
+++ b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/base/GT_MTE_CustomRecipe_BasicMachine.java
@@ -0,0 +1,799 @@
+package miscutil.xmod.gregtech.api.metatileentity.implementations.base;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_Container_BasicMachine;
+import gregtech.api.gui.GT_GUIContainer_BasicMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+
+import java.util.Arrays;
+
+import miscutil.xmod.gregtech.api.util.GregtechRecipe;
+import miscutil.xmod.gregtech.api.util.GregtechRecipe.Gregtech_Recipe_Map;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * This is the main construct for my Basic Machines such as the Automatic Extractor
+ * Extend this class to make a simple Machine
+ */
+public abstract class GT_MTE_CustomRecipe_BasicMachine extends GT_MetaTileEntity_BasicTank {
+    /**
+     * return values for checkRecipe()
+     */
+    protected static final int
+            DID_NOT_FIND_RECIPE = 0,
+            FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS = 1,
+            FOUND_AND_SUCCESSFULLY_USED_RECIPE = 2;
+    private static final int OTHER_SLOT_COUNT = 4;
+    public final ItemStack[] mOutputItems;
+    public final int mInputSlotCount, mAmperage;
+    public boolean mAllowInputFromOutputSide = false, mFluidTransfer = false, mItemTransfer = false, mHasBeenUpdated = false, mStuttering = false, mCharge = false, mDecharge = false;
+    public int mMainFacing = -1, mProgresstime = 0, mMaxProgresstime = 0, mEUt = 0, mOutputBlocked = 0;
+    public FluidStack mOutputFluid;
+    public String mGUIName = "", mNEIName = "";
+    private NBTTagCompound mRecipeStuff = new NBTTagCompound();
+    /**
+     * Contains the Recipe which has been previously used, or null if there was no previous Recipe, which could have been buffered
+     */
+    protected GregtechRecipe mLastRecipe = null;
+    private FluidStack mFluidOut;
+
+    /**
+     * @param aOverlays 0 = SideFacingActive
+     *                  1 = SideFacingInactive
+     *                  2 = FrontFacingActive
+     *                  3 = FrontFacingInactive
+     *                  4 = TopFacingActive
+     *                  5 = TopFacingInactive
+     *                  6 = BottomFacingActive
+     *                  7 = BottomFacingInactive
+     *                  ----- Not all Array Elements have to be initialised, you can also just use 8 Parameters for the Default Pipe Texture Overlays -----
+     *                  8 = BottomFacingPipeActive
+     *                  9 = BottomFacingPipeInactive
+     *                  10 = TopFacingPipeActive
+     *                  11 = TopFacingPipeInactive
+     *                  12 = SideFacingPipeActive
+     *                  13 = SideFacingPipeInactive
+     */
+    public GT_MTE_CustomRecipe_BasicMachine(int aID, String aName, String aNameRegional, int aTier, int aAmperage, String aDescription, int aInputSlotCount, int aOutputSlotCount, String aGUIName, String aNEIName, ITexture... aOverlays) {
+        super(aID, aName, aNameRegional, aTier, OTHER_SLOT_COUNT + aInputSlotCount + aOutputSlotCount + 1, aDescription, aOverlays);
+        mInputSlotCount = Math.max(0, aInputSlotCount);
+        mOutputItems = new ItemStack[Math.max(0, aOutputSlotCount)];
+        mAmperage = aAmperage;
+        mGUIName = aGUIName;
+        mNEIName = aNEIName;
+    }
+
+    public GT_MTE_CustomRecipe_BasicMachine(String aName, int aTier, int aAmperage, String aDescription, ITexture[][][] aTextures, int aInputSlotCount, int aOutputSlotCount, String aGUIName, String aNEIName) {
+        super(aName, aTier, OTHER_SLOT_COUNT + aInputSlotCount + aOutputSlotCount + 1, aDescription, aTextures);
+        mInputSlotCount = Math.max(0, aInputSlotCount);
+        mOutputItems = new ItemStack[Math.max(0, aOutputSlotCount)];
+        mAmperage = aAmperage;
+        mGUIName = aGUIName;
+        mNEIName = aNEIName;
+    }
+
+    @Override
+    public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+        ITexture[][][] rTextures = new ITexture[14][17][];
+        aTextures = Arrays.copyOf(aTextures, 14);
+
+        for (int i = 0; i < aTextures.length; i++)
+            if (aTextures[i] != null) for (byte c = -1; c < 16; c++) {
+                if (rTextures[i][c + 1] == null)
+                    rTextures[i][c + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][c + 1], aTextures[i]};
+            }
+
+        for (byte c = -1; c < 16; c++) {
+            if (rTextures[0][c + 1] == null) rTextures[0][c + 1] = getSideFacingActive(c);
+            if (rTextures[1][c + 1] == null) rTextures[1][c + 1] = getSideFacingInactive(c);
+            if (rTextures[2][c + 1] == null) rTextures[2][c + 1] = getFrontFacingActive(c);
+            if (rTextures[3][c + 1] == null) rTextures[3][c + 1] = getFrontFacingInactive(c);
+            if (rTextures[4][c + 1] == null) rTextures[4][c + 1] = getTopFacingActive(c);
+            if (rTextures[5][c + 1] == null) rTextures[5][c + 1] = getTopFacingInactive(c);
+            if (rTextures[6][c + 1] == null) rTextures[6][c + 1] = getBottomFacingActive(c);
+            if (rTextures[7][c + 1] == null) rTextures[7][c + 1] = getBottomFacingInactive(c);
+            if (rTextures[8][c + 1] == null) rTextures[8][c + 1] = getBottomFacingPipeActive(c);
+            if (rTextures[9][c + 1] == null) rTextures[9][c + 1] = getBottomFacingPipeInactive(c);
+            if (rTextures[10][c + 1] == null) rTextures[10][c + 1] = getTopFacingPipeActive(c);
+            if (rTextures[11][c + 1] == null) rTextures[11][c + 1] = getTopFacingPipeInactive(c);
+            if (rTextures[12][c + 1] == null) rTextures[12][c + 1] = getSideFacingPipeActive(c);
+            if (rTextures[13][c + 1] == null) rTextures[13][c + 1] = getSideFacingPipeInactive(c);
+        }
+        return rTextures;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        return mTextures[mMainFacing < 2 ? aSide == aFacing ? aActive ? 2 : 3 : aSide == 0 ? aActive ? 6 : 7 : aSide == 1 ? aActive ? 4 : 5 : aActive ? 0 : 1 : aSide == mMainFacing ? aActive ? 2 : 3 : (showPipeFacing() && aSide == aFacing) ? aSide == 0 ? aActive ? 8 : 9 : aSide == 1 ? aActive ? 10 : 11 : aActive ? 12 : 13 : aSide == 0 ? aActive ? 6 : 7 : aSide == 1 ? aActive ? 4 : 5 : aActive ? 0 : 1][aColorIndex + 1];
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isOverclockerUpgradable() {
+        return false;
+    }
+
+    @Override
+    public boolean isTransformerUpgradable() {
+        return false;
+    }
+
+    @Override
+    public boolean isElectric() {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex > 0 && super.isValidSlot(aIndex) && aIndex != OTHER_SLOT_COUNT + mInputSlotCount + mOutputItems.length;
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return mMainFacing > 1 || aFacing > 1;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return true;
+    }
+
+    @Override
+    public boolean isInputFacing(byte aSide) {
+        return aSide != mMainFacing;
+    }
+
+    @Override
+    public boolean isOutputFacing(byte aSide) {
+        return false;
+    }
+
+    @Override
+    public boolean isTeleporterCompatible() {
+        return false;
+    }
+
+    @Override
+    public boolean isLiquidInput(byte aSide) {
+        return aSide != mMainFacing && (mAllowInputFromOutputSide || aSide != getBaseMetaTileEntity().getFrontFacing());
+    }
+
+    @Override
+    public boolean isLiquidOutput(byte aSide) {
+        return aSide != mMainFacing;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return V[mTier] * 16;
+    }
+
+    @Override
+    public long maxEUStore() {
+        return V[mTier] * 64;
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxSteamStore() {
+        return maxEUStore();
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return (mEUt * 2) / V[mTier] + 1;
+    }
+
+    @Override
+    public int getInputSlot() {
+        return OTHER_SLOT_COUNT;
+    }
+
+    @Override
+    public int getOutputSlot() {
+        return OTHER_SLOT_COUNT + mInputSlotCount;
+    }
+
+    @Override
+    public int getStackDisplaySlot() {
+        return 2;
+    }
+
+    @Override
+    public int rechargerSlotStartIndex() {
+        return 1;
+    }
+
+    @Override
+    public int dechargerSlotStartIndex() {
+        return 1;
+    }
+
+    @Override
+    public int rechargerSlotCount() {
+        return mCharge ? 1 : 0;
+    }
+
+    @Override
+    public int dechargerSlotCount() {
+        return mDecharge ? 1 : 0;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public int getProgresstime() {
+        return mProgresstime;
+    }
+
+    @Override
+    public int maxProgresstime() {
+        return mMaxProgresstime;
+    }
+
+    @Override
+    public int increaseProgress(int aProgress) {
+        mProgresstime += aProgress;
+        return mMaxProgresstime - mProgresstime;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return getFillableStack() != null || (getRecipeList() != null && getRecipeList().containsInput(aFluid));
+    }
+
+    @Override
+    public boolean isFluidChangingAllowed() {
+        return true;
+    }
+
+    @Override
+    public boolean doesFillContainers() {
+        return false;
+    }
+
+    @Override
+    public boolean doesEmptyContainers() {
+        return false;
+    }
+
+    @Override
+    public boolean canTankBeFilled() {
+        return true;
+    }
+
+    @Override
+    public boolean canTankBeEmptied() {
+        return true;
+    }
+
+    @Override
+    public boolean displaysItemStack() {
+        return true;
+    }
+
+    @Override
+    public boolean displaysStackSize() {
+        return true;
+    }
+
+    @Override
+    public FluidStack getDisplayedFluid() {
+        return displaysOutputFluid() ? getDrainableStack() : null;
+    }
+
+    @Override
+    public FluidStack getDrainableStack() {
+        return mFluidOut;
+    }
+
+    @Override
+    public FluidStack setDrainableStack(FluidStack aFluid) {
+        mFluidOut = aFluid;
+        return mFluidOut;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) return true;
+        aBaseMetaTileEntity.openGUI(aPlayer);
+        return true;
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_Container_BasicMachine(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), mGUIName, GT_Utility.isStringValid(mNEIName) ? mNEIName : getRecipeList() != null ? getRecipeList().mUnlocalizedName : "");
+    }
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {
+        mMainFacing = -1;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setBoolean("mFluidTransfer", mFluidTransfer);
+        aNBT.setBoolean("mItemTransfer", mItemTransfer);
+        aNBT.setBoolean("mHasBeenUpdated", mHasBeenUpdated);
+        aNBT.setBoolean("mAllowInputFromOutputSide", mAllowInputFromOutputSide);
+        aNBT.setInteger("mEUt", mEUt);
+        aNBT.setInteger("mMainFacing", mMainFacing);
+        aNBT.setInteger("mProgresstime", mProgresstime);
+        aNBT.setInteger("mMaxProgresstime", mMaxProgresstime);
+        aNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+        if (mOutputFluid != null) aNBT.setTag("mOutputFluid", mOutputFluid.writeToNBT(new NBTTagCompound()));
+        if (mFluidOut != null) aNBT.setTag("mFluidOut", mFluidOut.writeToNBT(new NBTTagCompound()));
+
+        for (int i = 0; i < mOutputItems.length; i++)
+            if (mOutputItems[i] != null)
+                aNBT.setTag("mOutputItem" + i, mOutputItems[i].writeToNBT(new NBTTagCompound()));
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        mFluidTransfer = aNBT.getBoolean("mFluidTransfer");
+        mItemTransfer = aNBT.getBoolean("mItemTransfer");
+        mHasBeenUpdated = aNBT.getBoolean("mHasBeenUpdated");
+        mAllowInputFromOutputSide = aNBT.getBoolean("mAllowInputFromOutputSide");
+        mEUt = aNBT.getInteger("mEUt");
+        mMainFacing = aNBT.getInteger("mMainFacing");
+        mProgresstime = aNBT.getInteger("mProgresstime");
+        mMaxProgresstime = aNBT.getInteger("mMaxProgresstime");
+        mRecipeStuff = aNBT.getCompoundTag("GT.CraftingComponents");
+        mOutputFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mOutputFluid"));
+        mFluidOut = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluidOut"));
+
+        for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = GT_Utility.loadItem(aNBT, "mOutputItem" + i);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+
+        if (aBaseMetaTileEntity.isServerSide()) {
+            mCharge = aBaseMetaTileEntity.getStoredEU() / 2 > aBaseMetaTileEntity.getEUCapacity() / 3;
+            mDecharge = aBaseMetaTileEntity.getStoredEU() < aBaseMetaTileEntity.getEUCapacity() / 3;
+
+            doDisplayThings();
+
+            boolean tSucceeded = false;
+
+            if (mMaxProgresstime > 0 && (mProgresstime >= 0 || aBaseMetaTileEntity.isAllowedToWork())) {
+                aBaseMetaTileEntity.setActive(true);
+                if (mProgresstime < 0 || drainEnergyForProcess(mEUt)) {
+                    if (++mProgresstime >= mMaxProgresstime) {
+                        for (int i = 0; i < mOutputItems.length; i++)
+                            for (int j = 0; j < mOutputItems.length; j++)
+                                if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot() + ((j + i) % mOutputItems.length), mOutputItems[i]))
+                                    break;
+                        if (mOutputFluid != null)
+                            if (getDrainableStack() == null) setDrainableStack(mOutputFluid.copy());
+                            else if (mOutputFluid.isFluidEqual(getDrainableStack()))
+                                getDrainableStack().amount += mOutputFluid.amount;
+                        for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = null;
+                        mOutputFluid = null;
+                        mEUt = 0;
+                        mProgresstime = 0;
+                        mMaxProgresstime = 0;
+                        mStuttering = false;
+                        tSucceeded = true;
+                        endProcess();
+                    }
+                    if (mProgresstime > 5) mStuttering = false;
+                } else {
+                    if (!mStuttering) {
+                        stutterProcess();
+                        if (canHaveInsufficientEnergy()) mProgresstime = -100;
+                        mStuttering = true;
+                    }
+                }
+            } else {
+                aBaseMetaTileEntity.setActive(false);
+            }
+
+            boolean tRemovedOutputFluid = false;
+
+            if (doesAutoOutputFluids() && getDrainableStack() != null && aBaseMetaTileEntity.getFrontFacing() != mMainFacing && (tSucceeded || aTick % 20 == 0)) {
+                IFluidHandler tTank = aBaseMetaTileEntity.getITankContainerAtSide(aBaseMetaTileEntity.getFrontFacing());
+                if (tTank != null) {
+                    FluidStack tDrained = drain(1000, false);
+                    if (tDrained != null) {
+                        int tFilledAmount = tTank.fill(ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), tDrained, false);
+                        if (tFilledAmount > 0)
+                            tTank.fill(ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), drain(tFilledAmount, true), true);
+                    }
+                }
+                if (getDrainableStack() == null) tRemovedOutputFluid = true;
+            }
+
+            if (doesAutoOutput() && !isOutputEmpty() && aBaseMetaTileEntity.getFrontFacing() != mMainFacing && (tSucceeded || mOutputBlocked % 300 == 1 || aBaseMetaTileEntity.hasInventoryBeenModified() || aTick % 600 == 0)) {
+                TileEntity tTileEntity2 = aBaseMetaTileEntity.getTileEntityAtSide(aBaseMetaTileEntity.getFrontFacing());
+                for (int i = 0, tCosts = 1; i < mOutputItems.length && tCosts > 0 && aBaseMetaTileEntity.isUniversalEnergyStored(128); i++) {
+                    tCosts = GT_Utility.moveOneItemStack(aBaseMetaTileEntity, tTileEntity2, aBaseMetaTileEntity.getFrontFacing(), aBaseMetaTileEntity.getBackFacing(), null, false, (byte) 64, (byte) 1, (byte) 64, (byte) 1);
+                    if (tCosts > 0) aBaseMetaTileEntity.decreaseStoredEnergyUnits(tCosts, true);
+                }
+            }
+
+            if (mOutputBlocked != 0) if (isOutputEmpty()) mOutputBlocked = 0;
+            else mOutputBlocked++;
+
+            if (allowToCheckRecipe()) {
+                if (mMaxProgresstime <= 0 && aBaseMetaTileEntity.isAllowedToWork() && (tRemovedOutputFluid || tSucceeded || aBaseMetaTileEntity.hasInventoryBeenModified() || aTick % 600 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled()) && hasEnoughEnergyToCheckRecipe()) {
+                    if (checkRecipe() == 2) {
+                        if (mInventory[3] != null && mInventory[3].stackSize <= 0) mInventory[3] = null;
+                        for (int i = getInputSlot(), j = i + mInputSlotCount; i < j; i++)
+                            if (mInventory[i] != null && mInventory[i].stackSize <= 0) mInventory[i] = null;
+                        for (int i = 0; i < mOutputItems.length; i++) {
+                            mOutputItems[i] = GT_Utility.copy(mOutputItems[i]);
+                            if (mOutputItems[i] != null && mOutputItems[i].stackSize > 64)
+                                mOutputItems[i].stackSize = 64;
+                            mOutputItems[i] = GT_OreDictUnificator.get(true, mOutputItems[i]);
+                        }
+                        if (mFluid != null && mFluid.amount <= 0) mFluid = null;
+                        mMaxProgresstime = Math.max(1, mMaxProgresstime);
+                        if (GT_Utility.isDebugItem(mInventory[dechargerSlotStartIndex()])) {
+                            mEUt = mMaxProgresstime = 1;
+                        }
+                        startProcess();
+                    } else {
+                        mMaxProgresstime = 0;
+                        for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = null;
+                        mOutputFluid = null;
+                    }
+                }
+            } else {
+                if (!mStuttering) {
+                    stutterProcess();
+                    mStuttering = true;
+                }
+            }
+        }
+    }
+
+    protected void doDisplayThings() {
+        if (mMainFacing < 2 && getBaseMetaTileEntity().getFrontFacing() > 1) {
+            mMainFacing = getBaseMetaTileEntity().getFrontFacing();
+        }
+        if (mMainFacing >= 2 && !mHasBeenUpdated) {
+            mHasBeenUpdated = true;
+            getBaseMetaTileEntity().setFrontFacing(getBaseMetaTileEntity().getBackFacing());
+        }
+
+        if (displaysInputFluid()) {
+            int tDisplayStackSlot = OTHER_SLOT_COUNT + mInputSlotCount + mOutputItems.length;
+            if (getFillableStack() == null) {
+                if (ItemList.Display_Fluid.isStackEqual(mInventory[tDisplayStackSlot], true, true))
+                    mInventory[tDisplayStackSlot] = null;
+            } else {
+                mInventory[tDisplayStackSlot] = GT_Utility.getFluidDisplayStack(getFillableStack(), displaysStackSize());
+            }
+        }
+    }
+
+    protected boolean hasEnoughEnergyToCheckRecipe() {
+        return getBaseMetaTileEntity().isUniversalEnergyStored(getMinimumStoredEU() / 2);
+    }
+
+    protected boolean drainEnergyForProcess(long aEUt) {
+        return getBaseMetaTileEntity().decreaseStoredEnergyUnits(aEUt, false);
+    }
+
+    protected void calculateOverclockedNess(GregtechRecipe tRecipe) {
+        calculateOverclockedNess(tRecipe.mEUt, tRecipe.mDuration);
+    }
+
+    protected void calculateOverclockedNess(int aEUt, int aDuration) {
+        if (aEUt <= 16) {
+            mEUt = aEUt * (1 << (mTier - 1)) * (1 << (mTier - 1));
+            mMaxProgresstime = aDuration / (1 << (mTier - 1));
+        } else {
+            mEUt = aEUt;
+            mMaxProgresstime = aDuration;
+            while (mEUt <= V[mTier - 1] * mAmperage) {
+                mEUt *= 4;
+                mMaxProgresstime /= 2;
+            }
+        }
+    }
+
+    protected ItemStack getSpecialSlot() {
+        return mInventory[3];
+    }
+
+    protected ItemStack getOutputAt(int aIndex) {
+        return mInventory[getOutputSlot() + aIndex];
+    }
+
+    protected ItemStack[] getAllOutputs() {
+        ItemStack[] rOutputs = new ItemStack[mOutputItems.length];
+        for (int i = 0; i < mOutputItems.length; i++) rOutputs[i] = getOutputAt(i);
+        return rOutputs;
+    }
+
+    protected boolean canOutput(GregtechRecipe tRecipe) {
+        return tRecipe != null && (tRecipe.mNeedsEmptyOutput ? isOutputEmpty() && getDrainableStack() == null : canOutput(tRecipe.getFluidOutput(0)) && canOutput(tRecipe.mOutputs));
+    }
+
+    protected boolean canOutput(ItemStack... aOutputs) {
+        if (aOutputs == null) return true;
+        ItemStack[] tOutputSlots = getAllOutputs();
+        for (int i = 0; i < tOutputSlots.length && i < aOutputs.length; i++)
+            if (tOutputSlots[i] != null && aOutputs[i] != null && (!GT_Utility.areStacksEqual(tOutputSlots[i], aOutputs[i], false) || tOutputSlots[i].stackSize + aOutputs[i].stackSize > tOutputSlots[i].getMaxStackSize())) {
+                mOutputBlocked++;
+                return false;
+            }
+        return true;
+    }
+
+    protected boolean canOutput(FluidStack aOutput) {
+        return getDrainableStack() == null || aOutput == null || (getDrainableStack().isFluidEqual(aOutput) && (getDrainableStack().amount <= 0 || getDrainableStack().amount + aOutput.amount <= getCapacity()));
+    }
+
+    protected ItemStack getInputAt(int aIndex) {
+        return mInventory[getInputSlot() + aIndex];
+    }
+
+    protected ItemStack[] getAllInputs() {
+        ItemStack[] rInputs = new ItemStack[mInputSlotCount];
+        for (int i = 0; i < mInputSlotCount; i++) rInputs[i] = getInputAt(i);
+        return rInputs;
+    }
+
+    protected boolean isOutputEmpty() {
+        boolean rIsEmpty = true;
+        for (ItemStack tOutputSlotContent : getAllOutputs()) if (tOutputSlotContent != null) rIsEmpty = false;
+        return rIsEmpty;
+    }
+
+    protected boolean displaysInputFluid() {
+        return true;
+    }
+
+    protected boolean displaysOutputFluid() {
+        return true;
+    }
+
+    @Override
+    public void onValueUpdate(byte aValue) {
+        mMainFacing = aValue;
+    }
+
+    @Override
+    public byte getUpdateData() {
+        return (byte) mMainFacing;
+    }
+
+    @Override
+    public void doSound(byte aIndex, double aX, double aY, double aZ) {
+        super.doSound(aIndex, aX, aY, aZ);
+        if (aIndex == 8) GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(210), 100, 1.0F, aX, aY, aZ);
+    }
+
+    public boolean doesAutoOutput() {
+        return mItemTransfer;
+    }
+
+    public boolean doesAutoOutputFluids() {
+        return mFluidTransfer;
+    }
+
+    public boolean allowToCheckRecipe() {
+        return true;
+    }
+
+    public boolean showPipeFacing() {
+        return true;
+    }
+
+    /**
+     * Called whenever the Machine successfully started a Process, useful for Sound Effects
+     */
+    public void startProcess() {
+        //
+    }
+
+    /**
+     * Called whenever the Machine successfully finished a Process, useful for Sound Effects
+     */
+    public void endProcess() {
+        //
+    }
+
+    /**
+     * Called whenever the Machine aborted a Process, useful for Sound Effects
+     */
+    public void abortProcess() {
+        //
+    }
+
+    /**
+     * Called whenever the Machine aborted a Process but still works on it, useful for Sound Effects
+     */
+    public void stutterProcess() {
+        if (useStandardStutterSound()) sendSound((byte) 8);
+    }
+
+    /**
+     * If this Machine can have the Insufficient Energy Line Problem
+     */
+    public boolean canHaveInsufficientEnergy() {
+        return true;
+    }
+
+    public boolean useStandardStutterSound() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[]{
+        		mRecipeStuff.toString(),
+                mNEIName,
+                "Progress:", (mProgresstime / 20) + " secs",
+                (mMaxProgresstime / 20) + " secs",
+                "Stored Energy:",
+                getBaseMetaTileEntity().getStoredEU() + "EU",
+                getBaseMetaTileEntity().getEUCapacity() + "EU"};
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (aSide == getBaseMetaTileEntity().getFrontFacing() || aSide == mMainFacing) {
+            mAllowInputFromOutputSide = !mAllowInputFromOutputSide;
+            GT_Utility.sendChatToPlayer(aPlayer, mAllowInputFromOutputSide ? "Input from Output Side allowed" : "Input from Output Side forbidden");
+        }
+    }
+
+    @Override
+    public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) {
+        return (aSide != mMainFacing || GregTech_API.getCoverBehavior(aCoverID.toStack()).isGUIClickable(aSide, GT_Utility.stackToInt(aCoverID.toStack()), 0, getBaseMetaTileEntity()));
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return aSide != mMainFacing && aIndex >= getOutputSlot() && aIndex < getOutputSlot() + mOutputItems.length;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        if (aSide == mMainFacing || aIndex < getInputSlot() || aIndex >= getInputSlot() + mInputSlotCount || (!mAllowInputFromOutputSide && aSide == aBaseMetaTileEntity.getFrontFacing()))
+            return false;
+        for (int i = getInputSlot(), j = i + mInputSlotCount; i < j; i++)
+            if (GT_Utility.areStacksEqual(GT_OreDictUnificator.get(aStack), mInventory[i])) return i == aIndex;
+        return true;
+    }
+
+    /**
+     * @return the Recipe List which is used for this Machine, this is a useful Default Handler
+     */
+    public Gregtech_Recipe_Map getRecipeList() {
+        return null;
+    }
+
+    /**
+     * Override this to check the Recipes yourself, super calls to this could be useful if you just want to add a special case
+     * <p/>
+     * I thought about Enum too, but Enum doesn't add support for people adding other return Systems.
+     * <p/>
+     * Funny how Eclipse marks the word Enum as not correctly spelled.
+     *
+     * @return see constants above
+     */
+    public int checkRecipe() {
+    	Gregtech_Recipe_Map tMap = getRecipeList();
+        if (tMap == null) return DID_NOT_FIND_RECIPE;
+        GregtechRecipe tRecipe = tMap.findRecipe(getBaseMetaTileEntity(), mLastRecipe, false, V[mTier], new FluidStack[]{getFillableStack()}, getSpecialSlot(), getAllInputs());
+        if (tRecipe == null) return DID_NOT_FIND_RECIPE;
+        if (tRecipe.mCanBeBuffered) mLastRecipe = tRecipe;
+        if (!canOutput(tRecipe)) {
+            mOutputBlocked++;
+            return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
+        }
+        if (!tRecipe.isRecipeInputEqual(true, new FluidStack[]{getFillableStack()}, getAllInputs()))
+            return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
+
+        for (int i = 0; i < mOutputItems.length; i++)
+            if (getBaseMetaTileEntity().getRandomNumber(10000) < tRecipe.getOutputChance(i))
+                mOutputItems[i] = tRecipe.getOutput(i);
+        mOutputFluid = tRecipe.getFluidOutput(0);
+        calculateOverclockedNess(tRecipe);
+        return FOUND_AND_SUCCESSFULLY_USED_RECIPE;
+    }
+
+    public ITexture[] getSideFacingActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getSideFacingInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getFrontFacingActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getFrontFacingInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getTopFacingActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getTopFacingInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBottomFacingActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBottomFacingInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBottomFacingPipeActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+    }
+
+    public ITexture[] getBottomFacingPipeInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+    }
+
+    public ITexture[] getTopFacingPipeActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+    }
+
+    public ITexture[] getTopFacingPipeInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+    }
+
+    public ITexture[] getSideFacingPipeActive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+    }
+
+    public ITexture[] getSideFacingPipeInactive(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/xmod/gregtech/api/util/GregtechRecipe.java b/src/Java/miscutil/xmod/gregtech/api/util/GregtechRecipe.java
index 96359550a3..10163bc3a5 100644
--- a/src/Java/miscutil/xmod/gregtech/api/util/GregtechRecipe.java
+++ b/src/Java/miscutil/xmod/gregtech/api/util/GregtechRecipe.java
@@ -204,6 +204,22 @@ public class GregtechRecipe {
 			}
 		}
 	}
+	
+	//Custom Recipe Handlers
+	public GregtechRecipe(ItemStack aInput, FluidStack aFluid, ItemStack[] aOutput, int aDuration, int aEUt) {
+        this(true, new ItemStack[]{aInput}, aOutput.clone(), null, null, new FluidStack[]{aFluid}, null, aDuration, aEUt, 0);
+        if (mInputs.length > 0 && mOutputs[0] != null) {
+            Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(this);
+        }
+    }
+	
+	/*public GregtechRecipe(ItemStack aInput, FluidStack aFluid, ItemStack[] aOutput, int aDuration, int aEUt) {
+        this(true, new ItemStack[]{aInput}, aOutput.clone(), null, null, new FluidStack[]{aFluid}, null, aDuration, aEUt, 0);
+        if (mInputs.length > 0 && mOutputs[0] != null) {
+            Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(this);
+        }
+    }*/
+	
 
 	public static void reInit() {
 		GT_Log.out.println("GT_Mod: Re-Unificating Recipes.");
@@ -307,7 +323,8 @@ public class GregtechRecipe {
 		//public static final Gregtech_Recipe_Map sMatterFabRecipes = new Gregtech_Recipe_Map(new HashSet<GregtechRecipe>(200), "gt.recipe.matterfab", "Matter Fabricator", null, RES_PATH_GUI + "basicmachines/Massfabricator", 1, 3, 1, 1, 1, E, 1, E, true, true);
 		public static final Gregtech_Recipe_Map_Fuel sRocketFuels = new Gregtech_Recipe_Map_Fuel(new HashSet<GregtechRecipe>(10), "gt.recipe.rocketenginefuel", "Rocket Engine Fuel", null, RES_PATH_GUI + "basicmachines/Default", 1, 1, 0, 0, 1, "Fuel Value: ", 3000, " EU", true, true);
 		public static final Gregtech_Recipe_Map_Fuel sGeoThermalFuels = new Gregtech_Recipe_Map_Fuel(new HashSet<GregtechRecipe>(10), "gt.recipe.geothermalfuel", "GeoThermal Fuel", null, RES_PATH_GUI + "basicmachines/Default", 1, 1, 0, 0, 1, "Fuel Value: ", 1000, " EU", true, true);
-
+		public static final Gregtech_Recipe_Map sChemicalDehydratorRecipes = new Gregtech_Recipe_Map(new HashSet<GregtechRecipe>(200), "gt.recipe.chemicaldehydrator", "Chemical Dehydrator", null, RES_PATH_GUI + "basicmachines/Sifter", 1, 1, 0, 0, 1, E, 1, E, true, true);
+		
 		/**
 		 * HashMap of Recipes based on their Items
 		 */
diff --git a/src/Java/miscutil/xmod/gregtech/recipes/GregtechRecipeAdder.java b/src/Java/miscutil/xmod/gregtech/recipes/GregtechRecipeAdder.java
index 5460689ec8..13e41ba62b 100644
--- a/src/Java/miscutil/xmod/gregtech/recipes/GregtechRecipeAdder.java
+++ b/src/Java/miscutil/xmod/gregtech/recipes/GregtechRecipeAdder.java
@@ -67,7 +67,7 @@ public class GregtechRecipeAdder implements IGregtech_RecipeAdder {
 	}
 	
 	@Override
-	public boolean addMattrFabricatorRecipe(FluidStack aFluidInput, FluidStack aFluidOutput, int aDuration, int aEUt) {
+	public boolean addMatterFabricatorRecipe(FluidStack aFluidInput, FluidStack aFluidOutput, int aDuration, int aEUt) {
 		try {
 			try {
 				RECIPEHANDLER_MatterFabricator.debug1();
@@ -132,5 +132,46 @@ public class GregtechRecipeAdder implements IGregtech_RecipeAdder {
         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;
+                }
+                GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, new ItemStack[]{aItemA, aItemB}, aOutputItems.clone(), null, null, null, aDuration, aEUt, 0);
+                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;
+        }
+        GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, new ItemStack[]{aItemA, aItemB}, aOutputItems.clone(), null, null, null, aDuration, aEUt, 0);
+        return true;
+    }
+	
+	@Override
+	public boolean addDehydratorRecipe(ItemStack aInput, FluidStack aFluid, ItemStack[] aOutput, int aDuration, int aEUt) {
+        if ((aInput == null) || (aFluid == null) || (aOutput == null)) {
+            return false;
+        }
+        if ((aDuration = GregTech_API.sRecipeFile.get("dehydrator", aInput, aDuration)) <= 0) {
+            return false;
+        }
+        GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes.addRecipe(true, new ItemStack[]{aInput}, aOutput.clone(), null, new FluidStack[]{aFluid}, null, aDuration, aEUt, 0);
+        return true;
+    }
+
 
 }
diff --git a/src/Java/miscutil/xmod/gregtech/registration/gregtech/GregtechDehydrator.java b/src/Java/miscutil/xmod/gregtech/registration/gregtech/GregtechDehydrator.java
index 9a210cd555..d5b61eae7a 100644
--- a/src/Java/miscutil/xmod/gregtech/registration/gregtech/GregtechDehydrator.java
+++ b/src/Java/miscutil/xmod/gregtech/registration/gregtech/GregtechDehydrator.java
@@ -1,11 +1,11 @@
 package miscutil.xmod.gregtech.registration.gregtech;
 
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_GT_Recipe;
-import gregtech.api.util.GT_Recipe;
 import miscutil.core.lib.CORE;
 import miscutil.core.lib.LoadedMods;
 import miscutil.core.util.Utils;
 import miscutil.xmod.gregtech.api.enums.GregtechItemList;
+import miscutil.xmod.gregtech.api.metatileentity.implementations.base.GT_MTE_BasicMachine_Custom_Recipe;
+import miscutil.xmod.gregtech.api.util.GregtechRecipe;
 
 public class GregtechDehydrator
 {
@@ -15,28 +15,85 @@ public class GregtechDehydrator
 			Utils.LOG_INFO("Gregtech5u Content | Registering Chemical Dehydrators.");
 			run1();
 		}
-		
+
 	}
 
 	private static void run1()
 	{
-		
-		GregtechItemList.GT_Dehydrator_EV.set(new GT_MetaTileEntity_BasicMachine_GT_Recipe(813, "advancedmachine.dehydrator.tier.01", "Advanced Chemical Dehydrator I", 4, "Remind Alkalus to add something here."+CORE.GT_Tooltip,
-        		GT_Recipe.GT_Recipe_Map.sSifterRecipes, 1, 9, 0, 2, 5, "Sifter.png", "", false, false, 0, "SIFTER", null).getStackForm(1L));
-		GregtechItemList.GT_Dehydrator_IV.set(new GT_MetaTileEntity_BasicMachine_GT_Recipe(814, "advancedmachine.dehydrator.tier.02", "Advanced Chemical Dehydrator II", 5, "Remind Alkalus to add something here."+CORE.GT_Tooltip,
-        		GT_Recipe.GT_Recipe_Map.sSifterRecipes, 1, 9, 0, 2, 5, "Sifter.png", "", false, false, 0, "SIFTER", null).getStackForm(1L));
-		GregtechItemList.GT_Dehydrator_LuV.set(new GT_MetaTileEntity_BasicMachine_GT_Recipe(815, "advancedmachine.dehydrator.tier.03", "Advanced Chemical Dehydrator III", 6, "Remind Alkalus to add something here."+CORE.GT_Tooltip,
-        		GT_Recipe.GT_Recipe_Map.sSifterRecipes, 1, 9, 0, 2, 5, "Sifter.png", "", false, false, 0, "SIFTER", null).getStackForm(1L));
-		GregtechItemList.GT_Dehydrator_ZPM.set(new GT_MetaTileEntity_BasicMachine_GT_Recipe(816, "advancedmachine.dehydrator.tier.04", "Advanced Chemical Dehydrator IV", 7, "Remind Alkalus to add something here."+CORE.GT_Tooltip,
-        		GT_Recipe.GT_Recipe_Map.sSifterRecipes, 1, 9, 0, 2, 5, "Sifter.png", "", false, false, 0, "SIFTER", null).getStackForm(1L));
-		
-        //GregtechItemList.GT_Dehydrator_EV.set(new GregtechMetaTileEntitySolarGenerator(813, "dehydrator.tier.01", "Extreme Voltage Chemical Dehydrator", 4).getStackForm(1L));
-        //GregtechItemList..set(new GregtechMetaTileEntitySolarGenerator(814, "dehydrator.tier.02", "Insane Voltage Chemical Dehydrator", 5).getStackForm(1L));
-        //GregtechItemList..set(new GregtechMetaTileEntitySolarGenerator(815, "dehydrator.tier.03", "Ludicrous Voltage Chemical Dehydrator", 6).getStackForm(1L));
-        //GregtechItemList..set(new GregtechMetaTileEntitySolarGenerator(816, "dehydrator.tier.04", "ZPM Voltage Chemical Dehydrator", 7).getStackForm(1L));
-		
-        
-        
-        
+
+		/*
+
+		 public GT_MetaTileEntity_BasicMachine_GT_Recipe(
+		  int aID, String aName, String aNameRegional, int aTier,
+		  String aDescription, 
+		  GT_Recipe_Map aRecipes,
+		  int aInputSlots, int aOutputSlots,
+		  int aTankCapacity,
+		  int aGUIParameterA, int aGUIParameterB,
+		  String aGUIName, String aSound,
+		  boolean aSharedTank, boolean aRequiresFluidForFiltering,
+		  int aSpecialEffect,
+		  String aOverlays,
+		  Object[] aRecipe) {	  
+
+		 */
+
+		GregtechItemList.GT_Dehydrator_EV.set(new GT_MTE_BasicMachine_Custom_Recipe(
+				813, "advancedmachine.dehydrator.tier.01", "Chemical Dehydrator I", 4,
+				"Remind Alkalus to add something here."+System.getProperty("line.separator")+CORE.GT_Tooltip,
+				GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes,
+				2, 9,
+				10000,
+				2, 5, 
+				"Dehydrator.png", "",
+				false, false,
+				0,
+				"UNBOXINATOR",
+				null).getStackForm(1L));
+		GregtechItemList.GT_Dehydrator_IV.set(new GT_MTE_BasicMachine_Custom_Recipe(
+				814, "advancedmachine.dehydrator.tier.02", "Chemical Dehydrator II", 5,
+				"Remind Alkalus to add something here."+System.getProperty("line.separator")+CORE.GT_Tooltip,
+				GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes,
+				2, 9,
+				10000,
+				2, 5, 
+				"Dehydrator.png", "",
+				false, false,
+				0,
+				"UNBOXINATOR",
+				null).getStackForm(1L));
+		GregtechItemList.GT_Dehydrator_LuV.set(new GT_MTE_BasicMachine_Custom_Recipe(
+				815, "advancedmachine.dehydrator.tier.03", "Chemical Dehydrator III", 6,
+				"Remind Alkalus to add something here."+System.getProperty("line.separator")+CORE.GT_Tooltip,
+				GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes,
+				2, 9,
+				10000,
+				2, 5, 
+				"Dehydrator.png", "",
+				false, false,
+				0,
+				"UNBOXINATOR",
+				null).getStackForm(1L));
+		GregtechItemList.GT_Dehydrator_ZPM.set(new GT_MTE_BasicMachine_Custom_Recipe(
+				816, "advancedmachine.dehydrator.tier.04", "Chemical Dehydrator IV", 7,
+				"Remind Alkalus to add something here."+System.getProperty("line.separator")+CORE.GT_Tooltip,
+				GregtechRecipe.Gregtech_Recipe_Map.sChemicalDehydratorRecipes,
+				2, 9,
+				10000,
+				2, 5, 
+				"Dehydrator.png", "",
+				false, false,
+				0,
+				"UNBOXINATOR",
+				null).getStackForm(1L));
+
+		//GregtechItemList.GT_Dehydrator_EV.set(new GregtechMetaTileEntitySolarGenerator(813, "dehydrator.tier.01", "Extreme Voltage Chemical Dehydrator", 4).getStackForm(1L));
+		//GregtechItemList..set(new GregtechMetaTileEntitySolarGenerator(814, "dehydrator.tier.02", "Insane Voltage Chemical Dehydrator", 5).getStackForm(1L));
+		//GregtechItemList..set(new GregtechMetaTileEntitySolarGenerator(815, "dehydrator.tier.03", "Ludicrous Voltage Chemical Dehydrator", 6).getStackForm(1L));
+		//GregtechItemList..set(new GregtechMetaTileEntitySolarGenerator(816, "dehydrator.tier.04", "ZPM Voltage Chemical Dehydrator", 7).getStackForm(1L));
+
+
+
+
 	}
 }