+ Gave Fission Fuels their own NEI handler, which allows 9 input fluids.

% Moved Fission Fuel recipe map to it's own class, specially for the NEI handler.

^ Updated CodeChickenCore-1.7.10-1.0.6.44-dev.jar to CodeChickenCore-1.7.10-1.0.7.47-dev.jar.
^ Updated CodeChickenLib-1.7.10-1.1.3.136-dev.jar to CodeChickenLib-1.7.10-1.1.3.140-dev.jar.
^ Updated NotEnoughItems-1.7.10-1.0.4.107-dev.jar to NotEnoughItems-1.7.10-1.0.5.120-dev.jar.

5 files changed, 1159 insertions, 7 deletions

diff --git a/src/Java/gregtech/api/util/CustomRecipeMap.java b/src/Java/gregtech/api/util/CustomRecipeMap.java
new file mode 100644
index 0000000000..3434239ca7
--- /dev/null
+++ b/src/Java/gregtech/api/util/CustomRecipeMap.java
@@ -0,0 +1,263 @@
+package gregtech.api.util;
+
+import static gregtech.api.enums.GT_Values.*;
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.tileentity.IHasWorldObjectAndCoords;
+import gregtech.api.objects.GT_ItemStack;
+
+import java.util.*;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+public class CustomRecipeMap/* extends GT_Recipe_Map*/{
+        /**
+         * Contains all Recipe Maps
+         */
+        public static final Collection<CustomRecipeMap> sMappings = new ArrayList<CustomRecipeMap>();
+
+        //public static final CustomRecipeMap sOreWasherRecipes = new GT_Recipe_Map_OreWasher(new HashSet<GT_Recipe>(0), "ic.recipe.orewasher", "Ore Washer", "ic2.blockOreWashingPlant", RES_PATH_GUI + "basicmachines/OreWasher", 1, 3, 1, 1, 1, E, 1, E, true, false);
+      //Fission Fuel Plant Recipes
+      	public static final CustomRecipeMap sFissionFuelProcessing = new CustomRecipeMap(new HashSet<GT_Recipe>(50), "gt.recipe.fissionfuel", "Fission Fuel Processing", null, RES_PATH_GUI + "basicmachines/LFTR", 0, 0, 0, 9, 1, E, 1, E, true, true);
+      		
+        /**
+         * HashMap of Recipes based on their Items
+         */
+        public final Map<GT_ItemStack, Collection<GT_Recipe>> mRecipeItemMap = new HashMap<GT_ItemStack, Collection<GT_Recipe>>();
+        /**
+         * HashMap of Recipes based on their Fluids
+         */
+        public final Map<Fluid, Collection<GT_Recipe>> mRecipeFluidMap = new HashMap<Fluid, Collection<GT_Recipe>>();
+        /**
+         * The List of all Recipes
+         */
+        public final Collection<GT_Recipe> mRecipeList;
+        /**
+         * String used as an unlocalised Name.
+         */
+        public final String mUnlocalizedName;
+        /**
+         * String used in NEI for the Recipe Lists. If null it will use the unlocalised Name instead
+         */
+        public final String mNEIName;
+        /**
+         * GUI used for NEI Display. Usually the GUI of the Machine itself
+         */
+        public final String mNEIGUIPath;
+        public final String mNEISpecialValuePre, mNEISpecialValuePost;
+        public final int mUsualInputCount, mUsualOutputCount, mNEISpecialValueMultiplier, mMinimalInputItems, mMinimalInputFluids, mAmperage;
+        public final boolean mNEIAllowed, mShowVoltageAmperageInNEI;
+
+        /**
+         * Initialises a new type of Recipe Handler.
+         *
+         * @param aRecipeList                a List you specify as Recipe List. Usually just an ArrayList with a pre-initialised Size.
+         * @param aUnlocalizedName           the unlocalised Name of this Recipe Handler, used mainly for NEI.
+         * @param aLocalName                 the displayed Name inside the NEI Recipe GUI.
+         * @param aNEIGUIPath                the displayed GUI Texture, usually just a Machine GUI. Auto-Attaches ".png" if forgotten.
+         * @param aUsualInputCount           the usual amount of Input Slots this Recipe Class has.
+         * @param aUsualOutputCount          the usual amount of Output Slots this Recipe Class has.
+         * @param aNEISpecialValuePre        the String in front of the Special Value in NEI.
+         * @param aNEISpecialValueMultiplier the Value the Special Value is getting Multiplied with before displaying
+         * @param aNEISpecialValuePost       the String after the Special Value. Usually for a Unit or something.
+         * @param aNEIAllowed                if NEI is allowed to display this Recipe Handler in general.
+         */
+        public CustomRecipeMap(Collection<GT_Recipe> aRecipeList, String aUnlocalizedName, String aLocalName, String aNEIName, String aNEIGUIPath, int aUsualInputCount, int aUsualOutputCount, int aMinimalInputItems, int aMinimalInputFluids, int aAmperage, String aNEISpecialValuePre, int aNEISpecialValueMultiplier, String aNEISpecialValuePost, boolean aShowVoltageAmperageInNEI, boolean aNEIAllowed) {
+            //super(aRecipeList, aUnlocalizedName, aLocalName, aNEIName, aNEIGUIPath, aUsualInputCount, aUsualOutputCount, aMinimalInputItems, aMinimalInputFluids, aAmperage, aNEISpecialValuePre, aNEISpecialValueMultiplier, aNEISpecialValuePost, aShowVoltageAmperageInNEI, aNEIAllowed);
+        	sMappings.add(this);
+            mNEIAllowed = aNEIAllowed;
+            mShowVoltageAmperageInNEI = aShowVoltageAmperageInNEI;
+            mRecipeList = aRecipeList;
+            mNEIName = aNEIName == null ? aUnlocalizedName : aNEIName;
+            mNEIGUIPath = aNEIGUIPath.endsWith(".png") ? aNEIGUIPath : aNEIGUIPath + ".png";
+            mNEISpecialValuePre = aNEISpecialValuePre;
+            mNEISpecialValueMultiplier = aNEISpecialValueMultiplier;
+            mNEISpecialValuePost = aNEISpecialValuePost;
+            mAmperage = aAmperage;
+            mUsualInputCount = aUsualInputCount;
+            mUsualOutputCount = aUsualOutputCount;
+            mMinimalInputItems = aMinimalInputItems;
+            mMinimalInputFluids = aMinimalInputFluids;
+            GregTech_API.sFluidMappings.add(mRecipeFluidMap);
+            GregTech_API.sItemStackMappings.add(mRecipeItemMap);
+            GT_LanguageManager.addStringLocalization(mUnlocalizedName = aUnlocalizedName, aLocalName);
+        }
+
+        public GT_Recipe addRecipe(boolean aOptimize, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addRecipe(new GT_Recipe(aOptimize, aInputs, aOutputs, aSpecial, aOutputChances, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        public GT_Recipe addRecipe(int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addRecipe(new GT_Recipe(false, null, null, null, aOutputChances, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue), false, false, false);
+        }
+
+        public GT_Recipe addRecipe(boolean aOptimize, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addRecipe(new GT_Recipe(aOptimize, aInputs, aOutputs, aSpecial, null, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        public GT_Recipe addRecipe(GT_Recipe aRecipe) {
+            return addRecipe(aRecipe, true, false, false);
+        }
+
+        protected GT_Recipe addRecipe(GT_Recipe aRecipe, boolean aCheckForCollisions, boolean aFakeRecipe, boolean aHidden) {
+            aRecipe.mHidden = aHidden;
+            aRecipe.mFakeRecipe = aFakeRecipe;
+            if (aRecipe.mFluidInputs.length < mMinimalInputFluids && aRecipe.mInputs.length < mMinimalInputItems)
+                return null;
+            if (aCheckForCollisions && findRecipe(null, false, Long.MAX_VALUE, aRecipe.mFluidInputs, aRecipe.mInputs) != null)
+                return null;
+            return add(aRecipe);
+        }
+
+        /**
+         * Only used for fake Recipe Handlers to show something in NEI, do not use this for adding actual Recipes! findRecipe wont find fake Recipes, containsInput WILL find fake Recipes
+         */
+        public GT_Recipe addFakeRecipe(boolean aCheckForCollisions, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addFakeRecipe(aCheckForCollisions, new GT_Recipe(false, aInputs, aOutputs, aSpecial, aOutputChances, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        /**
+         * Only used for fake Recipe Handlers to show something in NEI, do not use this for adding actual Recipes! findRecipe wont find fake Recipes, containsInput WILL find fake Recipes
+         */
+        public GT_Recipe addFakeRecipe(boolean aCheckForCollisions, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addFakeRecipe(aCheckForCollisions, new GT_Recipe(false, aInputs, aOutputs, aSpecial, null, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        /**
+         * Only used for fake Recipe Handlers to show something in NEI, do not use this for adding actual Recipes! findRecipe wont find fake Recipes, containsInput WILL find fake Recipes
+         */
+        public GT_Recipe addFakeRecipe(boolean aCheckForCollisions, GT_Recipe aRecipe) {
+            return addRecipe(aRecipe, aCheckForCollisions, true, false);
+        }
+
+        public GT_Recipe add(GT_Recipe aRecipe) {
+            mRecipeList.add(aRecipe);
+            for (FluidStack aFluid : aRecipe.mFluidInputs)
+                if (aFluid != null) {
+                    Collection<GT_Recipe> tList = mRecipeFluidMap.get(aFluid.getFluid());
+                    if (tList == null) mRecipeFluidMap.put(aFluid.getFluid(), tList = new HashSet<GT_Recipe>(1));
+                    tList.add(aRecipe);
+                }
+            return addToItemMap(aRecipe);
+        }
+
+        public void reInit() {
+            Map<GT_ItemStack, Collection<GT_Recipe>> tMap = mRecipeItemMap;
+            if (tMap != null) tMap.clear();
+            for (GT_Recipe tRecipe : mRecipeList) {
+                GT_OreDictUnificator.setStackArray(true, tRecipe.mInputs);
+                GT_OreDictUnificator.setStackArray(true, tRecipe.mOutputs);
+                if (tMap != null) addToItemMap(tRecipe);
+            }
+        }
+
+        /**
+         * @return if this Item is a valid Input for any for the Recipes
+         */
+        public boolean containsInput(ItemStack aStack) {
+            return aStack != null && (mRecipeItemMap.containsKey(new GT_ItemStack(aStack)) || mRecipeItemMap.containsKey(new GT_ItemStack(GT_Utility.copyMetaData(W, aStack))));
+        }
+
+        /**
+         * @return if this Fluid is a valid Input for any for the Recipes
+         */
+        public boolean containsInput(FluidStack aFluid) {
+            return aFluid != null && containsInput(aFluid.getFluid());
+        }
+
+        /**
+         * @return if this Fluid is a valid Input for any for the Recipes
+         */
+        public boolean containsInput(Fluid aFluid) {
+            return aFluid != null && mRecipeFluidMap.containsKey(aFluid);
+        }
+
+        public GT_Recipe findRecipe(IHasWorldObjectAndCoords aTileEntity, boolean aNotUnificated, long aVoltage, FluidStack[] aFluids, ItemStack... aInputs) {
+            return findRecipe(aTileEntity, null, aNotUnificated, aVoltage, aFluids, null, aInputs);
+        }
+
+        public GT_Recipe findRecipe(IHasWorldObjectAndCoords aTileEntity, GT_Recipe aRecipe, boolean aNotUnificated, long aVoltage, FluidStack[] aFluids, ItemStack... aInputs) {
+            return findRecipe(aTileEntity, aRecipe, aNotUnificated, aVoltage, aFluids, null, aInputs);
+        }
+
+        /**
+         * finds a Recipe matching the aFluid and ItemStack Inputs.
+         *
+         * @param aTileEntity    an Object representing the current coordinates of the executing Block/Entity/Whatever. This may be null, especially during Startup.
+         * @param aRecipe        in case this is != null it will try to use this Recipe first when looking things up.
+         * @param aNotUnificated if this is T the Recipe searcher will unificate the ItemStack Inputs
+         * @param aVoltage       Voltage of the Machine or Long.MAX_VALUE if it has no Voltage
+         * @param aFluids        the Fluid Inputs
+         * @param aSpecialSlot   the content of the Special Slot, the regular Manager doesn't do anything with this, but some custom ones do.
+         * @param aInputs        the Item Inputs
+         * @return the Recipe it has found or null for no matching Recipe
+         */
+        public GT_Recipe findRecipe(IHasWorldObjectAndCoords aTileEntity, GT_Recipe aRecipe, boolean aNotUnificated, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot, ItemStack... aInputs) {
+            // No Recipes? Well, nothing to be found then.
+            if (mRecipeList.isEmpty()) return null;
+
+            // Some Recipe Classes require a certain amount of Inputs of certain kinds. Like "at least 1 Fluid + 1 Stack" or "at least 2 Stacks" before they start searching for Recipes.
+            // This improves Performance massively, especially if people leave things like Circuits, Molds or Shapes in their Machines to select Sub Recipes.
+            if (GregTech_API.sPostloadFinished) {
+                if (mMinimalInputFluids > 0) {
+                    if (aFluids == null) return null;
+                    int tAmount = 0;
+                    for (FluidStack aFluid : aFluids) if (aFluid != null) tAmount++;
+                    if (tAmount < mMinimalInputFluids) return null;
+                }
+                if (mMinimalInputItems > 0) {
+                    if (aInputs == null) return null;
+                    int tAmount = 0;
+                    for (ItemStack aInput : aInputs) if (aInput != null) tAmount++;
+                    if (tAmount < mMinimalInputItems) return null;
+                }
+            }
+
+            // Unification happens here in case the Input isn't already unificated.
+            if (aNotUnificated) aInputs = GT_OreDictUnificator.getStackArray(true, (Object[]) aInputs);
+
+            // Check the Recipe which has been used last time in order to not have to search for it again, if possible.
+            if (aRecipe != null)
+                if (!aRecipe.mFakeRecipe && aRecipe.mCanBeBuffered && aRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                    return aRecipe.mEnabled && aVoltage * mAmperage >= aRecipe.mEUt ? aRecipe : null;
+
+            // Now look for the Recipes inside the Item HashMaps, but only when the Recipes usually have Items.
+            if (mUsualInputCount > 0 && aInputs != null) for (ItemStack tStack : aInputs)
+                if (tStack != null) {
+                    Collection<GT_Recipe>
+                            tRecipes = mRecipeItemMap.get(new GT_ItemStack(tStack));
+                    if (tRecipes != null) for (GT_Recipe tRecipe : tRecipes)
+                        if (!tRecipe.mFakeRecipe && tRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt ? tRecipe : null;
+                    tRecipes = mRecipeItemMap.get(new GT_ItemStack(GT_Utility.copyMetaData(W, tStack)));
+                    if (tRecipes != null) for (GT_Recipe tRecipe : tRecipes)
+                        if (!tRecipe.mFakeRecipe && tRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt ? tRecipe : null;
+                }
+
+            // If the minimal Amount of Items for the Recipe is 0, then it could be a Fluid-Only Recipe, so check that Map too.
+            if (mMinimalInputItems == 0 && aFluids != null) for (FluidStack aFluid : aFluids)
+                if (aFluid != null) {
+                    Collection<GT_Recipe>
+                            tRecipes = mRecipeFluidMap.get(aFluid.getFluid());
+                    if (tRecipes != null) for (GT_Recipe tRecipe : tRecipes)
+                        if (!tRecipe.mFakeRecipe && tRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt ? tRecipe : null;
+                }
+
+            // And nothing has been found.
+            return null;
+        }
+
+        protected GT_Recipe addToItemMap(GT_Recipe aRecipe) {
+            for (ItemStack aStack : aRecipe.mInputs)
+                if (aStack != null) {
+                    GT_ItemStack tStack = new GT_ItemStack(aStack);
+                    Collection<GT_Recipe> tList = mRecipeItemMap.get(tStack);
+                    if (tList == null) mRecipeItemMap.put(tStack, tList = new HashSet<GT_Recipe>(1));
+                    tList.add(aRecipe);
+                }
+            return aRecipe;
+        }
+    }
\ No newline at end of file
diff --git a/src/Java/gregtech/api/util/Recipe_GT.java b/src/Java/gregtech/api/util/Recipe_GT.java
index c020b7eeb9..f0b80f084a 100644
--- a/src/Java/gregtech/api/util/Recipe_GT.java
+++ b/src/Java/gregtech/api/util/Recipe_GT.java
@@ -133,7 +133,7 @@ public class Recipe_GT extends GT_Recipe{
 			int aDuration, int aEUt) {
         this(true, null, null, null, null, new FluidStack[]{aInput1, aInput2, aInput3, aInput4, aInput5, aInput6, aInput7, aInput8, aInput9}, new FluidStack[]{aOutput1, aOutput2}, Math.max(aDuration, 1), aEUt, 0);
         if (mInputs.length > 1) {
-        	Gregtech_Recipe_Map.sFissionFuelProcessing.addRecipe(this);
+        	CustomRecipeMap.sFissionFuelProcessing.addRecipe(this);
         }
     }
 	
@@ -150,39 +150,47 @@ public class Recipe_GT extends GT_Recipe{
 		for (Gregtech_Recipe_Map tMapEntry : Gregtech_Recipe_Map.sMappings) tMapEntry.reInit();
 	}
 	
+	@Override
 	public ItemStack getRepresentativeInput(int aIndex) {
         if (aIndex < 0 || aIndex >= mInputs.length) return null;
         return GT_Utility.copy(mInputs[aIndex]);
     }
 
-    public ItemStack getOutput(int aIndex) {
+    @Override
+	public ItemStack getOutput(int aIndex) {
         if (aIndex < 0 || aIndex >= mOutputs.length) return null;
         return GT_Utility.copy(mOutputs[aIndex]);
     }
 
-    public int getOutputChance(int aIndex) {
+    @Override
+	public int getOutputChance(int aIndex) {
         if (aIndex < 0 || aIndex >= mChances.length) return 10000;
         return mChances[aIndex];
     }
 
-    public FluidStack getRepresentativeFluidInput(int aIndex) {
+    @Override
+	public FluidStack getRepresentativeFluidInput(int aIndex) {
         if (aIndex < 0 || aIndex >= mFluidInputs.length || mFluidInputs[aIndex] == null) return null;
         return mFluidInputs[aIndex].copy();
     }
 
-    public FluidStack getFluidOutput(int aIndex) {
+    @Override
+	public FluidStack getFluidOutput(int aIndex) {
         if (aIndex < 0 || aIndex >= mFluidOutputs.length || mFluidOutputs[aIndex] == null) return null;
         return mFluidOutputs[aIndex].copy();
     }
 
+	@Override
 	public GT_Recipe copy() {
 		return this.copy();
 	}
 
+	@Override
 	public boolean isRecipeInputEqual(boolean aDecreaseStacksizeBySuccess, FluidStack[] aFluidInputs, ItemStack... aInputs) {
 		return isRecipeInputEqual(aDecreaseStacksizeBySuccess, false, aFluidInputs, aInputs);
 	}
 
+	@Override
 	public boolean isRecipeInputEqual(boolean aDecreaseStacksizeBySuccess, boolean aDontCheckStackSizes, FluidStack[] aFluidInputs, ItemStack... aInputs) {
 		if (mFluidInputs.length > 0 && aFluidInputs == null) return false;
 		for (FluidStack tFluid : mFluidInputs)
@@ -253,7 +261,7 @@ public class Recipe_GT extends GT_Recipe{
 		//LFTR recipes
 		public static final GT_Recipe_Map sLiquidFluorineThoriumReactorRecipes = new GT_Recipe_Map(new HashSet<GT_Recipe>(50), "gt.recipe.lftr", "Liquid Fluoride Thorium Reactor", null, RES_PATH_GUI + "basicmachines/LFTR", 0, 0, 0, 2, 1, "Start: ", 1, " EU", true, true);
 		//Fission Fuel Plant Recipes
-		public static final GT_Recipe_Map sFissionFuelProcessing = new GT_Recipe_Map(new HashSet<GT_Recipe>(50), "gt.recipe.fissionfuel", "Fission Fuel Processing", null, RES_PATH_GUI + "basicmachines/LFTR", 0, 0, 0, 9, 1, E, 1, E, true, true);
+		//public static final GT_Recipe_Map sFissionFuelProcessing = new GT_Recipe_Map(new HashSet<GT_Recipe>(50), "gt.recipe.fissionfuel", "Fission Fuel Processing", null, RES_PATH_GUI + "basicmachines/LFTR", 0, 0, 0, 9, 1, E, 1, E, true, true);
 		
 		/**
 		 * HashMap of Recipes based on their Items
diff --git a/src/Java/gtPlusPlus/nei/GT_NEI_DefaultHandler.java b/src/Java/gtPlusPlus/nei/GT_NEI_DefaultHandler.java
new file mode 100644
index 0000000000..c826a52363
--- /dev/null
+++ b/src/Java/gtPlusPlus/nei/GT_NEI_DefaultHandler.java
@@ -0,0 +1,849 @@
+package gtPlusPlus.nei;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.gui.GT_GUIContainer_BasicMachine;
+import gregtech.api.objects.ItemData;
+import gregtech.api.util.*;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.util.*;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.lwjgl.opengl.GL11;
+
+import codechicken.lib.gui.GuiDraw;
+import codechicken.nei.PositionedStack;
+import codechicken.nei.guihook.*;
+import codechicken.nei.recipe.*;
+import cpw.mods.fml.common.event.FMLInterModComms;
+
+public class GT_NEI_DefaultHandler
+        extends TemplateRecipeHandler {
+    public static final int sOffsetX = 5;
+    public static final int sOffsetY = 11;
+
+    static {
+        GuiContainerManager.addInputHandler(new GT_RectHandler());
+        GuiContainerManager.addTooltipHandler(new GT_RectHandler());
+    }
+
+    protected final CustomRecipeMap mRecipeMap;
+
+    public GT_NEI_DefaultHandler(CustomRecipeMap tMap) {
+        this.mRecipeMap = tMap;
+        this.transferRects.add(new TemplateRecipeHandler.RecipeTransferRect(new Rectangle(65, 13, 36, 18), getOverlayIdentifier(), new Object[0]));
+        if (!NEI_GT_Config.sIsAdded) {
+            FMLInterModComms.sendRuntimeMessage(GT_Values.GT, "NEIPlugins", "register-crafting-handler", "gregtechplusplus@" + getRecipeName() + "@" + getOverlayIdentifier());
+            GuiCraftingRecipe.craftinghandlers.add(this);
+            GuiUsageRecipe.usagehandlers.add(this);
+        }
+    }
+
+    public static void drawText(int aX, int aY, String aString, int aColor) {
+        Minecraft.getMinecraft().fontRenderer.drawString(aString, aX, aY, aColor);
+    }
+
+    @Override
+	public TemplateRecipeHandler newInstance() {
+        return new GT_NEI_DefaultHandler(this.mRecipeMap);
+    }
+
+    @Override
+	public void loadCraftingRecipes(String outputId, Object... results) {
+        if (outputId.equals(getOverlayIdentifier())) {
+            for (GT_Recipe tRecipe : this.mRecipeMap.mRecipeList) {
+                if (!tRecipe.mHidden) {
+                    this.arecipes.add(new CachedDefaultRecipe(tRecipe));
+                }
+            }
+        } else {
+            super.loadCraftingRecipes(outputId, results);
+        }
+    }
+
+    @Override
+	public void loadCraftingRecipes(ItemStack aResult) {
+        ItemData tPrefixMaterial = GT_OreDictUnificator.getAssociation(aResult);
+
+        ArrayList<ItemStack> tResults = new ArrayList();
+        tResults.add(aResult);
+        tResults.add(GT_OreDictUnificator.get(true, aResult));
+        if ((tPrefixMaterial != null) && (!tPrefixMaterial.mBlackListed) && (!tPrefixMaterial.mPrefix.mFamiliarPrefixes.isEmpty())) {
+            for (OrePrefixes tPrefix : tPrefixMaterial.mPrefix.mFamiliarPrefixes) {
+                tResults.add(GT_OreDictUnificator.get(tPrefix, tPrefixMaterial.mMaterial.mMaterial, 1L));
+            }
+        }
+        FluidStack tFluid = GT_Utility.getFluidForFilledItem(aResult, true);
+        if (tFluid != null) {
+            tResults.add(GT_Utility.getFluidDisplayStack(tFluid, false));
+            for (FluidContainerRegistry.FluidContainerData tData : FluidContainerRegistry.getRegisteredFluidContainerData()) {
+                if (tData.fluid.isFluidEqual(tFluid)) {
+                    tResults.add(GT_Utility.copy(new Object[]{tData.filledContainer}));
+                }
+            }
+        }
+        for (GT_Recipe tRecipe : this.mRecipeMap.mRecipeList) {
+            if (!tRecipe.mHidden) {
+                CachedDefaultRecipe tNEIRecipe = new CachedDefaultRecipe(tRecipe);
+                for (ItemStack tStack : tResults) {
+                    if (tNEIRecipe.contains(tNEIRecipe.mOutputs, tStack)) {
+                        this.arecipes.add(tNEIRecipe);
+                        break;
+                    }
+                }
+            }
+        }
+        CachedDefaultRecipe tNEIRecipe;
+    }
+
+    @Override
+	public void loadUsageRecipes(ItemStack aInput) {
+        ItemData tPrefixMaterial = GT_OreDictUnificator.getAssociation(aInput);
+
+        ArrayList<ItemStack> tInputs = new ArrayList();
+        tInputs.add(aInput);
+        tInputs.add(GT_OreDictUnificator.get(false, aInput));
+        if ((tPrefixMaterial != null) && (!tPrefixMaterial.mPrefix.mFamiliarPrefixes.isEmpty())) {
+            for (OrePrefixes tPrefix : tPrefixMaterial.mPrefix.mFamiliarPrefixes) {
+                tInputs.add(GT_OreDictUnificator.get(tPrefix, tPrefixMaterial.mMaterial.mMaterial, 1L));
+            }
+        }
+        FluidStack tFluid = GT_Utility.getFluidForFilledItem(aInput, true);
+        if (tFluid != null) {
+            tInputs.add(GT_Utility.getFluidDisplayStack(tFluid, false));
+            for (FluidContainerRegistry.FluidContainerData tData : FluidContainerRegistry.getRegisteredFluidContainerData()) {
+                if (tData.fluid.isFluidEqual(tFluid)) {
+                    tInputs.add(GT_Utility.copy(new Object[]{tData.filledContainer}));
+                }
+            }
+        }
+        for (GT_Recipe tRecipe : this.mRecipeMap.mRecipeList) {
+            if (!tRecipe.mHidden) {
+                CachedDefaultRecipe tNEIRecipe = new CachedDefaultRecipe(tRecipe);
+                for (ItemStack tStack : tInputs) {
+                    if (tNEIRecipe.contains(tNEIRecipe.mInputs, tStack)) {
+                        this.arecipes.add(tNEIRecipe);
+                        break;
+                    }
+                }
+            }
+        }
+        CachedDefaultRecipe tNEIRecipe;
+    }
+
+    @Override
+	public String getOverlayIdentifier() {
+        return this.mRecipeMap.mNEIName;
+    }
+
+    @Override
+	public void drawBackground(int recipe) {
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        GuiDraw.changeTexture(getGuiTexture());
+        GuiDraw.drawTexturedModalRect(-4, -8, 1, 3, 174, 78);
+    }
+
+    @Override
+	public int recipiesPerPage() {
+        return 1;
+    }
+
+    @Override
+	public String getRecipeName() {
+        return GT_LanguageManager.getTranslation(this.mRecipeMap.mUnlocalizedName);
+    }
+
+    @Override
+	public String getGuiTexture() {
+//    return "gregtech:textures/gui/" + this.mRecipeMap.mUnlocalizedName + ".png";
+        return this.mRecipeMap.mNEIGUIPath;
+    }
+
+    @Override
+	public List<String> handleItemTooltip(GuiRecipe gui, ItemStack aStack, List<String> currenttip, int aRecipeIndex) {
+        TemplateRecipeHandler.CachedRecipe tObject = (TemplateRecipeHandler.CachedRecipe) this.arecipes.get(aRecipeIndex);
+        if ((tObject instanceof CachedDefaultRecipe)) {
+            CachedDefaultRecipe tRecipe = (CachedDefaultRecipe) tObject;
+            for (PositionedStack tStack : tRecipe.mOutputs) {
+                if (aStack == tStack.item) {
+                    if ((!(tStack instanceof FixedPositionedStack)) || (((FixedPositionedStack) tStack).mChance <= 0) || (((FixedPositionedStack) tStack).mChance == 10000)) {
+                        break;
+                    }
+                    currenttip.add("Chance: " + ((FixedPositionedStack) tStack).mChance / 100 + "." + (((FixedPositionedStack) tStack).mChance % 100 < 10 ? "0" + ((FixedPositionedStack) tStack).mChance % 100 : Integer.valueOf(((FixedPositionedStack) tStack).mChance % 100)) + "%");
+                    break;
+                }
+            }
+            for (PositionedStack tStack : tRecipe.mInputs) {
+                if (aStack == tStack.item) {
+                    if ((gregtech.api.enums.ItemList.Display_Fluid.isStackEqual(tStack.item, true, true)) ||
+                            (tStack.item.stackSize != 0)) {
+                        break;
+                    }
+                    currenttip.add("Does not get consumed in the process");
+                    break;
+                }
+            }
+        }
+        return currenttip;
+    }
+
+    @Override
+	public void drawExtras(int aRecipeIndex) {
+        int tEUt = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mEUt;
+        int tDuration = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mDuration;
+        if (tEUt != 0) {
+            drawText(10, 73, "Total: " + tDuration * tEUt + " EU", -16777216);
+            drawText(10, 83, "Usage: " + tEUt + " EU/t", -16777216);
+            if (this.mRecipeMap.mShowVoltageAmperageInNEI) {
+                drawText(10, 93, "Voltage: " + tEUt / this.mRecipeMap.mAmperage + " EU", -16777216);
+                drawText(10, 103, "Amperage: " + this.mRecipeMap.mAmperage, -16777216);
+            } else {
+                drawText(10, 93, "Voltage: unspecified", -16777216);
+                drawText(10, 103, "Amperage: unspecified", -16777216);
+            }
+        }
+        if (tDuration > 0) {
+            drawText(10, 113, "Time: " + (tDuration < 20 ? "< 1" : Integer.valueOf(tDuration / 20)) + " secs", -16777216);
+        }
+        if ((GT_Utility.isStringValid(this.mRecipeMap.mNEISpecialValuePre)) || (GT_Utility.isStringValid(this.mRecipeMap.mNEISpecialValuePost))) {
+            drawText(10, 123, this.mRecipeMap.mNEISpecialValuePre + ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mSpecialValue * this.mRecipeMap.mNEISpecialValueMultiplier + this.mRecipeMap.mNEISpecialValuePost, -16777216);
+        }
+    }
+
+    public static class GT_RectHandler
+            implements IContainerInputHandler, IContainerTooltipHandler {
+        @Override
+		public boolean mouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
+            if (canHandle(gui)) {
+                if (button == 0) {
+                    return transferRect(gui, false);
+                }
+                if (button == 1) {
+                    return transferRect(gui, true);
+                }
+            }
+            return false;
+        }
+
+        @Override
+		public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyCode) {
+            return false;
+        }
+
+        public boolean canHandle(GuiContainer gui) {
+            return (((gui instanceof GT_GUIContainer_BasicMachine)) && (GT_Utility.isStringValid(((GT_GUIContainer_BasicMachine) gui).mNEI)) /*|| ((gui instanceof GT_GUIContainer_FusionReactor)) && (GT_Utility.isStringValid(((GT_GUIContainer_FusionReactor) gui).mNEI))*/);
+        }
+
+        @Override
+		public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) {
+            if ((canHandle(gui)) && (currenttip.isEmpty())) {
+                if (gui instanceof GT_GUIContainer_BasicMachine && new Rectangle(65, 13, 36, 18).contains(new Point(GuiDraw.getMousePosition().x - ((GT_GUIContainer_BasicMachine) gui).getLeft() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[0], GuiDraw.getMousePosition().y - ((GT_GUIContainer_BasicMachine) gui).getTop() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[1]))) {
+                    currenttip.add("Recipes");
+                } /*else if (gui instanceof GT_GUIContainer_FusionReactor && new Rectangle(145, 0, 24, 24).contains(new Point(GuiDraw.getMousePosition().x - ((GT_GUIContainer_FusionReactor) gui).getLeft() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[0], GuiDraw.getMousePosition().y - ((GT_GUIContainer_FusionReactor) gui).getTop() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[1]))) {
+                    currenttip.add("Recipes");
+                }*/
+
+            }
+            return currenttip;
+        }
+
+        private boolean transferRect(GuiContainer gui, boolean usage) {
+            if (gui instanceof GT_GUIContainer_BasicMachine) {
+                return (canHandle(gui)) && (new Rectangle(65, 13, 36, 18).contains(new Point(GuiDraw.getMousePosition().x - ((GT_GUIContainer_BasicMachine) gui).getLeft() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[0], GuiDraw.getMousePosition().y - ((GT_GUIContainer_BasicMachine) gui).getTop() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[1]))) && (usage ? GuiUsageRecipe.openRecipeGui(((GT_GUIContainer_BasicMachine) gui).mNEI, new Object[0]) : GuiCraftingRecipe.openRecipeGui(((GT_GUIContainer_BasicMachine) gui).mNEI, new Object[0]));
+            } /*else if (gui instanceof GT_GUIContainer_FusionReactor) {
+                return (canHandle(gui)) && (new Rectangle(145, 0, 24, 24).contains(new Point(GuiDraw.getMousePosition().x - ((GT_GUIContainer_FusionReactor) gui).getLeft() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[0], GuiDraw.getMousePosition().y - ((GT_GUIContainer_FusionReactor) gui).getTop() - codechicken.nei.recipe.RecipeInfo.getGuiOffset(gui)[1]))) && (usage ? GuiUsageRecipe.openRecipeGui(((GT_GUIContainer_FusionReactor) gui).mNEI, new Object[0]) : GuiCraftingRecipe.openRecipeGui(((GT_GUIContainer_FusionReactor) gui).mNEI, new Object[0]));
+            }*/
+            return false;
+        }
+
+        @Override
+		public List<String> handleItemDisplayName(GuiContainer gui, ItemStack itemstack, List<String> currenttip) {
+            return currenttip;
+        }
+
+        @Override
+		public List<String> handleItemTooltip(GuiContainer gui, ItemStack itemstack, int mousex, int mousey, List<String> currenttip) {
+            return currenttip;
+        }
+
+        @Override
+		public boolean keyTyped(GuiContainer gui, char keyChar, int keyCode) {
+            return false;
+        }
+
+        @Override
+		public void onKeyTyped(GuiContainer gui, char keyChar, int keyID) {
+        }
+
+        @Override
+		public void onMouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
+        }
+
+        @Override
+		public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button) {
+        }
+
+        @Override
+		public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
+            return false;
+        }
+
+        @Override
+		public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
+        }
+
+        @Override
+		public void onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime) {
+        }
+    }
+
+    public class FixedPositionedStack
+            extends PositionedStack {
+        public final int mChance;
+        public boolean permutated = false;
+
+        public FixedPositionedStack(Object object, int x, int y) {
+            this(object, x, y, 0);
+        }
+
+        public FixedPositionedStack(Object object, int x, int y, int aChance) {
+            super(object, x, y, true);
+            this.mChance = aChance;
+        }
+
+        @Override
+		public void generatePermutations() {
+            if (this.permutated) {
+                return;
+            }
+            ArrayList<ItemStack> tDisplayStacks = new ArrayList();
+            for (ItemStack tStack : this.items) {
+                if (GT_Utility.isStackValid(tStack)) {
+                    if (tStack.getItemDamage() == 32767) {
+                        List<ItemStack> permutations = codechicken.nei.ItemList.itemMap.get(tStack.getItem());
+                        if (!permutations.isEmpty()) {
+                            ItemStack stack;
+                            for (Iterator i$ = permutations.iterator(); i$.hasNext(); tDisplayStacks.add(GT_Utility.copyAmount(tStack.stackSize, new Object[]{stack}))) {
+                                stack = (ItemStack) i$.next();
+                            }
+                        } else {
+                            ItemStack base = new ItemStack(tStack.getItem(), tStack.stackSize);
+                            base.stackTagCompound = tStack.stackTagCompound;
+                            tDisplayStacks.add(base);
+                        }
+                    } else {
+                        tDisplayStacks.add(GT_Utility.copy(new Object[]{tStack}));
+                    }
+                }
+            }
+            this.items = ((ItemStack[]) tDisplayStacks.toArray(new ItemStack[0]));
+            if (this.items.length == 0) {
+                this.items = new ItemStack[]{new ItemStack(Blocks.fire)};
+            }
+            this.permutated = true;
+            setPermutationToRender(0);
+        }
+    }
+
+    public class CachedDefaultRecipe
+            extends TemplateRecipeHandler.CachedRecipe {
+        public final GT_Recipe mRecipe;
+        public final List<PositionedStack> mOutputs = new ArrayList();
+        public final List<PositionedStack> mInputs = new ArrayList();
+
+        public CachedDefaultRecipe(GT_Recipe aRecipe) {
+            super();
+            this.mRecipe = aRecipe;
+
+            int tStartIndex = 0;
+            switch (GT_NEI_DefaultHandler.this.mRecipeMap.mUsualInputCount) {
+                case 0:
+                    break;
+                case 1:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 14));
+                    }
+                    tStartIndex++;
+                    break;
+                case 2:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 14));
+                    }
+                    tStartIndex++;
+                    break;
+                case 3:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 14));
+                    }
+                    tStartIndex++;
+                    break;
+                case 4:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 23));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 23));
+                    }
+                    tStartIndex++;
+                    break;
+                case 5:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 23));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 23));
+                    }
+                    tStartIndex++;
+                    break;
+                case 6:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 5));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 23));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 23));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 23));
+                    }
+                    tStartIndex++;
+                    break;
+                case 7:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 32));
+                    }
+                    tStartIndex++;
+                    break;
+                case 8:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 32));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 32));
+                    }
+                    tStartIndex++;
+                    break;
+                default:
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, -4));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 14));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 12, 32));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 30, 32));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getRepresentativeInput(tStartIndex) != null) {
+                        this.mInputs.add(new FixedPositionedStack(aRecipe.getRepresentativeInput(tStartIndex), 48, 32));
+                    }
+                    tStartIndex++;
+            }
+            if (aRecipe.mSpecialItems != null) {
+                this.mInputs.add(new FixedPositionedStack(aRecipe.mSpecialItems, 120, 52));
+            }
+            tStartIndex = 0;
+            switch (GT_NEI_DefaultHandler.this.mRecipeMap.mUsualOutputCount) {
+                case 0:
+                    break;
+                case 1:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 2:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 3:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 4:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 5:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 6:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 5, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 23, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 7:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 32, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                case 8:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 32, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 32, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    break;
+                default:
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, -4, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 14, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 102, 32, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 120, 32, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+                    if (aRecipe.getOutput(tStartIndex) != null) {
+                        this.mOutputs.add(new FixedPositionedStack(aRecipe.getOutput(tStartIndex), 138, 32, aRecipe.getOutputChance(tStartIndex)));
+                    }
+                    tStartIndex++;
+            }
+                      
+        
+            //New fluid display behaviour when 3 fluid inputs are detected. (Basically a mix of the code below for outputs an the code above for 9 input slots.)
+            if (aRecipe.mFluidInputs.length > 2) {
+                if (aRecipe.mFluidInputs[0] != null && (aRecipe.mFluidInputs[0].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[0], true), 12, -4));
+                }
+                if (aRecipe.mFluidInputs[1] != null && (aRecipe.mFluidInputs[1].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[1], true), 30, -4));
+                }
+                if (aRecipe.mFluidInputs.length > 2 && aRecipe.mFluidInputs[2] != null && (aRecipe.mFluidInputs[2].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[2], true), 48, -4));
+                }
+                if (aRecipe.mFluidInputs.length > 3 && aRecipe.mFluidInputs[3] != null && (aRecipe.mFluidInputs[3].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[3], true), 12, 14));
+                }
+                if (aRecipe.mFluidInputs.length > 4 && aRecipe.mFluidInputs[4] != null && (aRecipe.mFluidInputs[4].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[4], true), 30, 14));
+                }
+                if (aRecipe.mFluidInputs.length > 5 && aRecipe.mFluidInputs[5] != null && (aRecipe.mFluidInputs[5].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[5], true), 48, 14));
+                }
+                if (aRecipe.mFluidInputs.length > 6 && aRecipe.mFluidInputs[6] != null && (aRecipe.mFluidInputs[6].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[6], true), 12, 32));
+                }
+                if (aRecipe.mFluidInputs.length > 7 && aRecipe.mFluidInputs[7] != null && (aRecipe.mFluidInputs[7].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[7], true), 30, 32));
+                }
+                if (aRecipe.mFluidInputs.length > 8 && aRecipe.mFluidInputs[8] != null && (aRecipe.mFluidInputs[8].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[8], true), 48, 32));
+                }
+            } 
+            //Returns to old behaviour if fluid inputs < 3
+            else if ((aRecipe.mFluidInputs.length > 0) && (aRecipe.mFluidInputs[0] != null) && (aRecipe.mFluidInputs[0].getFluid() != null)) {
+                this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[0], true), 48, 52));
+                if ((aRecipe.mFluidInputs.length == 2) && (aRecipe.mFluidInputs[1] != null) && (aRecipe.mFluidInputs[1].getFluid() != null)) {
+                    this.mInputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidInputs[1], true), 30, 52));
+                }
+            }
+            
+            if (aRecipe.mFluidOutputs.length > 1) {
+                if (aRecipe.mFluidOutputs[0] != null && (aRecipe.mFluidOutputs[0].getFluid() != null)) {
+                    this.mOutputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidOutputs[0], true), 120, 5));
+                }
+                if (aRecipe.mFluidOutputs[1] != null && (aRecipe.mFluidOutputs[1].getFluid() != null)) {
+                    this.mOutputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidOutputs[1], true), 138, 5));
+                }
+                if (aRecipe.mFluidOutputs.length > 2 && aRecipe.mFluidOutputs[2] != null && (aRecipe.mFluidOutputs[2].getFluid() != null)) {
+                    this.mOutputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidOutputs[2], true), 102, 23));
+                }
+                if (aRecipe.mFluidOutputs.length > 3 && aRecipe.mFluidOutputs[3] != null && (aRecipe.mFluidOutputs[3].getFluid() != null)) {
+                    this.mOutputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidOutputs[3], true), 120, 23));
+                }
+                if (aRecipe.mFluidOutputs.length > 4 && aRecipe.mFluidOutputs[4] != null && (aRecipe.mFluidOutputs[4].getFluid() != null)) {
+                    this.mOutputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidOutputs[4], true), 138, 23));
+                }
+            } else if ((aRecipe.mFluidOutputs.length > 0) && (aRecipe.mFluidOutputs[0] != null) && (aRecipe.mFluidOutputs[0].getFluid() != null)) {
+                this.mOutputs.add(new FixedPositionedStack(GT_Utility.getFluidDisplayStack(aRecipe.mFluidOutputs[0], true), 102, 52));
+            }
+        }
+
+        @Override
+		public List<PositionedStack> getIngredients() {
+            return getCycledIngredients(GT_NEI_DefaultHandler.this.cycleticks / 10, this.mInputs);
+        }
+
+        @Override
+		public PositionedStack getResult() {
+            return null;
+        }
+
+        @Override
+		public List<PositionedStack> getOtherStacks() {
+            return this.mOutputs;
+        }
+    }
+}
diff --git a/src/Java/gtPlusPlus/nei/NEI_GT_Config.java b/src/Java/gtPlusPlus/nei/NEI_GT_Config.java
new file mode 100644
index 0000000000..700541a83a
--- /dev/null
+++ b/src/Java/gtPlusPlus/nei/NEI_GT_Config.java
@@ -0,0 +1,30 @@
+package gtPlusPlus.nei;
+
+import gregtech.api.util.CustomRecipeMap;
+import codechicken.nei.api.IConfigureNEI;
+
+public class NEI_GT_Config
+        implements IConfigureNEI {
+    public static boolean sIsAdded = true;
+
+    @Override
+	public void loadConfig() {
+        sIsAdded = false;
+        for (CustomRecipeMap tMap : gregtech.api.util.CustomRecipeMap.sMappings) {
+            if (tMap.mNEIAllowed) {
+                new GT_NEI_DefaultHandler(tMap);
+            }
+        }
+        sIsAdded = true;
+    }
+
+    @Override
+	public String getName() {
+        return "GT++ NEI Plugin";
+    }
+
+    @Override
+	public String getVersion() {
+        return "(1.01)";
+    }
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java b/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java
index 4c31c51fe6..177ee518b0 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java
@@ -2,6 +2,7 @@ package gtPlusPlus.xmod.gregtech.recipes;
 
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.Materials;
+import gregtech.api.util.CustomRecipeMap;
 import gregtech.api.util.Recipe_GT;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.item.ItemUtils;
@@ -316,7 +317,8 @@ public class GregtechRecipeAdder implements IGregtech_RecipeAdder {
         }
 		FluidStack inputs[] = {aInput1, aInput2, aInput3, aInput4, aInput5, aInput6, aInput7, aInput8, aInput9};
 		FluidStack outputs[] = {aOutput1, aOutput2};
-        Recipe_GT.Gregtech_Recipe_Map.sFissionFuelProcessing.addRecipe(null, inputs, outputs, aDuration, aEUt, 0);
+        //Recipe_GT.Gregtech_Recipe_Map.sFissionFuelProcessing.addRecipe(null, inputs, outputs, aDuration, aEUt, 0);
+		CustomRecipeMap.sFissionFuelProcessing.addRecipe(null, inputs, outputs, aDuration, aEUt, 0);
         return true;
 	}