Merge in GoodGenerator with history

git-subtree-dir: goodgen
git-subtree-mainline: 13d47567b6b1103647e5a819e601b426911bb89d
git-subtree-split: 84481c22d7d4e0834de97a150d257ce6e85ad690

85 files changed, 22281 insertions, 0 deletions

diff --git a/goodgen/src/main/java/goodgenerator/api/recipe/ComponentAssemblyLineFrontend.java b/goodgen/src/main/java/goodgenerator/api/recipe/ComponentAssemblyLineFrontend.java
new file mode 100644
index 0000000000..b645c8e8f9
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/api/recipe/ComponentAssemblyLineFrontend.java
@@ -0,0 +1,44 @@
+package goodgenerator.api.recipe;
+
+import java.util.Collections;
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.common.gui.modularui.UIHelper;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class ComponentAssemblyLineFrontend extends RecipeMapFrontend {
+
+    public ComponentAssemblyLineFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder);
+    }
+
+    @Override
+    public List<Pos2d> getItemInputPositions(int itemInputCount) {
+        return UIHelper.getGridPositions(itemInputCount, 16, 8, 3);
+    }
+
+    @Override
+    public List<Pos2d> getItemOutputPositions(int itemOutputCount) {
+        return Collections.singletonList(new Pos2d(142, 8));
+    }
+
+    @Override
+    public List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+
+        return UIHelper.getGridPositions(fluidInputCount, 88, 26, 4);
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder, Pos2d windowOffset) {}
+}
diff --git a/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerBackend.java b/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerBackend.java
new file mode 100644
index 0000000000..cdd3a4d57f
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerBackend.java
@@ -0,0 +1,25 @@
+package goodgenerator.api.recipe;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.recipe.maps.FuelBackend;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class ExtremeHeatExchangerBackend extends FuelBackend {
+
+    public ExtremeHeatExchangerBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder);
+    }
+
+    @Override
+    public GT_Recipe compileRecipe(GT_Recipe recipe) {
+        if (!(recipe instanceof ExtremeHeatExchangerRecipe)) {
+            throw new RuntimeException("Recipe must be instance of ExtremeHeatExchangerRecipe");
+        }
+        return super.compileRecipe(recipe);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerFrontend.java b/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerFrontend.java
new file mode 100644
index 0000000000..b933802fc2
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerFrontend.java
@@ -0,0 +1,58 @@
+package goodgenerator.api.recipe;
+
+import java.util.Arrays;
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.nei.RecipeDisplayInfo;
+import gregtech.nei.formatter.INEISpecialInfoFormatter;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class ExtremeHeatExchangerFrontend extends RecipeMapFrontend {
+
+    public ExtremeHeatExchangerFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder.neiSpecialInfoFormatter(new EHESpecialValueFormatter()));
+    }
+
+    @Override
+    public List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+        return Arrays.asList(new Pos2d(26, 13), new Pos2d(26, 37));
+    }
+
+    @Override
+    public List<Pos2d> getFluidOutputPositions(int fluidOutputCount) {
+        return Arrays.asList(new Pos2d(128, 13), new Pos2d(128, 31), new Pos2d(128, 54));
+    }
+
+    private static class EHESpecialValueFormatter implements INEISpecialInfoFormatter {
+
+        @Override
+        public List<String> format(RecipeDisplayInfo recipeInfo) {
+            FluidStack[] Inputs = recipeInfo.recipe.mFluidInputs;
+            FluidStack[] Outputs = recipeInfo.recipe.mFluidOutputs;
+            int threshold = recipeInfo.recipe.mSpecialValue;
+            return Arrays.asList(
+                StatCollector.translateToLocal("value.extreme_heat_exchanger.0") + " "
+                    + GT_Utility.formatNumbers(Inputs[0].amount)
+                    + " L/s",
+                StatCollector.translateToLocal("value.extreme_heat_exchanger.1"),
+                GT_Utility.formatNumbers(Outputs[0].amount / 160) + " L/s",
+                StatCollector.translateToLocal("value.extreme_heat_exchanger.2"),
+                GT_Utility.formatNumbers(Outputs[1].amount / 160) + " L/s",
+                StatCollector.translateToLocal("value.extreme_heat_exchanger.4") + " " + threshold + " L/s");
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerRecipe.java b/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerRecipe.java
new file mode 100644
index 0000000000..4a32e882f8
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/api/recipe/ExtremeHeatExchangerRecipe.java
@@ -0,0 +1,66 @@
+package goodgenerator.api.recipe;
+
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.util.GT_Recipe;
+
+public class ExtremeHeatExchangerRecipe extends GT_Recipe {
+
+    public ExtremeHeatExchangerRecipe(FluidStack[] input, FluidStack[] output, int special) {
+        super(false, null, null, null, null, input, output, 0, 0, special);
+    }
+
+    public int getMaxHotFluidConsume() {
+        if (this.mFluidInputs != null) {
+            return this.mFluidInputs[0].amount;
+        }
+        return 0;
+    }
+
+    public Fluid getNormalSteam() {
+        if (this.mFluidOutputs != null) {
+            return this.mFluidOutputs[0].getFluid();
+        }
+        return null;
+    }
+
+    public Fluid getHeatedSteam() {
+        if (this.mFluidOutputs != null) {
+            return this.mFluidOutputs[1].getFluid();
+        }
+        return null;
+    }
+
+    public Fluid getCooledFluid() {
+        if (this.mFluidOutputs != null) {
+            return this.mFluidOutputs[2].getFluid();
+        }
+        return null;
+    }
+
+    public int getEUt() {
+        if (getNormalSteam() != null) {
+            switch (getNormalSteam().getName()) {
+                case "steam": {
+                    int tVal = this.mFluidInputs[1].amount * 4;
+                    if (tVal < 0) tVal = -tVal;
+                    return tVal;
+                }
+                case "ic2superheatedsteam": {
+                    int tVal = this.mFluidInputs[1].amount * 8;
+                    if (tVal < 0) tVal = -tVal;
+                    return tVal;
+                }
+                case "supercriticalsteam": {
+                    int tVal = this.mFluidInputs[1].amount * 800;
+                    if (tVal < 0) tVal = -tVal;
+                    return tVal;
+                }
+                default:
+                    return 0;
+            }
+        }
+        return 0;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/api/recipe/GoodGeneratorRecipeMaps.java b/goodgen/src/main/java/goodgenerator/api/recipe/GoodGeneratorRecipeMaps.java
new file mode 100644
index 0000000000..85e4ebca1d
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/api/recipe/GoodGeneratorRecipeMaps.java
@@ -0,0 +1,78 @@
+package goodgenerator.api.recipe;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+
+import net.minecraft.util.StatCollector;
+
+import goodgenerator.client.GUI.GG_UITextures;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBuilder;
+import gregtech.api.util.GT_Utility;
+import gregtech.nei.formatter.SimpleSpecialValueFormatter;
+
+public class GoodGeneratorRecipeMaps {
+
+    public static final RecipeMap<RecipeMapBackend> naquadahReactorFuels = RecipeMapBuilder
+        .of("gg.recipe.naquadah_reactor")
+        .maxIO(0, 0, 1, 1)
+        .minInputs(0, 1)
+        .neiSpecialInfoFormatter(new SimpleSpecialValueFormatter("value.naquadah_reactor"))
+        .neiRecipeComparator(Comparator.comparing(recipe -> recipe.mSpecialValue))
+        .dontUseProgressBar()
+        .addSpecialTexture(59, 20, 58, 42, GG_UITextures.PICTURE_NAQUADAH_REACTOR)
+        .build();
+    public static final RecipeMap<RecipeMapBackend> naquadahFuelRefineFactoryRecipes = RecipeMapBuilder
+        .of("gg.recipe.naquadah_fuel_refine_factory")
+        .maxIO(6, 0, 2, 1)
+        .minInputs(0, 1)
+        .neiSpecialInfoFormatter(new SimpleSpecialValueFormatter("value.naquadah_fuel_refine_factory"))
+        .build();
+    public static final RecipeMap<?> neutronActivatorRecipes = RecipeMapBuilder.of("gg.recipe.neutron_activator")
+        .maxIO(9, 9, 1, 1)
+        .dontUseProgressBar()
+        .addSpecialTexture(73, 22, 31, 21, GG_UITextures.PICTURE_NEUTRON_ACTIVATOR)
+        .neiSpecialInfoFormatter(recipeInfo -> {
+            int minNKE = recipeInfo.recipe.mSpecialValue % 10000;
+            int maxNKE = recipeInfo.recipe.mSpecialValue / 10000;
+            return Arrays.asList(
+                StatCollector.translateToLocal("value.neutron_activator.0"),
+                GT_Utility.formatNumbers(minNKE) + StatCollector.translateToLocal("value.neutron_activator.2"),
+                StatCollector.translateToLocal("value.neutron_activator.1"),
+                GT_Utility.formatNumbers(maxNKE) + StatCollector.translateToLocal("value.neutron_activator.2"));
+        })
+        .build();
+    public static final RecipeMap<ExtremeHeatExchangerBackend> extremeHeatExchangerFuels = RecipeMapBuilder
+        .of("gg.recipe.extreme_heat_exchanger", ExtremeHeatExchangerBackend::new)
+        .maxIO(0, 0, 2, 3)
+        .dontUseProgressBar()
+        .addSpecialTexture(47, 13, 78, 59, GG_UITextures.PICTURE_EXTREME_HEAT_EXCHANGER)
+        .frontend(ExtremeHeatExchangerFrontend::new)
+        .build();
+    public static final RecipeMap<RecipeMapBackend> preciseAssemblerRecipes = RecipeMapBuilder
+        .of("gg.recipe.precise_assembler")
+        .maxIO(4, 1, 4, 0)
+        .progressBar(GT_UITextures.PROGRESSBAR_ARROW_MULTIPLE)
+        .progressBarPos(85, 30)
+        .neiTransferRect(80, 30, 35, 18)
+        .neiSpecialInfoFormatter(new SimpleSpecialValueFormatter("value.precise_assembler"))
+        .frontend(PreciseAssemblerFrontend::new)
+        .build();
+    public static final RecipeMap<RecipeMapBackend> componentAssemblyLineRecipes = RecipeMapBuilder
+        .of("gg.recipe.componentassemblyline")
+        .maxIO(12, 1, 12, 0)
+        .neiTransferRect(70, 15, 18, 54)
+        .neiSpecialInfoFormatter(
+            recipeInfo -> Collections.singletonList(
+                StatCollector.translateToLocalFormatted(
+                    "value.component_assembly_line",
+                    GT_Values.VN[recipeInfo.recipe.mSpecialValue])))
+        .dontUseProgressBar()
+        .addSpecialTexture(70, 11, 72, 40, GG_UITextures.PICTURE_COMPONENT_ASSLINE)
+        .frontend(ComponentAssemblyLineFrontend::new)
+        .build();
+}
diff --git a/goodgen/src/main/java/goodgenerator/api/recipe/PreciseAssemblerFrontend.java b/goodgen/src/main/java/goodgenerator/api/recipe/PreciseAssemblerFrontend.java
new file mode 100644
index 0000000000..2f4f0e308b
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/api/recipe/PreciseAssemblerFrontend.java
@@ -0,0 +1,39 @@
+package goodgenerator.api.recipe;
+
+import java.util.Collections;
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.common.gui.modularui.UIHelper;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class PreciseAssemblerFrontend extends RecipeMapFrontend {
+
+    public PreciseAssemblerFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder);
+    }
+
+    @Override
+    public List<Pos2d> getItemInputPositions(int itemInputCount) {
+        return UIHelper.getGridPositions(itemInputCount, 8, 13, itemInputCount);
+    }
+
+    @Override
+    public List<Pos2d> getItemOutputPositions(int itemOutputCount) {
+        return Collections.singletonList(new Pos2d(115, 30));
+    }
+
+    @Override
+    public List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+        return UIHelper.getGridPositions(fluidInputCount, 8, 48, fluidInputCount);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java b/goodgen/src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java
new file mode 100644
index 0000000000..47f73b186b
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java
@@ -0,0 +1,54 @@
+package goodgenerator.blocks.myFluids;
+
+import static goodgenerator.main.GoodGenerator.MOD_ID;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.fluids.BlockFluidClassic;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BaseFluid extends BlockFluidClassic {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon stillIcon;
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon flowingIcon;
+
+    private String stillTexture;
+    private String flowingTexture;
+
+    public BaseFluid(Fluid fluid, Material material) {
+        super(fluid, material);
+    }
+
+    public void SetTexture(String fluidName) {
+        stillTexture = MOD_ID + ":fluids/" + fluidName + ".still";
+        flowingTexture = MOD_ID + ":fluids/" + fluidName + ".flowing";
+    }
+
+    public static Fluid BuildFluid(String fluidName) {
+        Fluid tFluid = new Fluid(fluidName);
+        FluidRegistry.registerFluid(tFluid);
+        return tFluid;
+    }
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        stillIcon = register.registerIcon(stillTexture);
+        flowingIcon = register.registerIcon(flowingTexture);
+
+        super.getFluid().setIcons(stillIcon, flowingIcon);
+    }
+
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return (side == 0 || side == 1) ? stillIcon : flowingIcon;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java b/goodgen/src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java
new file mode 100644
index 0000000000..de8cca2b43
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java
@@ -0,0 +1,203 @@
+package goodgenerator.blocks.myFluids;
+
+import net.minecraft.block.material.Material;
+import net.minecraftforge.fluids.Fluid;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import goodgenerator.crossmod.nei.NEI_Config;
+
+public class FluidsBuilder {
+
+    public FluidsBuilder() {}
+
+    public static void Register() {
+        crackedNaquadahGas_Lightly();
+        crackedNaquadahGas_Moderately();
+        crackedNaquadahGas_Heavily();
+        crackedLightNaquadahFuel_Lightly();
+        crackedLightNaquadahFuel_Moderately();
+        crackedLightNaquadahFuel_Heavily();
+        crackedHeavyNaquadahFuel_Lightly();
+        crackedHeavyNaquadahFuel_Moderately();
+        crackedHeavyNaquadahFuel_Heavily();
+        crackedNaquadahAsphalt_Lightly();
+        crackedNaquadahAsphalt_Moderately();
+        crackedNaquadahAsphalt_Heavily();
+        combustionPromotor();
+        coalTar();
+        supercriticalSteam();
+    }
+
+    public static void crackedNaquadahGas_Lightly() {
+        Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedNaquadahGas");
+        tmp.setGaseous(true)
+            .setTemperature(800);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("lightlyCrackedNaquadahGas");
+        tmp2.setBlockName("lightlyCrackedNaquadahGas");
+        GameRegistry.registerBlock(tmp2, "lightlyCrackedNaquadahGas");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedNaquadahGas_Moderately() {
+        Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedNaquadahGas");
+        tmp.setGaseous(true)
+            .setTemperature(800);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("moderatelyCrackedNaquadahGas");
+        tmp2.setBlockName("moderatelyCrackedNaquadahGas");
+        GameRegistry.registerBlock(tmp2, "moderatelyCrackedNaquadahGas");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedNaquadahGas_Heavily() {
+        Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedNaquadahGas");
+        tmp.setGaseous(true)
+            .setTemperature(800);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("heavilyCrackedNaquadahGas");
+        tmp2.setBlockName("heavilyCrackedNaquadahGas");
+        GameRegistry.registerBlock(tmp2, "heavilyCrackedNaquadahGas");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedLightNaquadahFuel_Lightly() {
+        Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedLightNaquadahFuel");
+        tmp.setGaseous(false)
+            .setTemperature(1200);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("lightlyCrackedLightNaquadahFuel");
+        tmp2.setBlockName("lightlyCrackedLightNaquadahFuel");
+        GameRegistry.registerBlock(tmp2, "lightlyCrackedLightNaquadahFuel");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedLightNaquadahFuel_Moderately() {
+        Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedLightNaquadahFuel");
+        tmp.setGaseous(false)
+            .setTemperature(1200);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("moderatelyCrackedLightNaquadahFuel");
+        tmp2.setBlockName("moderatelyCrackedLightNaquadahFuel");
+        GameRegistry.registerBlock(tmp2, "moderatelyCrackedLightNaquadahFuel");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedLightNaquadahFuel_Heavily() {
+        Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedLightNaquadahFuel");
+        tmp.setGaseous(false)
+            .setTemperature(1200);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("heavilyCrackedLightNaquadahFuel");
+        tmp2.setBlockName("heavilyCrackedLightNaquadahFuel");
+        GameRegistry.registerBlock(tmp2, "heavilyCrackedLightNaquadahFuel");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedHeavyNaquadahFuel_Lightly() {
+        Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedHeavyNaquadahFuel");
+        tmp.setGaseous(false)
+            .setTemperature(1200);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("lightlyCrackedHeavyNaquadahFuel");
+        tmp2.setBlockName("lightlyCrackedHeavyNaquadahFuel");
+        GameRegistry.registerBlock(tmp2, "lightlyCrackedHeavyNaquadahFuel");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedHeavyNaquadahFuel_Moderately() {
+        Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedHeavyNaquadahFuel");
+        tmp.setGaseous(false)
+            .setTemperature(1200);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("moderatelyCrackedHeavyNaquadahFuel");
+        tmp2.setBlockName("moderatelyCrackedHeavyNaquadahFuel");
+        GameRegistry.registerBlock(tmp2, "moderatelyCrackedHeavyNaquadahFuel");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedHeavyNaquadahFuel_Heavily() {
+        Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedHeavyNaquadahFuel");
+        tmp.setGaseous(false)
+            .setTemperature(1200);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("heavilyCrackedHeavyNaquadahFuel");
+        tmp2.setBlockName("heavilyCrackedHeavyNaquadahFuel");
+        GameRegistry.registerBlock(tmp2, "heavilyCrackedHeavyNaquadahFuel");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedNaquadahAsphalt_Lightly() {
+        Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedNaquadahAsphalt");
+        tmp.setGaseous(false)
+            .setTemperature(1800)
+            .setDensity(20000)
+            .setViscosity(20000);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("lightlyCrackedNaquadahAsphalt");
+        tmp2.setBlockName("lightlyCrackedNaquadahAsphalt");
+        GameRegistry.registerBlock(tmp2, "lightlyCrackedNaquadahAsphalt");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedNaquadahAsphalt_Moderately() {
+        Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedNaquadahAsphalt");
+        tmp.setGaseous(false)
+            .setTemperature(1800)
+            .setDensity(20000)
+            .setViscosity(20000);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("moderatelyCrackedNaquadahAsphalt");
+        tmp2.setBlockName("moderatelyCrackedNaquadahAsphalt");
+        GameRegistry.registerBlock(tmp2, "moderatelyCrackedNaquadahAsphalt");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void crackedNaquadahAsphalt_Heavily() {
+        Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedNaquadahAsphalt");
+        tmp.setGaseous(false)
+            .setTemperature(1800)
+            .setDensity(20000)
+            .setViscosity(20000);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("heavilyCrackedNaquadahAsphalt");
+        tmp2.setBlockName("heavilyCrackedNaquadahAsphalt");
+        GameRegistry.registerBlock(tmp2, "heavilyCrackedNaquadahAsphalt");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void combustionPromotor() {
+        Fluid tmp = BaseFluid.BuildFluid("combustionPromotor");
+        tmp.setGaseous(false)
+            .setTemperature(300);
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("combustionPromotor");
+        tmp2.setBlockName("combustionPromotor");
+        GameRegistry.registerBlock(tmp2, "combustionPromotor");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void coalTar() {
+        Fluid tmp = BaseFluid.BuildFluid("fluid.coalTar");
+        tmp.setGaseous(false)
+            .setTemperature(450)
+            .setUnlocalizedName("fluid.coalTar");
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("coalTar");
+        tmp2.setBlockTextureName("coalTar");
+        GameRegistry.registerBlock(tmp2, "coalTar");
+        NEI_Config.hide(tmp2);
+    }
+
+    public static void supercriticalSteam() {
+        Fluid tmp = BaseFluid.BuildFluid("supercriticalSteam");
+        tmp.setGaseous(true)
+            .setTemperature(648)
+            .setUnlocalizedName("supercriticalSteam");
+        BaseFluid tmp2 = new BaseFluid(tmp, Material.water);
+        tmp2.SetTexture("supercriticalSteam");
+        tmp2.setBlockTextureName("supercriticalSteam");
+        GameRegistry.registerBlock(tmp2, "supercriticalSteam");
+        NEI_Config.hide(tmp2);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/regularBlock/Casing.java b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/Casing.java
new file mode 100644
index 0000000000..9e01d783d2
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/Casing.java
@@ -0,0 +1,124 @@
+package goodgenerator.blocks.regularBlock;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.main.GoodGenerator;
+import gregtech.api.GregTech_API;
+
+public class Casing extends Block {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon[] texture;
+
+    String[] textureNames;
+    protected String name;
+
+    public Casing(String name) {
+        super(Material.iron);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.setHarvestLevel("wrench", 2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public Casing(String name, String[] texture) {
+        super(Material.iron);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench", 2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public Casing(String name, String[] texture, Material material) {
+        super(material);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench", 2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int meta) {
+        return meta < this.texture.length ? this.texture[meta] : this.texture[0];
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister par1IconRegister) {
+        this.texture = new IIcon[this.textureNames.length];
+        for (int i = 0; i < this.textureNames.length; i++) {
+            this.texture[i] = par1IconRegister.registerIcon(this.textureNames[i]);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+        for (int i = 0; i < this.textureNames.length; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
+
+    @Override
+    public void onBlockAdded(World aWorld, int aX, int aY, int aZ) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+    }
+
+    @Override
+    public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+    }
+
+    @Override
+    public String getUnlocalizedName() {
+        return this.name;
+    }
+
+    @Override
+    public boolean canBeReplacedByLeaves(IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public boolean canEntityDestroy(IBlockAccess world, int x, int y, int z, Entity entity) {
+        return false;
+    }
+
+    @Override
+    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java
new file mode 100644
index 0000000000..0a0169d0b4
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java
@@ -0,0 +1,58 @@
+package goodgenerator.blocks.regularBlock;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ComplexTextureCasing extends Casing {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon[] texture1, texture2;
+    String[] textureSide;
+    String[] textureTopAndDown;
+
+    public ComplexTextureCasing(String name, String[] textureSide, String[] textureTopAndDown) {
+        super(name);
+        this.textureSide = textureSide;
+        this.textureTopAndDown = textureTopAndDown;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int meta) {
+        if (side < 2) {
+            return meta < this.texture2.length ? this.texture2[meta] : this.texture2[0];
+        } else {
+            return meta < this.texture1.length ? this.texture1[meta] : this.texture1[0];
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister par1IconRegister) {
+        this.texture1 = new IIcon[this.textureSide.length];
+        for (int i = 0; i < this.textureSide.length; i++) {
+            this.texture1[i] = par1IconRegister.registerIcon(this.textureSide[i]);
+        }
+        this.texture2 = new IIcon[this.textureTopAndDown.length];
+        for (int i = 0; i < this.textureTopAndDown.length; i++) {
+            this.texture2[i] = par1IconRegister.registerIcon(this.textureTopAndDown[i]);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+        for (int i = 0; i < Math.max(this.textureSide.length, this.textureTopAndDown.length); i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/regularBlock/Frame.java b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/Frame.java
new file mode 100644
index 0000000000..b4acb03518
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/Frame.java
@@ -0,0 +1,37 @@
+package goodgenerator.blocks.regularBlock;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.world.IBlockAccess;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class Frame extends Casing {
+
+    public Frame(String name, String[] texture) {
+        super(name, texture, Material.iron);
+    }
+
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean shouldSideBeRendered(IBlockAccess worldClient, int xCoord, int yCoord, int zCoord, int aSide) {
+        if (worldClient.getBlock(xCoord, yCoord, zCoord) instanceof Frame) return false;
+        return super.shouldSideBeRendered(worldClient, xCoord, yCoord, zCoord, aSide);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getRenderBlockPass() {
+        return 1;
+    }
+
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java
new file mode 100644
index 0000000000..fae196a64b
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java
@@ -0,0 +1,18 @@
+package goodgenerator.blocks.regularBlock;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+
+public interface ITextureBlock {
+
+    default ITexture[] getTexture(Block aBlock, ForgeDirection side) {
+        return getTexture(aBlock, 0, side);
+    }
+
+    ITexture[] getTexture(Block aBlock, ForgeDirection side, IBlockAccess aWorld, int xCoord, int yCoord, int zCoord);
+
+    ITexture[] getTexture(Block aBlock, int aMeta, ForgeDirection side);
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java
new file mode 100644
index 0000000000..6c13a9c680
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java
@@ -0,0 +1,207 @@
+package goodgenerator.blocks.regularBlock;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.blocks.tileEntity.EssentiaHatch;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch_ME;
+import goodgenerator.main.GoodGenerator;
+import gregtech.api.GregTech_API;
+import gregtech.api.util.GT_Utility;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.IEssentiaContainerItem;
+
+public class TEBlock extends BlockContainer {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon[] texture;
+
+    String[] textureNames;
+    protected String name;
+    protected int index;
+
+    public TEBlock(String name, String[] texture, CreativeTabs Tab) {
+        super(Material.iron);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench", 2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public TEBlock(String name, String[] texture, int index) {
+        super(Material.iron);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench", 2);
+        this.index = index;
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public TEBlock(String name, String[] texture, Material material) {
+        super(material);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench", 2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public int getIndex() {
+        return this.index;
+    }
+
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int meta) {
+        return meta < this.texture.length ? this.texture[meta] : this.texture[0];
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister par1IconRegister) {
+        this.texture = new IIcon[this.textureNames.length];
+        for (int i = 0; i < this.textureNames.length; i++) {
+            this.texture[i] = par1IconRegister.registerIcon(this.textureNames[i]);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+        for (int i = 0; i < this.textureNames.length; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
+
+    @Override
+    public void onBlockAdded(World aWorld, int aX, int aY, int aZ) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+    }
+
+    @Override
+    public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+        aWorld.removeTileEntity(aX, aY, aZ);
+    }
+
+    @Override
+    public String getUnlocalizedName() {
+        return this.name;
+    }
+
+    @Override
+    public boolean canBeReplacedByLeaves(IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public boolean canEntityDestroy(IBlockAccess world, int x, int y, int z, Entity entity) {
+        return false;
+    }
+
+    @Override
+    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public TileEntity createTileEntity(World world, int meta) {
+        switch (index) {
+            case 1:
+                return new EssentiaHatch();
+            case 2:
+                return new EssentiaOutputHatch();
+            case 3:
+                return new EssentiaOutputHatch_ME();
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7,
+        float par8, float par9) {
+        if (world.isRemote) {
+            return false;
+        } else {
+            TileEntity tile = world.getTileEntity(x, y, z);
+            if (index == 1) {
+                if (tile instanceof EssentiaHatch) {
+                    ItemStack tItemStack = player.getHeldItem();
+                    if (tItemStack != null) {
+                        Item tItem = tItemStack.getItem();
+                        if (tItem instanceof IEssentiaContainerItem
+                            && ((IEssentiaContainerItem) tItem).getAspects(player.getHeldItem()) != null
+                            && ((IEssentiaContainerItem) tItem).getAspects(player.getHeldItem())
+                                .size() > 0) {
+                            Aspect tLocked = ((IEssentiaContainerItem) tItem).getAspects(player.getHeldItem())
+                                .getAspects()[0];
+                            ((EssentiaHatch) tile).setLockedAspect(tLocked);
+                            GT_Utility.sendChatToPlayer(
+                                player,
+                                String.format(
+                                    StatCollector.translateToLocal("essentiahatch.chat.0"),
+                                    tLocked.getLocalizedDescription()));
+                        }
+                    } else {
+                        ((EssentiaHatch) tile).setLockedAspect(null);
+                        GT_Utility.sendChatToPlayer(player, StatCollector.translateToLocal("essentiahatch.chat.1"));
+                    }
+                    world.markBlockForUpdate(x, y, z);
+                    return true;
+                } else return false;
+            } else if (index == 2) {
+                if (tile instanceof EssentiaOutputHatch && player.isSneaking()) {
+                    ItemStack tItemStack = player.getHeldItem();
+                    if (tItemStack == null) {
+                        ((EssentiaOutputHatch) tile).clear();
+                        GT_Utility
+                            .sendChatToPlayer(player, StatCollector.translateToLocal("essentiaoutputhatch.chat.0"));
+                    }
+                    return true;
+                } else return false;
+            } else return false;
+        }
+    }
+
+    @Override
+    public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) {
+        return null;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java
new file mode 100644
index 0000000000..986ab4e0c8
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java
@@ -0,0 +1,103 @@
+package goodgenerator.blocks.regularBlock;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_LargeTurbineBase;
+import goodgenerator.client.render.BlockRenderHandler;
+import goodgenerator.main.GoodGenerator;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.render.TextureFactory;
+
+public class TurbineCasing extends Casing implements ITextureBlock {
+
+    public static IIconContainer[][] turbineShape = new IIconContainer[3][9];
+    public IIconContainer base;
+
+    static {
+        for (int i = 0; i < 3; i++) for (int j = 1; j <= 9; j++)
+            turbineShape[i][j - 1] = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_" + i + "" + j);
+    }
+
+    public TurbineCasing(String name, String texture) {
+        super(name, new String[] { GoodGenerator.MOD_ID + ":" + texture });
+        base = new Textures.BlockIcons.CustomIcon("icons/" + texture);
+    }
+
+    private static int isTurbineControllerWithSide(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection side) {
+        TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+        if (!(tTileEntity instanceof IGregTechTileEntity)) return 0;
+        IGregTechTileEntity tTile = (IGregTechTileEntity) tTileEntity;
+        if (tTile.getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase && tTile.getFrontFacing() == side) {
+            if (tTile.isActive()) return 1;
+            return ((GT_MetaTileEntity_LargeTurbineBase) tTile.getMetaTileEntity()).hasTurbine() ? 2 : 3;
+        }
+        return 0;
+    }
+
+    public ITexture[] getTurbineCasing(int iconIndex, boolean active, boolean hasTurbine) {
+        int states = active ? 0 : hasTurbine ? 1 : 2;
+        return new ITexture[] { TextureFactory.of(base), TextureFactory.of(turbineShape[states][iconIndex]) };
+    }
+
+    @Override
+    public ITexture[] getTexture(Block aBlock, ForgeDirection side, IBlockAccess aWorld, int xCoord, int yCoord,
+        int zCoord) {
+        final int ordinalSide = side.ordinal();
+        int tInvertLeftRightMod = ordinalSide % 2 * 2 - 1;
+        switch (ordinalSide / 2) {
+            case 0:
+                for (int i = -1; i < 2; i++) {
+                    for (int j = -1; j < 2; j++) {
+                        if (i == 0 && j == 0) continue;
+                        int tState;
+                        if ((tState = isTurbineControllerWithSide(aWorld, xCoord + j, yCoord, zCoord + i, side)) != 0) {
+                            return getTurbineCasing(4 - i * 3 - j, tState == 1, tState == 2);
+                        }
+                    }
+                }
+                break;
+            case 1:
+                for (int i = -1; i < 2; i++) {
+                    for (int j = -1; j < 2; j++) {
+                        if (i == 0 && j == 0) continue;
+                        int tState;
+                        if ((tState = isTurbineControllerWithSide(aWorld, xCoord + j, yCoord + i, zCoord, side)) != 0) {
+                            return getTurbineCasing(4 + i * 3 - j * tInvertLeftRightMod, tState == 1, tState == 2);
+                        }
+                    }
+                }
+                break;
+            case 2:
+                for (int i = -1; i < 2; i++) {
+                    for (int j = -1; j < 2; j++) {
+                        if (i == 0 && j == 0) continue;
+                        int tState;
+                        if ((tState = isTurbineControllerWithSide(aWorld, xCoord, yCoord + i, zCoord + j, side)) != 0) {
+                            return getTurbineCasing(4 + i * 3 + j * tInvertLeftRightMod, tState == 1, tState == 2);
+                        }
+                    }
+                }
+                break;
+        }
+        return getTexture(aBlock, side);
+    }
+
+    @Override
+    public ITexture[] getTexture(Block aBlock, int aMeta, ForgeDirection side) {
+        return new ITexture[] { TextureFactory.of(base) };
+    }
+
+    @Override
+    public int getRenderType() {
+        if (BlockRenderHandler.INSTANCE == null) {
+            return super.getRenderType();
+        }
+        return BlockRenderHandler.INSTANCE.mRenderID;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java
new file mode 100644
index 0000000000..618477d09c
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java
@@ -0,0 +1,403 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.GT_HatchElement.*;
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+import goodgenerator.loader.Loaders;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_StructureUtility;
+import gregtech.api.util.GT_Utility;
+
+public class ComponentAssemblyLine extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<ComponentAssemblyLine>
+    implements ISurvivalConstructable {
+
+    private int casingTier;
+    protected static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final IStructureDefinition<ComponentAssemblyLine> STRUCTURE_DEFINITION = StructureDefinition
+        .<ComponentAssemblyLine>builder()
+        .addShape(
+            STRUCTURE_PIECE_MAIN,
+            new String[][] {
+                { "         ", "   III   ", " HHI~IHH ", "HH III HH", "H       H", "H       H", "H  JJJ  H",
+                    "H  JJJ  H", "H  N N  H", "HHHHHHHHH" },
+                { "         ", " ELHHHLE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "AG  C  GA", "AG     GA", "AG     GA",
+                    "AG HHH GA", "AG     GA", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "HG  C  GH", "HG     GH", "HG     GH",
+                    "HG HHH GH", "HG     GH", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "AG  C  GA", "AG     GA", "AG     GA",
+                    "AG HHH GA", "AG     GA", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "HG  C  GH", "HG     GH", "HG     GH",
+                    "HG HHH GH", "HG     GH", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "AG  C  GA", "AG     GA", "AG     GA",
+                    "AG HHH GA", "AG     GA", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "HG  C  GH", "HG     GH", "HG     GH",
+                    "HG HHH GH", "HG     GH", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "   BBB   ", " EL   LE ", "E GGDGG E", "HGG D GGH", "AG  C  GA", "AG     GA", "AG     GA",
+                    "AG HHH GA", "AG     GA", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A  n n  A", "MHHHHHHHM" },
+                { "   HBH   ", " EL   LE ", "E       E", "HC     CH", "AC     CA", "AC     CA", "A D   D A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "         ", " ELHHHLE ", "E       E", "H       H", "A       A", "A       A", "A       A",
+                    "A  HHH  A", "A       A", "MHHHHHHHM" },
+                { "         ", "         ", " HHHHHHH ", "HH     HH", "H       H", "H       H", "H       H",
+                    "H       H", "H  KKK  H", "HHHHHHHHH" } })
+        .addElement(
+            'A',
+            ofChain(
+                ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 5),
+                ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 13),
+                ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 14),
+                ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 15),
+                ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks2", 0)))
+        .addElement('H', ofBlock(GregTech_API.sBlockCasings8, 7))
+        .addElement('C', ofBlock(GregTech_API.sBlockCasings2, 5))
+        .addElement('D', ofBlock(GregTech_API.sBlockCasings2, 9))
+        .addElement('G', ofBlock(GregTech_API.sBlockCasings9, 0))
+        .addElement('E', ofBlock(GregTech_API.sBlockCasings9, 1))
+        .addElement('F', ofBlock(GregTech_API.sBlockCasings4, 1))
+        .addElement(
+            'B',
+            ofBlocksTiered(
+                (block, meta) -> block == Loaders.componentAssemblylineCasing ? meta : -1,
+                IntStream.range(0, 14)
+                    .mapToObj(i -> Pair.of(Loaders.componentAssemblylineCasing, i))
+                    .collect(Collectors.toList()),
+                -2,
+                (t, meta) -> t.casingTier = meta,
+                t -> t.casingTier))
+        .addElement(
+            'J',
+            GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class)
+                .atLeast(InputBus)
+                .dot(1)
+                .casingIndex(183)
+                .buildAndChain(GregTech_API.sBlockCasings8, 7))
+        .addElement(
+            'N',
+            GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class)
+                .atLeast(InputBus)
+                .dot(1)
+                .casingIndex(183)
+                .buildAndChain(GT_StructureUtility.ofFrame(Materials.TungstenSteel)))
+        .addElement(
+            'K',
+            GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class)
+                .atLeast(OutputBus)
+                .dot(2)
+                .casingIndex(183)
+                .buildAndChain(GregTech_API.sBlockCasings8, 7))
+        .addElement(
+            'L',
+            GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class)
+                .atLeast(Energy, ExoticEnergy)
+                .dot(3)
+                .casingIndex(183)
+                .buildAndChain(GregTech_API.sBlockCasings8, 7))
+        .addElement(
+            'I',
+            GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class)
+                .atLeast(Maintenance)
+                .dot(4)
+                .casingIndex(183)
+                .buildAndChain(GregTech_API.sBlockCasings8, 7))
+        .addElement(
+            'M',
+            GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class)
+                .atLeast(InputHatch)
+                .dot(5)
+                .casingIndex(183)
+                .buildAndChain(GregTech_API.sBlockCasings8, 7))
+        .addElement('n', GT_StructureUtility.ofFrame(Materials.TungstenSteel))
+        .build();
+
+    public ComponentAssemblyLine(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public ComponentAssemblyLine(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 4, 2, 0);
+    }
+
+    @Override
+    public IStructureDefinition<ComponentAssemblyLine> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("High-Capacity Component Assembler")
+            .addInfo("Controller block for the Component Assembly Line.")
+            .addInfo("Assembles basic components (motors, pumps, etc.) in large batches.")
+            .addInfo(
+                "The " + EnumChatFormatting.BOLD
+                    + EnumChatFormatting.YELLOW
+                    + "Component Assembly Line Casing "
+                    + EnumChatFormatting.RESET
+                    + EnumChatFormatting.GRAY
+                    + "limits the recipes the machine can perform. See the NEI pages for details.")
+            .addInfo(
+                "Supports " + EnumChatFormatting.BLUE
+                    + "Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " laser and multi-amp hatches!")
+            .addInfo("Supports overclocking beyond MAX!")
+            .addInfo(EnumChatFormatting.ITALIC + "Much more efficient than other competing brands!")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .beginStructureBlock(9, 10, 33, false)
+            .addStructureInfo("This structure is too complex! See schematic for details.")
+            .addOtherStructurePart("Borosilicate Glass", "Can be UV tier or higher")
+            .addInputBus("Start of conveyor belt", 1)
+            .addOutputBus("End of conveyor belt", 2)
+            .addEnergyHatch("Second-top layer", 3)
+            .addMaintenanceHatch("Around the controller", 4)
+            .addInputHatch("Bottom left and right corners", 5)
+            .toolTipFinisher(
+                EnumChatFormatting.AQUA + "MadMan310"
+                    + EnumChatFormatting.GRAY
+                    + " via "
+                    + EnumChatFormatting.GREEN
+                    + "Good Generator");
+
+        return tt;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new ComponentAssemblyLine(mName);
+    }
+
+    /**
+     * Changes and adds new information to the default info data for the scanner.
+     */
+    @Override
+    public String[] getInfoData() {
+        String[] origin = super.getInfoData();
+        String[] ret = new String[origin.length + 1];
+        System.arraycopy(origin, 0, ret, 0, origin.length);
+        ret[origin.length] = StatCollector.translateToLocal("scanner.info.CASS.tier")
+            + (casingTier >= 0 ? GT_Values.VN[casingTier + 1] : "None!");
+        return ret;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(183),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(183), TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(183) };
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult validateRecipe(@NotNull GT_Recipe recipe) {
+                if (recipe.mSpecialValue > casingTier + 1) {
+                    return CheckRecipeResultRegistry.insufficientMachineTier(recipe.mSpecialValue);
+                }
+                return CheckRecipeResultRegistry.SUCCESSFUL;
+            }
+        };
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        logic.setAvailableVoltage(getMaxInputEu());
+        logic.setAvailableAmperage(1);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        int realBudget = elementBudget >= 200 ? elementBudget : Math.min(200, elementBudget * 5);
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 4, 2, 0, realBudget, env, false, true);
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        casingTier = -2;
+        return checkPiece(STRUCTURE_PIECE_MAIN, 4, 2, 0);
+    }
+
+    @Override
+    public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        inputSeparation = !inputSeparation;
+        GT_Utility.sendChatToPlayer(
+            aPlayer,
+            StatCollector.translateToLocal("GT5U.machines.separatebus") + " " + inputSeparation);
+    }
+
+    @Override
+    public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
+        float aX, float aY, float aZ, ItemStack aTool) {
+        if (aPlayer.isSneaking()) {
+            batchMode = !batchMode;
+            if (batchMode) {
+                GT_Utility.sendChatToPlayer(aPlayer, "Batch recipes.");
+            } else {
+                GT_Utility.sendChatToPlayer(aPlayer, "Don't batch recipes.");
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean supportsInputSeparation() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return GoodGeneratorRecipeMaps.componentAssemblyLineRecipes;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("casingTier", casingTier);
+    }
+
+    @Override
+    public void loadNBTData(final NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        casingTier = aNBT.getInteger("casingTier");
+        if (!aNBT.hasKey(INPUT_SEPARATION_NBT_KEY)) {
+            inputSeparation = aNBT.getBoolean("mSeparate");
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java
new file mode 100644
index 0000000000..ae3395ffb9
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java
@@ -0,0 +1,225 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.util.GT_StructureUtility.*;
+import static gregtech.api.util.GT_Utility.filterValidMTEs;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_MultiInput;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+
+public class CoolantTower extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    protected IStructureDefinition<CoolantTower> multiDefinition = null;
+    private final int CASING_INDEX = 1542;
+
+    public CoolantTower(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public CoolantTower(String name) {
+        super(name);
+    }
+
+    @Override
+    public IStructureDefinition<? extends GT_MetaTileEntity_MultiblockBase_EM> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<CoolantTower>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] {
+                            { "           ", "           ", "    BBB    ", "   B   B   ", "  B     B  ", "  B     B  ",
+                                "  B     B  ", "   B   B   ", "    BBB    ", "           ", "           " },
+                            { "           ", "           ", "    BBB    ", "   BBBBB   ", "  BB   BB  ", "  BB   BB  ",
+                                "  BB   BB  ", "   BBBBB   ", "    BBB    ", "           ", "           " },
+                            { "           ", "           ", "           ", "    BBB    ", "   B   B   ", "   B   B   ",
+                                "   B   B   ", "    BBB    ", "           ", "           ", "           " },
+                            { "           ", "           ", "           ", "    BBB    ", "   B   B   ", "   B   B   ",
+                                "   B   B   ", "    BBB    ", "           ", "           ", "           " },
+                            { "           ", "           ", "           ", "    BBB    ", "   B   B   ", "   B   B   ",
+                                "   B   B   ", "    BBB    ", "           ", "           ", "           " },
+                            { "           ", "           ", "    BBB    ", "   BBBBB   ", "  BB   BB  ", "  BB   BB  ",
+                                "  BB   BB  ", "   BBBBB   ", "    BBB    ", "           ", "           " },
+                            { "           ", "           ", "    BBB    ", "   B   B   ", "  B     B  ", "  B     B  ",
+                                "  B     B  ", "   B   B   ", "    BBB    ", "           ", "           " },
+                            { "           ", "           ", "    BBB    ", "   B   B   ", "  B     B  ", "  B     B  ",
+                                "  B     B  ", "   B   B   ", "    BBB    ", "           ", "           " },
+                            { "           ", "    BBB    ", "   BBBBB   ", "  BB   BB  ", " BB     BB ", " BB     BB ",
+                                " BB     BB ", "  BB   BB  ", "   BBBBB   ", "    BBB    ", "           " },
+                            { "           ", "    BBB    ", "   B   B   ", "  B     B  ", " B       B ", " B       B ",
+                                " B       B ", "  B     B  ", "   B   B   ", "    BBB    ", "           " },
+                            { "           ", "   BBBBB   ", "  BB   BB  ", " BB     BB ", " B       B ", " B       B ",
+                                " B       B ", " BB     BB ", "  BB   BB  ", "   BBBBB   ", "           " },
+                            { "   HH~HH   ", "  HBBBBBH  ", " HB     BH ", "HB       BH", "HB       BH", "HB       BH",
+                                "HB       BH", "HB       BH", " HB     BH ", "  HBBBBBH  ", "   HHHHH   " },
+                            { "   CCCCC   ", "  C     C  ", " C       C ", "C         C", "C         C", "C         C",
+                                "C         C", "C         C", " C       C ", "  C     C  ", "   CCCCC   " }, }))
+                .addElement('B', ofBlockAnyMeta(GregTech_API.sBlockConcretes, 8))
+                .addElement('C', ofFrame(Materials.TungstenCarbide))
+                .addElement(
+                    'H',
+                    buildHatchAdder(CoolantTower.class).atLeast(GT_HatchElement.InputHatch, GT_HatchElement.OutputHatch)
+                        .casingIndex(CASING_INDEX)
+                        .dot(1)
+                        .buildAndChain(ofBlockAnyMeta(GregTech_API.sBlockConcretes, 8)))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        mWrench = true;
+        mScrewdriver = true;
+        mSoftHammer = true;
+        mHardHammer = true;
+        mSolderingTool = true;
+        mCrowbar = true;
+        return structureCheck_EM(mName, 5, 11, 0);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Coolant Tower")
+            .addInfo("Controller block for the Coolant Tower.")
+            .addInfo("Turn Steam back to Distilled Water.")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addController("Mid of the second layer.")
+            .addInputHatch("Input Hatch", 1)
+            .addOutputHatch("Output Hatch", 1)
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        structureBuild_EM(mName, 5, 11, 0, stackSize, hintsOnly);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("CoolantTower.hint", 3);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new CoolantTower(mName);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        if (aTick % 72000 == 0) {
+            mWrench = true;
+            mScrewdriver = true;
+            mSoftHammer = true;
+            mHardHammer = true;
+            mSolderingTool = true;
+            mCrowbar = true;
+        }
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    protected @NotNull CheckRecipeResult checkProcessing_EM() {
+        this.mMaxProgresstime = 20;
+        int steam = 0;
+
+        for (GT_MetaTileEntity_Hatch_Input tHatch : filterValidMTEs(mInputHatches)) {
+            steam += maybeDrainHatch(tHatch);
+        }
+        addOutput(GT_ModHandler.getDistilledWater(steam / 160));
+        return CheckRecipeResultRegistry.SUCCESSFUL;
+    }
+
+    private int maybeDrainHatch(GT_MetaTileEntity_Hatch_Input tHatch) {
+        if (tHatch instanceof GT_MetaTileEntity_Hatch_MultiInput) {
+            int drained = 0;
+            for (FluidStack maybeSteam : ((GT_MetaTileEntity_Hatch_MultiInput) tHatch).getStoredFluid()) {
+                drained += maybeDrainSteam(tHatch, maybeSteam);
+            }
+            return drained;
+        }
+        return maybeDrainSteam(tHatch, tHatch.getFillableStack());
+    }
+
+    private int maybeDrainSteam(GT_MetaTileEntity_Hatch_Input tHatch, FluidStack maybeSteam) {
+        if (maybeSteam == null) return 0;
+        if (!GT_Utility.areFluidsEqual(maybeSteam, GT_ModHandler.getSteam(1))) return 0;
+        FluidStack defoSteam = tHatch.drain(ForgeDirection.UNKNOWN, maybeSteam, true);
+        return defoSteam.amount;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { casingTexturePages[12][6], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { casingTexturePages[12][6], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { casingTexturePages[12][6] };
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 5, 11, 0, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java
new file mode 100644
index 0000000000..f9eab80f03
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java
@@ -0,0 +1,244 @@
+package goodgenerator.blocks.tileEntity;
+
+import java.util.ArrayList;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.aspects.IAspectContainer;
+import thaumcraft.api.aspects.IEssentiaTransport;
+
+public class EssentiaHatch extends TileEntity implements IAspectContainer, IEssentiaTransport {
+
+    private Aspect mLocked;
+    private AspectList current = new AspectList();
+    public int mState = 0;
+
+    public void setLockedAspect(Aspect aAspect) {
+        this.mLocked = aAspect;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+
+        this.mLocked = Aspect.getAspect(tagCompound.getString("mLocked"));
+        this.mState = tagCompound.getInteger("mState");
+        current = new AspectList();
+        NBTTagList tlist = tagCompound.getTagList("Aspects", 10);
+        for (int j = 0; j < tlist.tagCount(); ++j) {
+            NBTTagCompound rs = tlist.getCompoundTagAt(j);
+            if (rs.hasKey("key")) {
+                current.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount"));
+            }
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+
+        tagCompound.setString("mLocked", this.mLocked == null ? "" : this.mLocked.getTag());
+        tagCompound.setInteger("mState", mState);
+        NBTTagList tlist = new NBTTagList();
+        Aspect[] aspectA = current.getAspects();
+        for (Aspect aspect : aspectA) {
+            if (aspect != null) {
+                NBTTagCompound f = new NBTTagCompound();
+                f.setString("key", aspect.getTag());
+                f.setInteger("amount", current.getAmount(aspect));
+                tlist.appendTag(f);
+            }
+        }
+        tagCompound.setTag("Aspects", tlist);
+    }
+
+    public final Packet getDescriptionPacket() {
+        NBTTagCompound nbt = new NBTTagCompound();
+        writeToNBT(nbt);
+        return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, nbt);
+    }
+
+    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
+        NBTTagCompound nbt = pkt.func_148857_g();
+        readFromNBT(nbt);
+    }
+
+    public void markDirty() {
+        super.markDirty();
+        if (this.worldObj.isRemote) {
+            return;
+        }
+        this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
+    }
+
+    @Override
+    public void updateEntity() {
+        fillfrompipe();
+    }
+
+    public void fillfrompipe() {
+        if (getEssentiaAmount(null) >= 1000) return;
+        TileEntity[] te = new TileEntity[ForgeDirection.VALID_DIRECTIONS.length];
+        for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) {
+            te[i] = ThaumcraftApiHelper.getConnectableTile(
+                this.worldObj,
+                this.xCoord,
+                this.yCoord,
+                this.zCoord,
+                ForgeDirection.VALID_DIRECTIONS[i]);
+            if (te[i] != null) {
+                IEssentiaTransport pipe = (IEssentiaTransport) te[i];
+                if (!pipe.canOutputTo(ForgeDirection.VALID_DIRECTIONS[i])) {
+                    continue;
+                }
+                if ((pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i].getOpposite()) != null)
+                    && (pipe.getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i])
+                        < getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]))) {
+                    Aspect readyInput = pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i].getOpposite());
+                    int type = LargeEssentiaEnergyData.getAspectTypeIndex(readyInput);
+                    if (type != -1 && (mState & (1 << type)) == 0) continue;
+                    if (readyInput.equals(mLocked)) {
+                        addToContainer(mLocked, pipe.takeEssentia(mLocked, 1, ForgeDirection.VALID_DIRECTIONS[i]));
+                    }
+                    if (mLocked == null) addToContainer(
+                        pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]),
+                        pipe.takeEssentia(
+                            pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]),
+                            1,
+                            ForgeDirection.VALID_DIRECTIONS[i]));
+                }
+            }
+        }
+    }
+
+    @Override
+    public AspectList getAspects() {
+        return current;
+    }
+
+    @Override
+    public void setAspects(AspectList aspectList) {
+        this.current.add(aspectList);
+    }
+
+    @Override
+    public boolean doesContainerAccept(Aspect aspect) {
+        int type = LargeEssentiaEnergyData.getAspectTypeIndex(aspect);
+        if (type != -1 && (mState & (1 << type)) == 0) return false;
+        return (mLocked == null || mLocked.equals(aspect)) && getEssentiaAmount(null) <= 1000;
+    }
+
+    @Override
+    public int addToContainer(Aspect aspect, int i) {
+        int type = LargeEssentiaEnergyData.getAspectTypeIndex(aspect);
+        if (type != -1 && (mState & (1 << type)) == 0) return i;
+        int ready = Math.min(1000 - getEssentiaAmount(null), i);
+        if ((mLocked == null || mLocked.equals(aspect)) && ready > 0) {
+            current.add(aspect, ready);
+            this.markDirty();
+            return i - ready;
+        }
+        this.markDirty();
+        return i;
+    }
+
+    @Override
+    public boolean takeFromContainer(Aspect aspect, int i) {
+        return false;
+    }
+
+    @Override
+    public boolean takeFromContainer(AspectList aspectList) {
+        return false;
+    }
+
+    @Override
+    public boolean doesContainerContainAmount(Aspect aspect, int i) {
+        return current.aspects.containsKey(aspect) && i <= current.getAmount(aspect);
+    }
+
+    @Override
+    public boolean doesContainerContain(AspectList aspectList) {
+        ArrayList<Boolean> ret = new ArrayList<Boolean>();
+        for (Aspect a : aspectList.aspects.keySet()) ret.add(current.aspects.containsKey(a));
+        return !ret.contains(false);
+    }
+
+    @Override
+    public int containerContains(Aspect aspect) {
+        return current.aspects.containsKey(aspect) ? current.getAmount(aspect) : 0;
+    }
+
+    @Override
+    public boolean isConnectable(ForgeDirection forgeDirection) {
+        return true;
+    }
+
+    @Override
+    public boolean canInputFrom(ForgeDirection forgeDirection) {
+        return true;
+    }
+
+    @Override
+    public boolean canOutputTo(ForgeDirection forgeDirection) {
+        return false;
+    }
+
+    @Override
+    public void setSuction(Aspect aspect, int i) {}
+
+    @Override
+    public Aspect getSuctionType(ForgeDirection forgeDirection) {
+        return this.mLocked;
+    }
+
+    @Override
+    public int getSuctionAmount(ForgeDirection forgeDirection) {
+        return 256;
+    }
+
+    @Override
+    public int takeEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) {
+        return 0;
+    }
+
+    @Override
+    public int addEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) {
+        return i - addToContainer(aspect, i);
+    }
+
+    @Override
+    public Aspect getEssentiaType(ForgeDirection forgeDirection) {
+        if (current == null || current.size() < 1) return null;
+        return current.getAspects()[0];
+    }
+
+    @Override
+    public int getEssentiaAmount(ForgeDirection forgeDirection) {
+        int ret = 0;
+        for (final Aspect A : current.aspects.keySet()) {
+            ret += current.getAmount(A);
+        }
+        return ret;
+    }
+
+    @Override
+    public int getMinimumSuction() {
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public boolean renderExtendedTube() {
+        return true;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch.java
new file mode 100644
index 0000000000..93cec4672c
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch.java
@@ -0,0 +1,179 @@
+package goodgenerator.blocks.tileEntity;
+
+import java.util.Map;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import thaumcraft.api.TileThaumcraft;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.aspects.IAspectContainer;
+import thaumcraft.api.aspects.IEssentiaTransport;
+
+public class EssentiaOutputHatch extends TileThaumcraft implements IAspectContainer, IEssentiaTransport {
+
+    public static final int CAPACITY = 256;
+    protected AspectList mAspects = new AspectList();
+
+    public void clear() {
+        this.mAspects.aspects.clear();
+    }
+
+    @Override
+    public void markDirty() {
+        super.markDirty();
+        if (this.worldObj.isRemote) return;
+        this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound nbttagcompound) {
+        super.readFromNBT(nbttagcompound);
+        this.mAspects.aspects.clear();
+        NBTTagList tlist = nbttagcompound.getTagList("Aspects", 10);
+        for (int j = 0; j < tlist.tagCount(); ++j) {
+            NBTTagCompound rs = tlist.getCompoundTagAt(j);
+            if (rs.hasKey("key")) mAspects.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount"));
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound nbttagcompound) {
+        super.writeToNBT(nbttagcompound);
+        Aspect[] aspectA = this.mAspects.getAspects();
+        NBTTagList nbtTagList = new NBTTagList();
+        for (Aspect aspect : aspectA) {
+            if (aspect != null) {
+                NBTTagCompound f = new NBTTagCompound();
+                f.setString("key", aspect.getTag());
+                f.setInteger("amount", this.mAspects.getAmount(aspect));
+                nbtTagList.appendTag(f);
+            }
+        }
+        nbttagcompound.setTag("Aspects", nbtTagList);
+    }
+
+    private int remainingCapacity() {
+        return CAPACITY - this.getEssentiaAmount(null);
+    }
+
+    @Override
+    public AspectList getAspects() {
+        return this.mAspects;
+    }
+
+    @Override
+    public void setAspects(AspectList aspectList) {
+        for (Map.Entry<Aspect, Integer> entry : aspectList.aspects.entrySet()) {
+            this.addEssentia(entry.getKey(), entry.getValue(), null);
+        }
+    }
+
+    @Override
+    public boolean doesContainerAccept(Aspect var1) {
+        return true;
+    }
+
+    @Override
+    public int addToContainer(Aspect aspect, int amount) {
+        int remaining = 0;
+        if (amount > this.remainingCapacity()) {
+            remaining = amount - this.remainingCapacity();
+            this.mAspects.add(aspect, this.remainingCapacity());
+        } else this.mAspects.add(aspect, amount);
+        this.markDirty();
+        return remaining;
+    }
+
+    @Override
+    public boolean takeFromContainer(Aspect aspect, int amount) {
+        if (this.mAspects != null && this.mAspects.getAmount(aspect) >= amount) {
+            this.mAspects.remove(aspect, amount);
+            this.markDirty();
+            return true;
+        } else return false;
+    }
+
+    @Override
+    public boolean takeFromContainer(AspectList aspects) {
+        return true;
+    }
+
+    @Override
+    public boolean doesContainerContainAmount(Aspect aspect, int amount) {
+        return this.mAspects.getAmount(aspect) >= amount;
+    }
+
+    @Override
+    public boolean doesContainerContain(AspectList aspectList) {
+        for (Map.Entry<Aspect, Integer> entry : aspectList.aspects.entrySet()) {
+            if (this.mAspects.getAmount(entry.getKey()) < entry.getValue()) return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int containerContains(Aspect aspect) {
+        return this.mAspects.getAmount(aspect);
+    }
+
+    @Override
+    public boolean isConnectable(ForgeDirection var1) {
+        return true;
+    }
+
+    @Override
+    public boolean canInputFrom(ForgeDirection var1) {
+        return false;
+    }
+
+    @Override
+    public boolean canOutputTo(ForgeDirection var1) {
+        return true;
+    }
+
+    @Override
+    public void setSuction(Aspect var1, int var2) {}
+
+    @Override
+    public Aspect getSuctionType(ForgeDirection var1) {
+        return null;
+    }
+
+    @Override
+    public int getSuctionAmount(ForgeDirection var1) {
+        return 0;
+    }
+
+    @Override
+    public int takeEssentia(Aspect aspect, int amount, ForgeDirection var3) {
+        return this.takeFromContainer(aspect, amount) ? amount : 0;
+    }
+
+    @Override
+    public int addEssentia(Aspect aspect, int amount, ForgeDirection direction) {
+        return amount - addToContainer(aspect, amount);
+    }
+
+    @Override
+    public Aspect getEssentiaType(ForgeDirection var1) {
+        return this.mAspects.size() > 0 ? this.mAspects.getAspects()[0] : null;
+    }
+
+    @Override
+    public int getEssentiaAmount(ForgeDirection var1) {
+        return this.mAspects.visSize();
+    }
+
+    @Override
+    public int getMinimumSuction() {
+        return 0;
+    }
+
+    @Override
+    public boolean renderExtendedTube() {
+        return true;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch_ME.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch_ME.java
new file mode 100644
index 0000000000..b576b44e7f
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch_ME.java
@@ -0,0 +1,150 @@
+package goodgenerator.blocks.tileEntity;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import appeng.api.config.Actionable;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.security.IActionHost;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.IGridProxyable;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+import goodgenerator.util.ItemRefer;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumicenergistics.api.grid.IEssentiaGrid;
+import thaumicenergistics.api.grid.IMEEssentiaMonitor;
+
+public class EssentiaOutputHatch_ME extends EssentiaOutputHatch implements IActionHost, IGridProxyable {
+
+    private AENetworkProxy gridProxy = null;
+    private IMEEssentiaMonitor monitor = null;
+    private MachineSource asMachineSource = new MachineSource(this);
+
+    @Override
+    public void updateEntity() {
+        getProxy();
+        super.updateEntity();
+    }
+
+    @Override
+    public void invalidate() {
+        super.invalidate();
+        this.invalidateAE();
+    }
+
+    @Override
+    public void onChunkUnload() {
+        super.onChunkUnload();
+        this.onChunkUnloadAE();
+    }
+
+    @TileEvent(TileEventType.WORLD_NBT_READ)
+    public void readFromNBT_AENetwork(final NBTTagCompound data) {
+        AENetworkProxy gp = getProxy();
+        if (gp != null) getProxy().readFromNBT(data);
+    }
+
+    @TileEvent(TileEventType.WORLD_NBT_WRITE)
+    public void writeToNBT_AENetwork(final NBTTagCompound data) {
+        AENetworkProxy gp = getProxy();
+        if (gp != null) gp.writeToNBT(data);
+    }
+
+    void onChunkUnloadAE() {
+        AENetworkProxy gp = getProxy();
+        if (gp != null) gp.onChunkUnload();
+    }
+
+    void invalidateAE() {
+        AENetworkProxy gp = getProxy();
+        if (gp != null) gp.invalidate();
+    }
+
+    @Override
+    public IGridNode getGridNode(ForgeDirection forgeDirection) {
+        AENetworkProxy gp = getProxy();
+        return gp != null ? gp.getNode() : null;
+    }
+
+    @Override
+    public void gridChanged() {}
+
+    @Override
+    public AECableType getCableConnectionType(ForgeDirection forgeDirection) {
+        return AECableType.SMART;
+    }
+
+    @Override
+    public void securityBreak() {}
+
+    @Override
+    public AENetworkProxy getProxy() {
+        if (gridProxy == null) {
+            gridProxy = new AENetworkProxy(this, "proxy", ItemRefer.Essentia_Output_Hatch_ME.get(1), true);
+            gridProxy.onReady();
+            gridProxy.setFlags(GridFlags.REQUIRE_CHANNEL);
+        }
+        return this.gridProxy;
+    }
+
+    @Override
+    public DimensionalCoord getLocation() {
+        return new DimensionalCoord(this.worldObj, this.xCoord, this.yCoord, this.zCoord);
+    }
+
+    @Override
+    public IGridNode getActionableNode() {
+        AENetworkProxy gp = getProxy();
+        return gp != null ? gp.getNode() : null;
+    }
+
+    @Override
+    public boolean takeFromContainer(AspectList aspects) {
+        return false;
+    }
+
+    @Override
+    public boolean takeFromContainer(Aspect aspect, int amount) {
+        return false;
+    }
+
+    @Override
+    public int addEssentia(Aspect aspect, int amount, ForgeDirection side) {
+        return this.addEssentia(aspect, amount, side, Actionable.MODULATE);
+    }
+
+    public int addEssentia(Aspect aspect, int amount, ForgeDirection side, Actionable mode) {
+        long rejectedAmount = amount;
+        if (this.getEssentiaMonitor()) {
+            rejectedAmount = this.monitor.injectEssentia(aspect, amount, mode, this.getMachineSource(), true);
+        }
+
+        long acceptedAmount = (long) amount - rejectedAmount;
+        return (int) acceptedAmount;
+    }
+
+    protected boolean getEssentiaMonitor() {
+        IMEEssentiaMonitor essentiaMonitor = null;
+        IGrid grid = null;
+        IGridNode node = this.getProxy()
+            .getNode();
+
+        if (node != null) {
+            grid = node.getGrid();
+            if (grid != null) essentiaMonitor = grid.getCache(IEssentiaGrid.class);
+        }
+        this.monitor = essentiaMonitor;
+        return (this.monitor != null);
+    }
+
+    public MachineSource getMachineSource() {
+        return this.asMachineSource;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
new file mode 100644
index 0000000000..af1fd82030
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
@@ -0,0 +1,416 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.GT_Values.V;
+import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.api.recipe.ExtremeHeatExchangerRecipe;
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.interfaces.IHatchElement;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.multitileentity.multiblock.casing.Glasses;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.IGT_HatchAdder;
+
+public class ExtremeHeatExchanger extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    protected IStructureDefinition<ExtremeHeatExchanger> multiDefinition = null;
+
+    public static double penalty_per_config = 0.015d;
+    protected int casingAmount = 0;
+    protected GT_MetaTileEntity_Hatch_Input mHotFluidHatch;
+    protected GT_MetaTileEntity_Hatch_Output mCooledFluidHatch;
+    private boolean transformed = false;
+    private String hotName;
+    private ExtremeHeatExchangerRecipe tRunningRecipe;
+
+    public ExtremeHeatExchanger(String name) {
+        super(name);
+    }
+
+    public ExtremeHeatExchanger(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public IStructureDefinition<ExtremeHeatExchanger> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<ExtremeHeatExchanger>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] {
+                            // spotless:off
+                                            { " CCC ", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", " CCC " },
+                                            { " CCC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CCC " },
+                                            { " CFC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CEC " },
+                                            { " CCC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CCC " },
+                                            { " CCC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CCC " },
+                                            { " C~C ", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", " CCC " },
+                                        //spotless:on
+                        }))
+                .addElement(
+                    'B',
+                    ofChain(
+                        buildHatchAdder(ExtremeHeatExchanger.class)
+                            .atLeast(GT_HatchElement.InputHatch, GT_HatchElement.Maintenance)
+                            .casingIndex(48)
+                            .dot(1)
+                            .build(),
+                        onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 0))))
+                .addElement(
+                    'T',
+                    ofChain(
+                        buildHatchAdder(ExtremeHeatExchanger.class)
+                            .atLeast(GT_HatchElement.OutputHatch, GT_HatchElement.Maintenance)
+                            .casingIndex(48)
+                            .dot(2)
+                            .build(),
+                        onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 0))))
+                .addElement('F', EHEHatches.HotInputHatch.newAny(48, 3))
+                .addElement('E', EHEHatches.ColdOutputHatch.newAny(48, 4))
+                .addElement(
+                    'C',
+                    ofChain(
+                        buildHatchAdder(ExtremeHeatExchanger.class).atLeast(GT_HatchElement.Maintenance)
+                            .casingIndex(48)
+                            .dot(5)
+                            .build(),
+                        onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 0))))
+                .addElement('G', Glasses.chainAllGlasses())
+                .addElement('P', ofBlock(GregTech_API.sBlockCasings2, 15))
+                .addElement('W', ofBlock(Loaders.pressureResistantWalls, 0))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    public boolean addHotFluidInputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+            mHotFluidHatch = (GT_MetaTileEntity_Hatch_Input) aMetaTileEntity;
+            return true;
+        }
+        return false;
+    }
+
+    public boolean addColdFluidOutputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+            mCooledFluidHatch = (GT_MetaTileEntity_Hatch_Output) aMetaTileEntity;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        transformed = aNBT.getBoolean("transformed");
+        if (aNBT.hasKey("hotName", Constants.NBT.TAG_STRING)) {
+            String loadedHotName = aNBT.getString("hotName");
+            Fluid hotFluid = FluidRegistry.getFluid(loadedHotName);
+            if (hotFluid != null) {
+                hotName = loadedHotName;
+                tRunningRecipe = (ExtremeHeatExchangerRecipe) GoodGeneratorRecipeMaps.extremeHeatExchangerFuels
+                    .getBackend()
+                    .findFuel(hotFluid);
+            }
+        } else {
+            hotName = null;
+            tRunningRecipe = null;
+        }
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setBoolean("transformed", transformed);
+        if (hotName != null) aNBT.setString("hotName", hotName);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return GoodGeneratorRecipeMaps.extremeHeatExchangerFuels;
+    }
+
+    @Override
+    protected void clearHatches_EM() {
+        super.clearHatches_EM();
+        mCooledFluidHatch = null;
+        mHotFluidHatch = null;
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        this.casingAmount = 0;
+        return structureCheck_EM(mName, 2, 5, 0) && mMaintenanceHatches.size() == 1 && casingAmount >= 25;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Heat Exchanger/Plasma Heat Exchanger")
+            .addInfo("Controller block for the Extreme Heat Exchanger.")
+            .addInfo("Accept Hot fluid like lava, hot coolant or plasma.")
+            .addInfo("Output SC Steam/SH Steam/Steam.")
+            .addInfo("Check NEI for more info.")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addController("Front bottom")
+            .addOtherStructurePart("Input Hatch", "distilled water", 1)
+            .addOtherStructurePart("Output Hatch", "SC Steam/SH Steam/Steam", 2)
+            .addOtherStructurePart("Input Hatch", "Hot fluid or plasma", 3)
+            .addOtherStructurePart("Output Hatch", "Cold fluid", 4)
+            .addMaintenanceHatch("Any Casing", 1, 2, 5)
+            .addCasingInfoMin("Robust Tungstensteel Machine Casings", 25, false)
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing_EM() {
+        tRunningRecipe = null;
+        if (mHotFluidHatch.getFluid() == null) return CheckRecipeResultRegistry.SUCCESSFUL;
+        ExtremeHeatExchangerRecipe tRecipe = (ExtremeHeatExchangerRecipe) GoodGeneratorRecipeMaps.extremeHeatExchangerFuels
+            .getBackend()
+            .findFuel(mHotFluidHatch.getFluid());
+        if (tRecipe == null) return CheckRecipeResultRegistry.NO_RECIPE;
+        tRunningRecipe = tRecipe;
+        this.hotName = mHotFluidHatch.getFluid()
+            .getFluid()
+            .getName();
+        int tMaxConsume = tRecipe.getMaxHotFluidConsume();
+        int transformed_threshold = tRecipe.mSpecialValue;
+        int tRealConsume = Math.min(tMaxConsume, mHotFluidHatch.getFluid().amount);
+        double penalty = 0.0d;
+        double efficiency = 1d;
+        int shs_reduction_per_config = 150;
+
+        if (mInventory[1] != null && mInventory[1].getUnlocalizedName()
+            .startsWith("gt.integrated_circuit")) {
+            int circuit_config = mInventory[1].getItemDamage();
+            if (circuit_config >= 1 && circuit_config <= 25) {
+                penalty = (circuit_config - 1) * penalty_per_config;
+                transformed_threshold -= (shs_reduction_per_config * (circuit_config - 1));
+            }
+        }
+        efficiency -= penalty;
+
+        if (transformed_threshold <= 0) transformed_threshold = 1;
+
+        transformed = tRealConsume >= transformed_threshold;
+
+        this.mMaxProgresstime = 20;
+        this.mEUt = (int) (tRecipe.getEUt() * efficiency * ((double) tRealConsume / (double) tMaxConsume));
+        mHotFluidHatch.drain(tRealConsume, true);
+        mCooledFluidHatch.fill(new FluidStack(tRecipe.getCooledFluid(), tRealConsume), true);
+        this.mEfficiencyIncrease = 160;
+
+        return CheckRecipeResultRegistry.SUCCESSFUL;
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack aStack) {
+        if (this.mEUt > 0 && tRunningRecipe != null) {
+            Fluid tReadySteam = transformed ? tRunningRecipe.getHeatedSteam() : tRunningRecipe.getNormalSteam();
+            int waterAmount = (int) (this.mEUt / getUnitSteamPower(tReadySteam.getName())) / 160;
+            if (waterAmount < 0) return false;
+            if (depleteInput(GT_ModHandler.getDistilledWater(waterAmount))) {
+                addOutput(new FluidStack(tReadySteam, waterAmount * 160));
+            } else {
+                GT_Log.exp.println(this.mName + " had no more Distilled water!");
+                mHotFluidHatch.getBaseMetaTileEntity()
+                    .doExplosion(V[8]);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public double getUnitSteamPower(String steam) {
+        switch (steam) {
+            case "steam":
+                return 0.5;
+            case "ic2superheatedsteam":
+                return 1;
+            case "supercriticalsteam":
+                return 100;
+            default:
+                return -1;
+        }
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        structureBuild_EM(mName, 2, 5, 0, stackSize, hintsOnly);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("ExtremeHeatExchanger.hint", 6);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new ExtremeHeatExchanger(mName);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        int tThreshold = tRunningRecipe != null ? tRunningRecipe.mSpecialValue : 0;
+        return new String[] {
+            StatCollector.translateToLocal("GT5U.multiblock.Progress") + ": "
+                + EnumChatFormatting.GREEN
+                + GT_Utility.formatNumbers(mProgresstime / 20)
+                + EnumChatFormatting.RESET
+                + " s / "
+                + EnumChatFormatting.YELLOW
+                + GT_Utility.formatNumbers(mMaxProgresstime / 20)
+                + EnumChatFormatting.RESET
+                + " s",
+            StatCollector.translateToLocal("GT5U.multiblock.problems") + ": "
+                + EnumChatFormatting.RED
+                + (getIdealStatus() - getRepairStatus())
+                + EnumChatFormatting.RESET
+                + " "
+                + StatCollector.translateToLocal("GT5U.multiblock.efficiency")
+                + ": "
+                + EnumChatFormatting.YELLOW
+                + mEfficiency / 100.0F
+                + EnumChatFormatting.RESET
+                + " %",
+            StatCollector.translateToLocal("scanner.info.XHE.0") + " "
+                + (transformed ? EnumChatFormatting.RED : EnumChatFormatting.YELLOW)
+                + GT_Utility.formatNumbers(this.mEUt)
+                + EnumChatFormatting.RESET
+                + " EU/t",
+            StatCollector.translateToLocal("scanner.info.XHE.1") + " "
+                + EnumChatFormatting.GREEN
+                + GT_Utility.formatNumbers(tThreshold)
+                + EnumChatFormatting.RESET
+                + " L/s" };
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { casingTexturePages[0][48], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { casingTexturePages[0][48], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { casingTexturePages[0][48] };
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 2, 5, 0, elementBudget, env, false, true);
+    }
+
+    private enum EHEHatches implements IHatchElement<ExtremeHeatExchanger> {
+
+        HotInputHatch(ExtremeHeatExchanger::addHotFluidInputToMachineList, GT_MetaTileEntity_Hatch_Input.class) {
+
+            @Override
+            public long count(ExtremeHeatExchanger t) {
+                if (t.mHotFluidHatch == null) return 0;
+                return 1;
+            }
+        },
+        ColdOutputHatch(ExtremeHeatExchanger::addColdFluidOutputToMachineList, GT_MetaTileEntity_Hatch_Output.class) {
+
+            @Override
+            public long count(ExtremeHeatExchanger t) {
+                if (t.mCooledFluidHatch == null) return 0;
+                return 1;
+            }
+        };
+
+        private final List<Class<? extends IMetaTileEntity>> mteClasses;
+        private final IGT_HatchAdder<ExtremeHeatExchanger> adder;
+
+        EHEHatches(IGT_HatchAdder<ExtremeHeatExchanger> adder, Class<? extends IMetaTileEntity>... mteClasses) {
+            this.mteClasses = Collections.unmodifiableList(Arrays.asList(mteClasses));
+            this.adder = adder;
+        }
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return mteClasses;
+        }
+
+        public IGT_HatchAdder<? super ExtremeHeatExchanger> adder() {
+            return adder;
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
new file mode 100644
index 0000000000..85c4bffbab
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
@@ -0,0 +1,376 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.AutoPlaceEnvironment;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.IStructureElement;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizon.structurelib.structure.StructureUtility;
+
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_Recipe;
+
+public class FuelRefineFactory extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    private IStructureDefinition<FuelRefineFactory> multiDefinition = null;
+    private int Tier = -1;
+    private int[] cnt = new int[] { 0, 0, 0, 0 };
+    private static final Block[] coils = new Block[] { Loaders.FRF_Coil_1, Loaders.FRF_Coil_2, Loaders.FRF_Coil_3,
+        Loaders.FRF_Coil_4 };
+
+    public FuelRefineFactory(String name) {
+        super(name);
+        turnOffMaintenance();
+        useLongPower = true;
+    }
+
+    public FuelRefineFactory(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+        turnOffMaintenance();
+        useLongPower = true;
+    }
+
+    @Override
+    public void onFirstTick_EM(IGregTechTileEntity aBaseMetaTileEntity) {
+        if (!hasMaintenanceChecks) turnOffMaintenance();
+    }
+
+    @Override
+    public boolean doRandomMaintenanceDamage() {
+        return true;
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean hintsOnly) {
+        structureBuild_EM(mName, 7, 12, 1, itemStack, hintsOnly);
+    }
+
+    @Override
+    public IStructureDefinition<FuelRefineFactory> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<FuelRefineFactory>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] { { "               ", "      CCC      ", "               " },
+                            { "      XGX      ", "    CCFFFCC    ", "      XGX      " },
+                            { "    CC   CC    ", "   CFFCCCFFC   ", "    CC   CC    " },
+                            { "   C       C   ", "  CFCC   CCFC  ", "   C       C   " },
+                            { "  C         C  ", " CFC       CFC ", "  C         C  " },
+                            { "  C         C  ", " CFC       CFC ", "  C         C  " },
+                            { " X           X ", "CFC         CFC", " X           X " },
+                            { " G           G ", "CFC         CFC", " G           G " },
+                            { " X           X ", "CFC         CFC", " X           X " },
+                            { "  C         C  ", " CFC       CFC ", "  C         C  " },
+                            { "  C         C  ", " CFC       CFC ", "  C         C  " },
+                            { "   C       C   ", "  CFCC   CCFC  ", "   C       C   " },
+                            { "    CC   CC    ", "   CFFC~CFFC   ", "    CC   CC    " },
+                            { "      XGX      ", "    CCFFFCC    ", "      XGX      " },
+                            { "               ", "      CCC      ", "               " } }))
+                .addElement(
+                    'X',
+                    buildHatchAdder(FuelRefineFactory.class)
+                        .atLeast(
+                            GT_HatchElement.Maintenance,
+                            GT_HatchElement.InputHatch,
+                            GT_HatchElement.InputBus,
+                            GT_HatchElement.OutputHatch,
+                            HatchElement.EnergyMulti.or(GT_HatchElement.Energy))
+                        .casingIndex(179)
+                        .dot(1)
+                        .buildAndChain(ofBlock(Loaders.FRF_Casings, 0)))
+                .addElement('C', ofBlock(Loaders.FRF_Casings, 0))
+                .addElement('G', ofBlock(Loaders.fieldRestrictingGlass, 0))
+                .addElement(
+                    'F',
+                    ofChain(
+                        onElementPass(x -> ++x.cnt[0], ofFieldCoil(0)),
+                        onElementPass(x -> ++x.cnt[1], ofFieldCoil(1)),
+                        onElementPass(x -> ++x.cnt[2], ofFieldCoil(2)),
+                        onElementPass(x -> ++x.cnt[3], ofFieldCoil(3))))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    public static <T> IStructureElement<T> ofFieldCoil(int aIndex) {
+        return new IStructureElement<T>() {
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                Block block = world.getBlock(x, y, z);
+                return block.equals(coils[aIndex]);
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                StructureLibAPI.hintParticle(world, x, y, z, coils[getIndex(trigger)], 0);
+                return true;
+            }
+
+            private int getIndex(ItemStack trigger) {
+                int s = trigger.stackSize;
+                if (s > 4 || s <= 0) s = 4;
+                return s - 1;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return world.setBlock(x, y, z, coils[getIndex(trigger)], 0, 3);
+            }
+
+            @Override
+            public BlocksToPlace getBlocksToPlace(T t, World world, int x, int y, int z, ItemStack trigger,
+                AutoPlaceEnvironment env) {
+                return BlocksToPlace.create(coils[getIndex(trigger)], 0);
+            }
+
+            @Override
+            public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
+                AutoPlaceEnvironment env) {
+                if (check(t, world, x, y, z)) return PlaceResult.SKIP;
+                return StructureUtility.survivalPlaceBlock(
+                    coils[getIndex(trigger)],
+                    0,
+                    world,
+                    x,
+                    y,
+                    z,
+                    env.getSource(),
+                    env.getActor(),
+                    env.getChatter());
+            }
+        };
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Naquadah Fuel Refinery")
+            .addInfo("Controller block for the Naquadah Fuel Refinery")
+            .addInfo("But at what cost?")
+            .addInfo("Produces naquadah fuels.")
+            .addInfo("Needs field restriction coils to control the fatal radiation.")
+            .addInfo("Use higher tier coils to unlock more fuel types and reduce the processing times.")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .beginStructureBlock(3, 15, 15, false)
+            .addInputHatch("The casings adjoin the field restriction glass.")
+            .addInputBus("The casings adjoin the field restriction glass.", 1)
+            .addOutputHatch("The casings adjoin the field restriction glass.", 1)
+            .addEnergyHatch("The casings adjoin the field restriction glass.", 1)
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        this.Tier = aNBT.getInteger("mTier");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("mTier", this.Tier);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("FuelRefineFactory.hint", 8);
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        cnt[0] = 0;
+        cnt[1] = 0;
+        cnt[2] = 0;
+        cnt[3] = 0;
+        return structureCheck_EM(mName, 7, 12, 1) && getTier() != -1;
+    }
+
+    public int getTier() {
+        for (int i = 0; i < 4; i++) {
+            if (cnt[i] == 32) {
+                Tier = i + 1;
+                return i;
+            }
+        }
+        Tier = -1;
+        return -1;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return GoodGeneratorRecipeMaps.naquadahFuelRefineFactoryRecipes;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult validateRecipe(@NotNull GT_Recipe recipe) {
+                if (recipe.mSpecialValue > Tier) {
+                    return CheckRecipeResultRegistry.insufficientMachineTier(recipe.mSpecialValue);
+                }
+                return CheckRecipeResultRegistry.SUCCESSFUL;
+            }
+
+            @NotNull
+            @Override
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                int overclockAmount = Tier - recipe.mSpecialValue;
+                return super.createOverclockCalculator(recipe).limitOverclockCount(overclockAmount);
+            }
+        }.setOverclock(1, 1); // Set Overclock to be 2/2
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        logic.setAvailableVoltage(getMaxInputEu());
+        logic.setAvailableAmperage(1);
+    }
+
+    public final boolean addToFRFList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity == null) {
+                return false;
+            } else {
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch) {
+                    ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                }
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+                    return this.mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+                    return this.mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus) {
+                    return this.mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+                    return this.mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+                    return this.eEnergyMulti.add((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity);
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new FuelRefineFactory(this.mName);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        String[] infoData = new String[super.getInfoData().length + 1];
+        System.arraycopy(super.getInfoData(), 0, infoData, 0, super.getInfoData().length);
+        infoData[super.getInfoData().length] = StatCollector.translateToLocal("scanner.info.FRF") + " " + this.Tier;
+        return infoData;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    @SuppressWarnings("ALL")
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(179),
+                new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE), TextureFactory.builder()
+                    .addIcon(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE_GLOW)
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(179),
+                new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE), TextureFactory.builder()
+                    .addIcon(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_GLOW)
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(179) };
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 7, 12, 1, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/DieselGenerator.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/DieselGenerator.java
new file mode 100644
index 0000000000..4d54be44d1
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/DieselGenerator.java
@@ -0,0 +1,214 @@
+package goodgenerator.blocks.tileEntity.GTMetaTileEntity;
+
+import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.enums.Textures.BlockIcons.DIESEL_GENERATOR_SIDE_ACTIVE_GLOW;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.GT_Mod;
+import gregtech.api.enums.ItemList;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Utility;
+
+public class DieselGenerator extends GT_MetaTileEntity_BasicGenerator {
+
+    public int mEfficiency;
+
+    public DieselGenerator(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            new String[] { "Requires liquid Fuel",
+                "Causes " + (int) (GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond * (1.1 - aTier * 0.1))
+                    + " Pollution per second" });
+        mEfficiency = 100 - aTier * 10;
+    }
+
+    public DieselGenerator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+        mEfficiency = 100 - aTier * 10;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new DieselGenerator(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return RecipeMaps.dieselFuels;
+    }
+
+    @Override
+    public int getCapacity() {
+        return 16000;
+    }
+
+    @Override
+    public int getEfficiency() {
+        return this.mEfficiency;
+    }
+
+    @Override
+    public int getFuelValue(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack) || getRecipeMap() == null) return 0;
+        long rValue = Math.max(GT_ModHandler.getFuelCanValue(aStack) * 6 / 5, super.getFuelValue(aStack));
+        if (ItemList.Fuel_Can_Plastic_Filled.isStackEqual(aStack, false, true)) {
+            rValue = Math.max(rValue, GameRegistry.getFuelValue(aStack) * 3L);
+        }
+        if (rValue > Integer.MAX_VALUE) {
+            throw new ArithmeticException("Integer LOOPBACK!");
+        }
+        return (int) rValue;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aTick % 100 == 0 && mFluid != null && mFluid.amount > this.getCapacity()) {
+            GT_Log.err.println(
+                "Dupe Abuse: " + aBaseMetaTileEntity.getOwnerName()
+                    + " Coords: "
+                    + aBaseMetaTileEntity.getXCoord()
+                    + " "
+                    + aBaseMetaTileEntity.getYCoord()
+                    + " "
+                    + aBaseMetaTileEntity.getZCoord());
+            aBaseMetaTileEntity.setToFire();
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public ITexture[] getFront(byte aColor) {
+        return new ITexture[] { super.getFront(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_FRONT),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_FRONT_GLOW)
+                    .glow()
+                    .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier] };
+    }
+
+    @Override
+    public ITexture[] getBack(byte aColor) {
+        return new ITexture[] { super.getBack(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_BACK),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_BACK_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getBottom(byte aColor) {
+        return new ITexture[] { super.getBottom(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_BOTTOM),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_BOTTOM_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getTop(byte aColor) {
+        return new ITexture[] { super.getTop(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_TOP),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_TOP_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getSides(byte aColor) {
+        return new ITexture[] { super.getSides(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_SIDE),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_SIDE_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getFrontActive(byte aColor) {
+        return new ITexture[] { super.getFrontActive(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_FRONT_ACTIVE),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_FRONT_ACTIVE_GLOW)
+                    .glow()
+                    .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier] };
+    }
+
+    @Override
+    public ITexture[] getBackActive(byte aColor) {
+        return new ITexture[] { super.getBackActive(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_BACK_ACTIVE),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_BACK_ACTIVE_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getBottomActive(byte aColor) {
+        return new ITexture[] { super.getBottomActive(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_BOTTOM_ACTIVE),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_BOTTOM_ACTIVE_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getTopActive(byte aColor) {
+        return new ITexture[] { super.getTopActive(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_TOP_ACTIVE),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_TOP_ACTIVE_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public ITexture[] getSidesActive(byte aColor) {
+        return new ITexture[] { super.getSidesActive(aColor)[0],
+            TextureFactory.of(
+                TextureFactory.of(DIESEL_GENERATOR_SIDE_ACTIVE),
+                TextureFactory.builder()
+                    .addIcon(DIESEL_GENERATOR_SIDE_ACTIVE_GLOW)
+                    .glow()
+                    .build()) };
+    }
+
+    @Override
+    public int getPollution() {
+        return (int) (GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond * (1.1 - mTier * 0.1));
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java
new file mode 100644
index 0000000000..730374db66
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java
@@ -0,0 +1,48 @@
+package goodgenerator.blocks.tileEntity.GTMetaTileEntity;
+
+import static gregtech.api.enums.GT_Values.V;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+
+public class NeutronAccelerator extends GT_MetaTileEntity_Hatch_Energy {
+
+    public NeutronAccelerator(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+    }
+
+    public NeutronAccelerator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    public int getMaxEUConsume() {
+        return (int) (V[mTier] * 8 / 10);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new NeutronAccelerator(mName, mTier, this.getDescription(), mTextures);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { "Input EU to Accelerate the Neutron!", "Max EU input: " + this.maxEUInput(),
+            "Max EU consumption: " + this.getMaxEUConsume(),
+            "Every EU can be transformed into 10~20 eV Neutron Kinetic Energy." };
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (aBaseMetaTileEntity.getStoredEU() >= getMaxEUConsume() && aBaseMetaTileEntity.isAllowedToWork()) {
+                setEUVar(aBaseMetaTileEntity.getStoredEU() - getMaxEUConsume());
+                aBaseMetaTileEntity.setActive(true);
+            } else {
+                aBaseMetaTileEntity.setActive(false);
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java
new file mode 100644
index 0000000000..86bcbeece9
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java
@@ -0,0 +1,277 @@
+package goodgenerator.blocks.tileEntity.GTMetaTileEntity;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget;
+
+import crazypants.enderio.Log;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GT_UIInfos;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.gui.modularui.widget.CoverCycleButtonWidget;
+
+public class NeutronSensor extends GT_MetaTileEntity_Hatch {
+
+    private static final IIconContainer textureFont = new Textures.BlockIcons.CustomIcon("icons/NeutronSensorFont");
+    private static final IIconContainer textureFont_Glow = new Textures.BlockIcons.CustomIcon(
+        "icons/NeutronSensorFont_GLOW");
+
+    protected int threshold = 0;
+    protected boolean inverted = false;
+    boolean isOn = false;
+
+    public NeutronSensor(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "Detect Neutron Kinetic Energy.");
+    }
+
+    public NeutronSensor(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { "Can be installed in Neutron Activator.",
+            "Output Redstone Signal according to the Neutron Kinetic Energy.",
+            "Right click to open the GUI and setting." };
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        if (aNBT.hasKey("mBoxContext")) {
+            // Convert legacy settings
+            setThresholdFromString(aNBT.getString("mBoxContext"));
+        } else {
+            threshold = aNBT.getInteger("mThreshold");
+            inverted = aNBT.getBoolean("mInverted");
+        }
+        super.loadNBTData(aNBT);
+    }
+
+    /**
+     * Used to convert legacy setting where the sensor would use a string like ">200keV" to set its threshold. This
+     * method updates the {@link #threshold} and {@link #inverted} fields based on the input string. The string is
+     * assumed to be in format "(operator)(value)[suffix](ev)", where:
+     * <ul>
+     * <li>(operator) is one of "<", ">", "<=", ">=", "==", or "!="</li>
+     * <li>(value) is a numeric value (sequence of decimal digits)</li>
+     * <li>(suffix) is "k", "K", "m", or "M" (optional)</li>
+     * <li>(ev) is the string "ev", case-insensitive.</li>
+     * </ul>
+     * Note that operators "==" and "!=" can not be converted exactly, as the new threshold supports only a binary
+     * comparison (less than, or greater than or equal). Thus "==" is interpreted in the same way as "<=", and "!=" as
+     * ">". This shouldn't be a big problem for real setups, because one should probably not be testing for strict
+     * equality here anyway. The possible reasonable conditions "==0eV" and "!=0eV" will continue working as before.
+     *
+     * @param text String to convert.
+     */
+    private void setThresholdFromString(String text) {
+        Matcher matcher = Pattern.compile("^(<|>|<=|>=|==|!=)([0-9]*)(|k|m)(ev)$", Pattern.CASE_INSENSITIVE)
+            .matcher(text);
+
+        if (!matcher.matches()) {
+            Log.error("Failed to parse Neutron Sensor setting: \"" + text + "\"!");
+            return;
+        }
+
+        String operator = matcher.group(1);
+        String value = matcher.group(2);
+        String suffix = matcher.group(3);
+
+        int newThreshold = Integer.parseInt(value);
+
+        switch (suffix) {
+            case "k":
+            case "K":
+                newThreshold *= 1000;
+                break;
+            case "m":
+            case "M":
+                newThreshold *= 1_000_000;
+                break;
+        }
+
+        switch (operator) {
+            case "<":
+                threshold = newThreshold;
+                inverted = true;
+                break;
+            case ">":
+                threshold = newThreshold + 1;
+                inverted = false;
+                break;
+            case "<=":
+                threshold = newThreshold + 1;
+                inverted = true;
+                break;
+            case ">=":
+                threshold = newThreshold;
+                inverted = false;
+                break;
+            case "==": // Interpret as <= to keep "==0eV" working as before.
+                threshold = newThreshold + 1;
+                inverted = true;
+                break;
+            case "!=": // Interpret as > to keep "!=0eV" working as before.
+                threshold = newThreshold + 1;
+                inverted = false;
+                break;
+        }
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("mThreshold", threshold);
+        aNBT.setBoolean("mInverted", inverted);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {
+        getBaseMetaTileEntity().setActive(true);
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side,
+        float aX, float aY, float aZ) {
+        GT_UIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    /**
+     * Updates redstone output strength based on the eV of the multiblock.
+     *
+     * @param eV Amount of eV to compare.
+     */
+    public void updateRedstoneOutput(int eV) {
+        isOn = (eV >= threshold) ^ inverted;
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), TextureFactory.builder()
+            .addIcon(textureFont_Glow)
+            .glow()
+            .build() };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont) };
+    }
+
+    @Override
+    public boolean allowGeneralRedstoneOutput() {
+        return true;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (isOn) {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 15);
+            }
+        } else {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 0);
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new NeutronSensor(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection Side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean useModularUI() {
+        return true;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        final String INVERTED = GT_Utility.trans("INVERTED", "Inverted");
+        final String NORMAL = GT_Utility.trans("NORMAL", "Normal");
+
+        builder.widget(
+            new CoverCycleButtonWidget().setToggle(() -> inverted, (val) -> inverted = val)
+                .setTextureGetter(
+                    (state) -> state == 1 ? GT_UITextures.OVERLAY_BUTTON_REDSTONE_ON
+                        : GT_UITextures.OVERLAY_BUTTON_REDSTONE_OFF)
+                .addTooltip(0, NORMAL)
+                .addTooltip(1, INVERTED)
+                .setPos(10, 8))
+            .widget(
+                new TextWidget().setStringSupplier(() -> inverted ? INVERTED : NORMAL)
+                    .setDefaultColor(COLOR_TEXT_GRAY.get())
+                    .setTextAlignment(Alignment.CenterLeft)
+                    .setPos(28, 12))
+            .widget(
+                new NumericWidget().setBounds(0, 1200000000)
+                    .setGetter(() -> threshold)
+                    .setSetter((value) -> threshold = (int) value)
+                    .setScrollValues(1000, 1, 1_000_000)
+                    .setTextColor(Color.WHITE.dark(1))
+                    .setTextAlignment(Alignment.CenterLeft)
+                    .setFocusOnGuiOpen(true)
+                    .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD.withOffset(-1, -1, 2, 2))
+                    .setPos(10, 28)
+                    .setSize(77, 12))
+            .widget(
+                new TextWidget(StatCollector.translateToLocal("gui.NeutronSensor.4"))
+                    .setDefaultColor(COLOR_TEXT_GRAY.get())
+                    .setTextAlignment(Alignment.CenterLeft)
+                    .setPos(90, 30));
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/YOTTAHatch.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/YOTTAHatch.java
new file mode 100644
index 0000000000..f905e82f8c
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/YOTTAHatch.java
@@ -0,0 +1,470 @@
+package goodgenerator.blocks.tileEntity.GTMetaTileEntity;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.events.MENetworkCellArrayUpdate;
+import appeng.api.networking.events.MENetworkStorageEvent;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.IActionHost;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.ICellContainer;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IItemList;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.IGridProxyable;
+import goodgenerator.blocks.tileEntity.YottaFluidTank;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.StackUtils;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Utility;
+
+public class YOTTAHatch extends GT_MetaTileEntity_Hatch implements IGridProxyable, IActionHost, ICellContainer,
+    IMEInventory<IAEFluidStack>, IMEInventoryHandler<IAEFluidStack> {
+
+    private static final IIconContainer textureFont = new Textures.BlockIcons.CustomIcon("icons/YOTTAHatch");
+
+    private YottaFluidTank host;
+    private AENetworkProxy gridProxy = null;
+    private int priority;
+    private byte tickRate = 20;
+    private FluidStack lastFluid = null;
+    private BigInteger lastAmt = BigInteger.ZERO;
+    private AccessRestriction readMode = AccessRestriction.READ_WRITE;
+    private final AccessRestriction[] AEModes = new AccessRestriction[] { AccessRestriction.NO_ACCESS,
+        AccessRestriction.READ, AccessRestriction.WRITE, AccessRestriction.READ_WRITE };
+
+    private static final BigInteger MAX_LONG_BIGINT = BigInteger.valueOf(Long.MAX_VALUE);
+
+    public YOTTAHatch(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { "Special I/O port for AE2FC.", "Directly connected YOTTank with AE fluid storage system.",
+                "Use screwdriver to set storage priority", "Use soldering iron to set read/write mode" });
+    }
+
+    public YOTTAHatch(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    public void setTank(YottaFluidTank te) {
+        this.host = te;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("mAEPriority", this.priority);
+        aNBT.setInteger("mAEMode", this.readMode.ordinal());
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        this.priority = aNBT.getInteger("mAEPriority");
+        this.readMode = AEModes[aNBT.getInteger("mAEMode")];
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public final void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ,
+        ItemStack toolStack) {
+        if (aPlayer.isSneaking()) this.priority -= 10;
+        else this.priority += 10;
+        GT_Utility
+            .sendChatToPlayer(aPlayer, String.format(StatCollector.translateToLocal("yothatch.chat.0"), this.priority));
+    }
+
+    @Override
+    public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
+        float aX, float aY, float aZ, ItemStack toolStack) {
+        this.readMode = AEModes[(readMode.ordinal() + 1) % 4];
+        GT_Utility
+            .sendChatToPlayer(aPlayer, String.format(StatCollector.translateToLocal("yothatch.chat.1"), this.readMode));
+        return true;
+    }
+
+    @Override
+    public IGridNode getGridNode(ForgeDirection forgeDirection) {
+        AENetworkProxy gp = getProxy();
+        return gp != null ? gp.getNode() : null;
+    }
+
+    @Override
+    public AECableType getCableConnectionType(ForgeDirection forgeDirection) {
+        return AECableType.SMART;
+    }
+
+    @Override
+    public void securityBreak() {}
+
+    @Override
+    public AENetworkProxy getProxy() {
+        if (gridProxy == null) {
+            gridProxy = new AENetworkProxy(this, "proxy", Loaders.YFH, true);
+            gridProxy.onReady();
+            gridProxy.setFlags(GridFlags.REQUIRE_CHANNEL);
+        }
+        return this.gridProxy;
+    }
+
+    @Override
+    public DimensionalCoord getLocation() {
+        IGregTechTileEntity gtm = this.getBaseMetaTileEntity();
+        return new DimensionalCoord(gtm.getWorld(), gtm.getXCoord(), gtm.getYCoord(), gtm.getZCoord());
+    }
+
+    @Override
+    public IItemList<IAEFluidStack> getAvailableItems(IItemList<IAEFluidStack> out) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return out;
+        if (host.mFluid == null || host.mStorageCurrent.signum() <= 0) return out;
+        long ready;
+        if (host.mStorageCurrent.compareTo(MAX_LONG_BIGINT) >= 0) {
+            ready = Long.MAX_VALUE;
+        } else ready = host.mStorageCurrent.longValue();
+        out.add(StackUtils.createAEFluidStack(host.mFluid.getFluid(), ready));
+        return out;
+    }
+
+    @Override
+    public IAEFluidStack injectItems(IAEFluidStack input, Actionable type, BaseActionSource src) {
+        long amt = fill(null, input, false);
+        if (amt == input.getStackSize()) {
+            if (type.equals(Actionable.MODULATE)) fill(null, input, true);
+            return null;
+        }
+        return input;
+    }
+
+    @Override
+    public IAEFluidStack extractItems(IAEFluidStack request, Actionable mode, BaseActionSource src) {
+        IAEFluidStack ready = drain(null, request, false);
+        if (ready != null) {
+            if (mode.equals(Actionable.MODULATE)) drain(null, ready, true);
+            return ready;
+        } else return null;
+    }
+
+    @Override
+    public StorageChannel getChannel() {
+        return StorageChannel.FLUIDS;
+    }
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+        super.onFirstTick(aBaseMetaTileEntity);
+        getProxy();
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (shouldTick(aTick)) {
+            if (isChanged()) {
+                IGridNode node = getGridNode(null);
+                if (node != null) {
+                    IGrid grid = node.getGrid();
+                    if (grid != null) {
+                        grid.postEvent(new MENetworkCellArrayUpdate());
+                        IStorageGrid storageGrid = grid.getCache(IStorageGrid.class);
+                        if (storageGrid == null) {
+                            node.getGrid()
+                                .postEvent(new MENetworkStorageEvent(null, StorageChannel.FLUIDS));
+                        } else {
+                            node.getGrid()
+                                .postEvent(
+                                    new MENetworkStorageEvent(storageGrid.getFluidInventory(), StorageChannel.FLUIDS));
+                        }
+                        node.getGrid()
+                            .postEvent(new MENetworkCellArrayUpdate());
+                    }
+                }
+                faster();
+                update();
+            } else {
+                slower();
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public int getCapacity() {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return 0;
+        if (host.mStorage.compareTo(YottaFluidTank.MAX_INT_BIGINT) >= 0) {
+            return Integer.MAX_VALUE;
+        } else return host.mStorage.intValue();
+    }
+
+    @Override
+    public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return 0;
+        if (host.mLockedFluid != null && !host.mLockedFluid.isFluidEqual(resource)) return 0;
+        if (host.mFluid == null || host.mFluid.isFluidEqual(resource)) {
+            if (host.mFluid == null) {
+                host.mFluid = resource.copy();
+                host.mFluid.amount = 1;
+            }
+
+            if (host.addFluid(resource.amount, doFill)) {
+                return resource.amount;
+            } else {
+                final int returned;
+                if (host.getIsVoidExcessEnabled()) {
+                    returned = resource.amount;
+                } else {
+                    final BigInteger delta = host.mStorage.subtract(host.mStorageCurrent);
+                    returned = delta.intValueExact();
+                }
+                host.mStorageCurrent = host.mStorage;
+                return returned;
+            }
+        }
+        return 0;
+    }
+
+    public long fill(@SuppressWarnings("unused") ForgeDirection from, IAEFluidStack resource, boolean doFill) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return 0;
+        if (host.mLockedFluid != null && host.mLockedFluid.getFluid() != resource.getFluid()) return 0;
+        if (host.mFluid == null || host.mFluid.getFluid() == resource.getFluid()) {
+            if (host.mFluid == null) {
+                host.mFluid = resource.getFluidStack(); // makes a copy internally
+                host.mFluid.amount = 1;
+            }
+
+            if (host.addFluid(resource.getStackSize(), doFill)) {
+                return resource.getStackSize();
+            } else {
+                final long returned;
+                if (host.getIsVoidExcessEnabled()) {
+                    returned = resource.getStackSize();
+                } else {
+                    final BigInteger delta = host.mStorage.subtract(host.mStorageCurrent);
+                    returned = delta.longValueExact();
+                }
+                host.mStorageCurrent = host.mStorage;
+                return returned;
+            }
+        }
+        return 0;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return null;
+        if (host.mFluid == null || host.mFluid.getFluid() != resource.getFluid()) return null;
+        int ready;
+        if (host.mStorageCurrent.compareTo(YottaFluidTank.MAX_INT_BIGINT) >= 0) {
+            ready = Integer.MAX_VALUE;
+        } else ready = host.mStorageCurrent.intValue();
+        ready = Math.min(ready, resource.amount);
+        if (doDrain) {
+            host.reduceFluid(ready);
+        }
+        return new FluidStack(resource.getFluid(), ready);
+    }
+
+    public IAEFluidStack drain(@SuppressWarnings("unused") ForgeDirection from, IAEFluidStack resource,
+        boolean doDrain) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return null;
+        if (host.mFluid == null || host.mFluid.getFluid() != resource.getFluid()) return null;
+        long ready;
+        if (host.mStorageCurrent.compareTo(MAX_LONG_BIGINT) > 0) {
+            ready = Long.MAX_VALUE;
+        } else ready = host.mStorageCurrent.longValue();
+        ready = Math.min(ready, resource.getStackSize());
+        if (doDrain) {
+            host.reduceFluid(ready);
+        }
+        IAEFluidStack copy = resource.copy();
+        copy.setStackSize(ready);
+        return copy;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return null;
+        if (host.mFluid == null) return null;
+        final FluidStack drainStack = host.mFluid.copy();
+        drainStack.amount = maxDrain;
+        return this.drain(from, drainStack, doDrain);
+    }
+
+    private static final FluidTankInfo[] EMPTY_TANK_INFO = new FluidTankInfo[] { new FluidTankInfo(null, 0) };
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+        if (host == null || host.getBaseMetaTileEntity() == null
+            || !host.getBaseMetaTileEntity()
+                .isActive())
+            return EMPTY_TANK_INFO;
+
+        return host.getTankInfo(from);
+    }
+
+    @Override
+    public boolean canTankBeFilled() {
+        return true;
+    }
+
+    @Override
+    public boolean canTankBeEmptied() {
+        return true;
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), };
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new YOTTAHatch(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public IGridNode getActionableNode() {
+        AENetworkProxy gp = getProxy();
+        return gp != null ? gp.getNode() : null;
+    }
+
+    @Override
+    public AccessRestriction getAccess() {
+        return this.readMode;
+    }
+
+    @Override
+    public boolean isPrioritized(IAEFluidStack input) {
+        return true;
+    }
+
+    @Override
+    public boolean canAccept(IAEFluidStack input) {
+        FluidStack rInput = input.getFluidStack();
+        return fill(null, rInput, false) > 0;
+    }
+
+    @Override
+    @SuppressWarnings("rawtypes")
+    public List<IMEInventoryHandler> getCellArray(StorageChannel channel) {
+        List<IMEInventoryHandler> list = new ArrayList<>();
+        if (channel == StorageChannel.FLUIDS) {
+            list.add(this);
+        }
+        return list;
+    }
+
+    @Override
+    public int getPriority() {
+        return this.priority;
+    }
+
+    @Override
+    public int getSlot() {
+        return 0;
+    }
+
+    @Override
+    public boolean validForPass(int i) {
+        return true;
+    }
+
+    @Override
+    public void blinkCell(int slot) {}
+
+    @Override
+    public void saveChanges(IMEInventory cellInventory) {
+        // This is handled by host itself.
+    }
+
+    private boolean isChanged() {
+        if (this.host == null) return false;
+        return !this.lastAmt.equals(this.host.mStorageCurrent) || this.lastFluid != this.host.mFluid;
+    }
+
+    private void update() {
+        if (this.host == null) return;
+        this.lastAmt = this.host.mStorageCurrent;
+        this.lastFluid = this.host.mFluid;
+    }
+
+    private void faster() {
+        if (this.tickRate > 15) {
+            this.tickRate -= 5;
+        }
+    }
+
+    private void slower() {
+        if (this.tickRate < 100) {
+            this.tickRate += 5;
+        }
+    }
+
+    private boolean shouldTick(long tick) {
+        if (this.host == null) return false;
+        return tick % this.tickRate == 0;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java
new file mode 100644
index 0000000000..b590378922
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java
@@ -0,0 +1,511 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import java.util.ArrayList;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoTunnel;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData;
+import goodgenerator.items.MyMaterial;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import goodgenerator.util.ItemRefer;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.objects.XSTR;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.common.config.ConfigBlocks;
+
+public class LargeEssentiaGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    private IStructureDefinition<LargeEssentiaGenerator> multiDefinition = null;
+    protected int mStableValue = 0;
+    protected int mTierLimit = -1;
+    protected long mLeftEnergy;
+    private int mUpgrade = 1;
+    final XSTR R = new XSTR();
+    protected ArrayList<EssentiaHatch> mEssentiaHatch = new ArrayList<>();
+
+    public LargeEssentiaGenerator(String name) {
+        super(name);
+    }
+
+    public LargeEssentiaGenerator(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean hintsOnly) {
+        structureBuild_EM(mName, 4, 0, 4, itemStack, hintsOnly);
+    }
+
+    @Override
+    protected void clearHatches_EM() {
+        super.clearHatches_EM();
+        mEssentiaHatch.clear();
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        mStableValue = 0;
+        return structureCheck_EM(mName, 4, 0, 4) && (mDynamoHatches.size() + eDynamoMulti.size()) == 1
+            && checkHatchTier()
+            && checkNoLaser()
+            && updateEssentiaHatchState();
+    }
+
+    private boolean checkNoLaser() {
+        for (GT_MetaTileEntity_Hatch_DynamoMulti tHatch : eDynamoMulti) {
+            if (tHatch instanceof GT_MetaTileEntity_Hatch_DynamoTunnel) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean checkHatchTier() {
+        for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
+            if (tHatch.mTier > mTierLimit) return false;
+        }
+        for (GT_MetaTileEntity_Hatch_Dynamo tHatch : mDynamoHatches) {
+            if (tHatch.mTier > mTierLimit) return false;
+        }
+        for (GT_MetaTileEntity_Hatch_DynamoMulti tHatch : eDynamoMulti) {
+            if (tHatch.mTier > mTierLimit) return false;
+        }
+        return true;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        this.mStableValue = aNBT.getInteger("mStableValue");
+        this.mLeftEnergy = aNBT.getLong("mLeftEnergy");
+        this.mUpgrade = aNBT.getInteger("mUpgrade");
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("mStableValue", this.mStableValue);
+        aNBT.setLong("mLeftEnergy", this.mLeftEnergy);
+        aNBT.setInteger("mUpgrade", this.mUpgrade);
+    }
+
+    public boolean updateEssentiaHatchState() {
+        for (EssentiaHatch hatch : mEssentiaHatch) {
+            hatch.mState = mUpgrade;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (this.getBaseMetaTileEntity()
+            .isServerSide()) {
+            ItemStack tCurrentItem = aPlayer.inventory.getCurrentItem();
+            if (tCurrentItem != null && tCurrentItem.getItem()
+                .equals(
+                    ItemRefer.Essentia_Upgrade_Empty.get(1)
+                        .getItem())) {
+                int tMeta = tCurrentItem.getItemDamage();
+                if ((mUpgrade & (1 << tMeta)) == 0 && tMeta != 0) {
+                    tCurrentItem.stackSize--;
+                    mUpgrade = mUpgrade | (1 << tMeta);
+                    GT_Utility.sendChatToPlayer(
+                        aPlayer,
+                        tCurrentItem.getDisplayName() + StatCollector.translateToLocal("largeessentiagenerator.chat"));
+                }
+                updateEssentiaHatchState();
+                return true;
+            }
+        }
+        super.onRightclick(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public IStructureDefinition<LargeEssentiaGenerator> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<LargeEssentiaGenerator>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] {
+                            { "A       A", "         ", "         ", "         ", "    ~    ", "         ", "         ",
+                                "         ", "A       A" },
+                            { "T   C   T", "   CEC   ", "  CEEEC  ", " CEEEEEC ", "CEEEEEEEC", " CEEEEEC ", "  CEEEC  ",
+                                "   CEC   ", "T   C   T" },
+                            { "T  TXT  T", "  TCXCT  ", " TCCXCCT ", "TCCCXCCCT", "XXXXXXXXX", "TCCCXCCCT", " TCCXCCT ",
+                                "  TCXCT  ", "T  TXT  T" } }))
+                .addElement('A', ofBlock(ConfigBlocks.blockCosmeticOpaque, 1))
+                .addElement('T', ofBlock(ConfigBlocks.blockCosmeticSolid, 7))
+                .addElement('C', ofBlock(Loaders.magicCasing, 0)) //
+                .addElement('E', ofChain(onElementPass(x -> {
+                    ++x.mStableValue;
+                    x.mTierLimit = Math.max(x.mTierLimit, 4);
+                }, ofBlock(Loaders.essentiaCell, 0)), onElementPass(x -> {
+                    x.mStableValue += 2;
+                    x.mTierLimit = Math.max(x.mTierLimit, 5);
+                }, ofBlock(Loaders.essentiaCell, 1)), onElementPass(x -> {
+                    x.mStableValue += 5;
+                    x.mTierLimit = Math.max(x.mTierLimit, 6);
+                }, ofBlock(Loaders.essentiaCell, 2)), onElementPass(x -> {
+                    x.mStableValue += 10;
+                    x.mTierLimit = Math.max(x.mTierLimit, 8);
+                }, ofBlock(Loaders.essentiaCell, 3))))
+                .addElement(
+                    'X',
+                    ofChain(
+                        buildHatchAdder(LargeEssentiaGenerator.class)
+                            .atLeast(
+                                HatchElement.DynamoMulti.or(GT_HatchElement.Dynamo),
+                                GT_HatchElement.Maintenance,
+                                GT_HatchElement.InputHatch)
+                            .casingIndex(1536)
+                            .dot(1)
+                            .build(),
+                        ofBlock(Loaders.magicCasing, 0),
+                        ofSpecificTileAdder(
+                            LargeEssentiaGenerator::addEssentiaHatch,
+                            EssentiaHatch.class,
+                            Loaders.magicCasing,
+                            0)))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    public final boolean addEssentiaHatch(EssentiaHatch aTileEntity) {
+        return this.mEssentiaHatch.add(aTileEntity);
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing_EM() {
+        this.mEfficiency = 10000;
+        this.mMaxProgresstime = 1;
+        setEssentiaToEUVoltageAndAmp(getVoltageLimit(), getAmpLimit());
+        return CheckRecipeResultRegistry.GENERATING;
+    }
+
+    public int getVoltageLimit() {
+        long voltage = 0;
+        for (GT_MetaTileEntity_Hatch tHatch : this.eDynamoMulti) {
+            voltage += tHatch.maxEUOutput();
+        }
+        for (GT_MetaTileEntity_Hatch tHatch : this.mDynamoHatches) {
+            voltage += tHatch.maxEUOutput();
+        }
+        if (voltage > Integer.MAX_VALUE) voltage = Integer.MAX_VALUE;
+        return (int) voltage;
+    }
+
+    public int getAmpLimit() {
+        long amp = 0;
+        for (GT_MetaTileEntity_Hatch tHatch : this.eDynamoMulti) {
+            amp += tHatch.maxAmperesOut();
+        }
+        for (GT_MetaTileEntity_Hatch tHatch : this.mDynamoHatches) {
+            amp += tHatch.maxAmperesOut();
+        }
+        if (amp > Integer.MAX_VALUE) amp = Integer.MAX_VALUE;
+        return (int) amp;
+    }
+
+    public long getPerAspectEnergy(Aspect aspect) {
+        int type = LargeEssentiaEnergyData.getAspectTypeIndex(aspect);
+        if (!isValidEssentia(aspect)) return 0;
+        switch (type) {
+            case 0:
+                return normalEssentia(aspect);
+            case 1:
+                return airEssentia(aspect);
+            case 2:
+                return thermalEssentia(aspect);
+            case 3:
+                return unstableEssentia(aspect);
+            case 4:
+                return victusEssentia(aspect);
+            case 5:
+                return taintedEssentia(aspect);
+            case 6:
+                return mechanicEssentia(aspect);
+            case 7:
+                return spiritEssentia(aspect);
+            case 8:
+                return radiationEssentia(aspect);
+            case 9:
+                return electricEssentia(aspect);
+            default:
+                return 0;
+        }
+    }
+
+    public long normalEssentia(Aspect aspect) {
+        return LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+    }
+
+    public long airEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 0;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 8;
+        if (depleteInput(Materials.LiquidAir.getFluid(ceoInput))) {
+            ceoOutput = 1.5D;
+        } else if (depleteInput(Materials.Air.getGas(ceoInput))) {
+            ceoOutput = 1.0D;
+        }
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long thermalEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 0;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 2;
+        if (depleteInput(Materials.SuperCoolant.getFluid(ceoInput))) {
+            ceoOutput = 9.0D;
+        } else if (depleteInput(FluidRegistry.getFluidStack("cryotheum", ceoInput))) {
+            ceoOutput = 5.0D;
+        } else if (depleteInput(FluidRegistry.getFluidStack("ic2coolant", ceoInput))) {
+            ceoOutput = 1.5D;
+        } else if (depleteInput(Materials.Ice.getSolid(ceoInput))) {
+            ceoOutput = 1.2D;
+        } else if (depleteInput(FluidRegistry.getFluidStack("ic2distilledwater", ceoInput))) {
+            ceoOutput = 1.0D;
+        } else if (depleteInput(Materials.Water.getFluid(ceoInput))) {
+            ceoOutput = 0.5D;
+        }
+
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long unstableEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 0;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 4;
+        if (depleteInput(WerkstoffLoader.Xenon.getFluidOrGas(ceoInput))) {
+            ceoOutput = 4.0D;
+        } else if (depleteInput(WerkstoffLoader.Krypton.getFluidOrGas(ceoInput))) {
+            ceoOutput = 3.0D;
+        } else if (depleteInput(Materials.Argon.getFluid(ceoInput))) {
+            ceoOutput = 2.5D;
+        } else if (depleteInput(WerkstoffLoader.Neon.getFluidOrGas(ceoInput))) {
+            ceoOutput = 2.2D;
+        } else if (depleteInput(Materials.Helium.getFluid(ceoInput))) {
+            ceoOutput = 2.0D;
+        } else if (depleteInput(Materials.Nitrogen.getFluid(ceoInput))) {
+            ceoOutput = 1.0D;
+        }
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long victusEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 1.0D;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 18;
+        if (depleteInput(FluidRegistry.getFluidStack("xpjuice", ceoInput))) {
+            ceoOutput = 2.0D;
+        } else if (depleteInput(FluidRegistry.getFluidStack("lifeessence", ceoInput))) {
+            ceoOutput = 6.0D;
+        }
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long taintedEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 1.0D;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 3;
+        int chance = 2000;
+        if (depleteInput(FluidRegistry.getFluidStack("fluidpure", ceoInput))) {
+            ceoOutput = 60.0D;
+            chance = 0;
+        } else if (depleteInput(FluidRegistry.getFluidStack("fluiddeath", ceoInput))) {
+            ceoOutput = Math.pow(25000D / baseValue, 4);
+            chance = 4000;
+        }
+
+        if (R.nextInt(10000) < chance) {
+            World world = getBaseMetaTileEntity().getWorld();
+            int tX = R.nextInt(4);
+            int tZ = R.nextInt(4);
+            if (world.isAirBlock(tX, 0, tZ)) world.setBlock(tX, 0, tZ, ConfigBlocks.blockFluxGas, R.nextInt(8), 3);
+        }
+
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long mechanicEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 0;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 20;
+        if (depleteInput(Materials.Lubricant.getFluid(ceoInput))) {
+            ceoOutput = 1.0D;
+        }
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long spiritEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 1.0D;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 2;
+        if (depleteInput(FluidRegistry.getFluidStack("witchery:fluidspirit", ceoInput))) {
+            ceoOutput = 10D * (1 + mStableValue / 100D);
+        } else if (depleteInput(FluidRegistry.getFluidStack("witchery:hollowtears", ceoInput))) {
+            ceoOutput = 15D * (1 + 100D / mStableValue);
+        }
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long radiationEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = 1.0D;
+        int ceoInput = (int) LargeEssentiaEnergyData.getAspectCeo(aspect) * 6;
+        if (depleteInput(Materials.Caesium.getMolten(ceoInput))) {
+            ceoOutput = 2.0D;
+        } else if (depleteInput(Materials.Uranium235.getMolten(ceoInput))) {
+            ceoOutput = 3.0D;
+        } else if (depleteInput(Materials.Naquadah.getMolten(ceoInput))) {
+            ceoOutput = 4.0D;
+        } else if (depleteInput(MyMaterial.atomicSeparationCatalyst.getMolten(ceoInput))) {
+            ceoOutput = 16.0D;
+        }
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public long electricEssentia(Aspect aspect) {
+        long baseValue = LargeEssentiaEnergyData.getAspectFuelValue(aspect);
+        double ceoOutput = Math.pow(3.0, GT_Utility.getTier(getVoltageLimit()));
+        return (long) (baseValue * ceoOutput);
+    }
+
+    public void setEssentiaToEUVoltageAndAmp(long voltageLimit, long ampLimit) {
+        long EUt = mLeftEnergy;
+        long EUVoltage = voltageLimit, EUAmp = 1;
+
+        for (EssentiaHatch hatch : this.mEssentiaHatch) {
+            AspectList aspects = hatch.getAspects();
+            for (Aspect aspect : aspects.aspects.keySet()) {
+                if (!isValidEssentia(aspect)) continue;
+                while (EUt <= (voltageLimit * ampLimit) && aspects.getAmount(aspect) > 0) {
+                    long addedEU = getPerAspectEnergy(aspect) * mStableValue / 25;
+                    if (addedEU == 0) break;
+                    EUt += addedEU;
+                    aspects.reduce(aspect, 1);
+                    if (aspects.getAmount(aspect) == 0) aspects.remove(aspect);
+                }
+            }
+        }
+
+        if (EUt <= voltageLimit) {
+            EUVoltage = EUt;
+            EUAmp = 1;
+            mLeftEnergy = 0;
+        } else {
+            while (EUVoltage * (EUAmp + 1) <= EUt && EUAmp + 1 <= ampLimit) {
+                EUAmp++;
+            }
+            mLeftEnergy = EUt - (EUVoltage * EUAmp);
+        }
+
+        this.mEUt = (int) EUVoltage;
+        this.eAmpereFlow = (int) EUAmp;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("LargeEssentiaGenerator.hint", 6);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new LargeEssentiaGenerator(this.mName);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Essentia Generator")
+            .addInfo("Controller block for the Large Essentia Generator")
+            .addInfo("Maybe some Thaumaturges are upset by it. . .")
+            .addInfo("Transform Essentia into energy!")
+            .addInfo("The Diffusion Cell determines the highest hatch tier that the LEG can accept.")
+            .addInfo("Supports normal Dynamo Hatches or TecTech ones for up to 64A, but no Laser Hatches.")
+            .addInfo("You can find more information about this generator in the Thaumonomicon.")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addMaintenanceHatch("Hint block with dot 1", 1)
+            .addInputHatch("Hint block with dot 1", 1)
+            .addDynamoHatch("Hint block with dot 1", 1)
+            .addOtherStructurePart("Essentia Input Hatch", "Essentia Input", 1)
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    @SuppressWarnings("ALL")
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1536),
+                new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_DRAGONEGG), TextureFactory.builder()
+                    .addIcon(Textures.BlockIcons.MACHINE_CASING_DRAGONEGG_GLOW)
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1536),
+                new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_DRAGONEGG) };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1536) };
+    }
+
+    public boolean isValidEssentia(Aspect aspect) {
+        int type = LargeEssentiaEnergyData.getAspectTypeIndex(aspect);
+        return type != -1 && (mUpgrade & (1 << type)) != 0;
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 4, 0, 4, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
new file mode 100644
index 0000000000..039bd76c51
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
@@ -0,0 +1,558 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Mods.ThaumicBases;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.objects.XSTR;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.recipe.check.SimpleCheckRecipeResult;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.visnet.VisNetHandler;
+import thaumcraft.common.config.ConfigBlocks;
+import thaumcraft.common.lib.crafting.ThaumcraftCraftingManager;
+
+public class LargeEssentiaSmeltery extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon(
+        "icons/LargeEssentiaSmeltery_On");
+    private static final IIconContainer textureFontOn_Glow = new Textures.BlockIcons.CustomIcon(
+        "icons/LargeEssentiaSmeltery_On_GLOW");
+    private static final IIconContainer textureFontOff = new Textures.BlockIcons.CustomIcon(
+        "icons/LargeEssentiaSmeltery_Off");
+    private static final IIconContainer textureFontOff_Glow = new Textures.BlockIcons.CustomIcon(
+        "icons/LargeEssentiaSmeltery_Off_GLOW");
+    private static final String STRUCTURE_PIECE_FIRST = "first";
+    private static final String STRUCTURE_PIECE_LATER = "later";
+    private static final String STRUCTURE_PIECE_LAST = "last";
+    private static final int CASING_INDEX = 1536;
+    private static final int MAX_STRUCTURE_LENGTH = 8;
+    private static final int DEFAULT_STRUCTURE_LENGTH = 3;
+    private static final int MAX_CONFIGURABLE_LENGTH = MAX_STRUCTURE_LENGTH - DEFAULT_STRUCTURE_LENGTH;
+
+    private static final int RECIPE_DURATION = 32;
+    private static final int RECIPE_EUT = 480;
+    private static final float NODE_COST_MULTIPLIER = 1.15f;
+
+    public AspectList mOutputAspects = new AspectList();
+    protected int mCasing = 0;
+    protected double mParallel = 0;
+    protected int nodePower = 0;
+    protected int nodePurificationEfficiency = 0;
+    protected int nodeIncrease = 0;
+
+    private IStructureDefinition<LargeEssentiaSmeltery> multiDefinition = null;
+    private ArrayList<EssentiaOutputHatch> mEssentiaOutputHatches = new ArrayList<>();
+    private int pTier = 0;
+    private XSTR xstr = new XSTR();
+
+    public LargeEssentiaSmeltery(String name) {
+        super(name);
+    }
+
+    public LargeEssentiaSmeltery(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean hintsOnly) {
+        structureBuild_EM(STRUCTURE_PIECE_FIRST, 2, 2, 0, itemStack, hintsOnly);
+        // default
+        structureBuild_EM(STRUCTURE_PIECE_LATER, 2, 2, -1, itemStack, hintsOnly);
+        structureBuild_EM(STRUCTURE_PIECE_LATER, 2, 2, -2, itemStack, hintsOnly);
+        int len = itemStack.stackSize;
+        if (len > MAX_CONFIGURABLE_LENGTH) len = MAX_CONFIGURABLE_LENGTH;
+        structureBuild_EM(STRUCTURE_PIECE_LAST, 2, 2, -len - 3, itemStack, hintsOnly);
+        while (len > 0) {
+            structureBuild_EM(STRUCTURE_PIECE_LATER, 2, 2, -len - 2, itemStack, hintsOnly);
+            len--;
+        }
+    }
+
+    @Override
+    protected void clearHatches_EM() {
+        super.clearHatches_EM();
+        mEssentiaOutputHatches.clear();
+    }
+
+    @Override
+    protected boolean checkMachine_EM(IGregTechTileEntity iGregTechTileEntity, ItemStack itemStack) {
+        this.mCasing = 0;
+        this.mParallel = 0;
+        this.pTier = 0;
+        this.nodePower = 0;
+        this.nodePurificationEfficiency = 0;
+        this.nodeIncrease = 0;
+
+        if (!structureCheck_EM(STRUCTURE_PIECE_FIRST, 2, 2, 0)) return false;
+        if (!structureCheck_EM(STRUCTURE_PIECE_LATER, 2, 2, -1)) return false;
+        if (!structureCheck_EM(STRUCTURE_PIECE_LATER, 2, 2, -2)) return false;
+        int len = 2;
+        while (structureCheck_EM(STRUCTURE_PIECE_LATER, 2, 2, -len - 1)) len++;
+        if (len > MAX_STRUCTURE_LENGTH - 1 || len < DEFAULT_STRUCTURE_LENGTH) return false;
+        if (!structureCheck_EM(STRUCTURE_PIECE_LAST, 2, 2, -len - 1)) return false;
+        if (this.mCasing >= 24 && this.mMaintenanceHatches.size() == 1
+            && this.mInputBusses.size() >= 1
+            && this.mEssentiaOutputHatches.size() >= 1) {
+            this.mParallel = Math.floor(this.mParallel += 1 << this.pTier);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public IStructureDefinition<? extends GT_MetaTileEntity_MultiblockBase_EM> getStructure_EM() {
+        if (this.multiDefinition == null) {
+            this.multiDefinition = StructureDefinition.<LargeEssentiaSmeltery>builder()
+                .addShape(
+                    "first",
+                    transpose(new String[][] { { "  A  " }, { " AAA " }, { "AA~AA" }, { " AAA " }, { "  A  " } }))
+                .addShape(
+                    "later",
+                    transpose(new String[][] { { " ABA " }, { "AECEA" }, { "D---D" }, { "AEFEA" }, { " AAA " } }))
+                .addShape(
+                    "last",
+                    transpose(new String[][] { { "  A  " }, { " AAA " }, { "AAAAA" }, { " AAA " }, { "  A  " } }))
+                .addElement('C', ofBlock(Loaders.essentiaFilterCasing, 0))
+                .addElement('D', ofBlock(ConfigBlocks.blockCosmeticOpaque, 2))
+                .addElement(
+                    'F',
+                    ThaumicBases.isModLoaded() ? ofBlock(Block.getBlockFromName("thaumicbases:advAlchFurnace"), 0)
+                        : ofBlock(ConfigBlocks.blockStoneDevice, 0))
+                .addElement(
+                    'E',
+                    ofChain(
+                        onElementPass(x -> x.onEssentiaCellFound(0), ofBlock(Loaders.essentiaCell, 0)),
+                        onElementPass(x -> x.onEssentiaCellFound(1), ofBlock(Loaders.essentiaCell, 1)),
+                        onElementPass(x -> x.onEssentiaCellFound(2), ofBlock(Loaders.essentiaCell, 2)),
+                        onElementPass(x -> x.onEssentiaCellFound(3), ofBlock(Loaders.essentiaCell, 3))))
+                .addElement(
+                    'A',
+                    ofChain(
+                        buildHatchAdder(LargeEssentiaSmeltery.class)
+                            .atLeast(GT_HatchElement.Maintenance, GT_HatchElement.Energy, GT_HatchElement.InputBus)
+                            .casingIndex(CASING_INDEX)
+                            .dot(1)
+                            .build(),
+                        ofSpecificTileAdder(
+                            LargeEssentiaSmeltery::addEssentiaOutputHatchToMachineList,
+                            EssentiaOutputHatch.class,
+                            Loaders.essentiaOutputHatch,
+                            0),
+                        onElementPass(LargeEssentiaSmeltery::onCasingFound, ofBlock(Loaders.magicCasing, 0))))
+                .addElement('B', GT_HatchElement.Muffler.newAny(CASING_INDEX, 2))
+                .build();
+        }
+        return this.multiDefinition;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Essentia Smeltery")
+            .addInfo("Controller block for the Large Essentia Smeltery")
+            .addInfo("Necessary evil.")
+            .addInfo("Advanced Essentia smelting technology.")
+            .addInfo("Max parallel dictated by structure size and Essentia Diffusion Cell tier")
+            .addInfo("Energy Hatch tier: HV+")
+            .addInfo("You can find more information about this machine in the Thaumonomicon.")
+            .addPollutionAmount(getPollutionPerSecond(null))
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addController("Front center")
+            .addCasingInfo("Magic Casing", 24)
+            .addMaintenanceHatch("Hint block with dot 1")
+            .addInputBus("Hint block with dot 1")
+            .addInputHatch("Hint block with dot 1")
+            .addEnergyHatch("Hint block with dot 1")
+            .addOtherStructurePart("Essentia Output Hatch", "Hint block with dot 1")
+            .addMufflerHatch("Hint block with dot 2")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("LargeEssentiaSmeltery.hint", 8);
+    }
+
+    @Override
+    public String[] getInfoData() {
+        String[] info = super.getInfoData();
+        info[8] = "Node Power: " + EnumChatFormatting.RED
+            + this.nodePower
+            + EnumChatFormatting.RESET
+            + " Purification Efficiency: "
+            + EnumChatFormatting.AQUA
+            + this.nodePurificationEfficiency
+            + "%"
+            + EnumChatFormatting.RESET
+            + " Speed Up: "
+            + EnumChatFormatting.GRAY
+            + this.nodeIncrease
+            + "%"
+            + EnumChatFormatting.RESET;
+        return info;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_INDEX),
+                TextureFactory.of(textureFontOn), TextureFactory.builder()
+                    .addIcon(textureFontOn_Glow)
+                    .glow()
+                    .build() };
+            else return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_INDEX),
+                TextureFactory.of(textureFontOff), TextureFactory.builder()
+                    .addIcon(textureFontOff_Glow)
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_INDEX) };
+    }
+
+    protected void onCasingFound() {
+        this.mCasing++;
+    }
+
+    protected void onEssentiaCellFound(int tier) {
+        this.mParallel += (1 << tier) * 0.25f;
+        this.pTier = Math.max(this.pTier, tier);
+    }
+
+    private boolean addEnergyHatchToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity == null) {
+                return false;
+            } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+                if (((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity).mTier < 3) return false;
+                ((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+            } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+                ((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.eEnergyMulti.add(((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity));
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private boolean addEssentiaOutputHatchToMachineList(EssentiaOutputHatch aTileEntity) {
+        if (aTileEntity instanceof EssentiaOutputHatch) {
+            return this.mEssentiaOutputHatches.add((EssentiaOutputHatch) aTileEntity);
+        }
+        return false;
+    }
+
+    @Override
+    protected void runMachine(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (!this.isFullPower()) return;
+        super.runMachine(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing_EM() {
+        if (!isFullPower()) return SimpleCheckRecipeResult.ofFailure("node_too_small");
+
+        ArrayList<ItemStack> tInputList = getStoredInputs();
+
+        if (tInputList.size() == 0) return CheckRecipeResultRegistry.NO_RECIPE;
+
+        int p = (int) this.mParallel;
+        for (int i = tInputList.size() - 1; i >= 0; i--) {
+            ItemStack itemStack = tInputList.get(i);
+            int stackSize = itemStack.stackSize;
+            int sur = p - stackSize;
+
+            if (sur > 0) {
+                p -= stackSize;
+                this.mOutputAspects.add(getEssentia(itemStack, stackSize));
+                if (!depleteInput(itemStack)) itemStack.stackSize = 0;
+            } else if (sur == 0) {
+                this.mOutputAspects.add(getEssentia(itemStack, stackSize));
+                if (!depleteInput(itemStack)) itemStack.stackSize = 0;
+                break;
+            } else {
+                this.mOutputAspects.add(getEssentia(itemStack, p));
+                itemStack.stackSize -= p;
+                break;
+            }
+        }
+
+        this.mEfficiency = 10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000;
+        this.mEfficiencyIncrease = 10000;
+
+        final World WORLD = this.getBaseMetaTileEntity()
+            .getWorld();
+        int x = this.getBaseMetaTileEntity()
+            .getXCoord();
+        int y = this.getBaseMetaTileEntity()
+            .getYCoord();
+        int z = this.getBaseMetaTileEntity()
+            .getZCoord();
+
+        this.drainNodePower(WORLD, x, y, z);
+        this.nodePower -= expectedPower();
+
+        calculatePerfectOverclockedNessMulti(
+            RECIPE_EUT,
+            (int) Math.ceil(this.mOutputAspects.visSize() * RECIPE_DURATION * (1 - this.nodeIncrease * 0.005)),
+            1,
+            Math.min(Integer.MAX_VALUE, getMaxInputEnergy_EM()));
+
+        this.updateSlots();
+        if (this.mEUt > 0) this.mEUt = -this.mEUt;
+        return CheckRecipeResultRegistry.SUCCESSFUL;
+    }
+
+    private AspectList getEssentia(ItemStack itemStack, int amount) {
+        AspectList aspectList = new AspectList();
+        AspectList aspects = ThaumcraftCraftingManager.getObjectTags(itemStack);
+        aspects = ThaumcraftCraftingManager.getBonusTags(itemStack, aspects);
+        if (aspects != null && aspects.size() != 0 && aspects.getAspects()[0] != null) {
+            for (int i = 0; i < amount; i++) aspectList.add(aspects);
+        } else aspectList.add(Aspect.ENTROPY, amount);
+        return aspectList;
+    }
+
+    private void fillEssentiaOutputHatch() {
+        for (EssentiaOutputHatch outputHatch : this.mEssentiaOutputHatches) {
+            for (Map.Entry<Aspect, Integer> entry : this.mOutputAspects.copy().aspects.entrySet()) {
+                Aspect aspect = entry.getKey();
+                int amount = entry.getValue();
+                this.mOutputAspects.remove(aspect, outputHatch.addEssentia(aspect, amount, null));
+            }
+        }
+        this.mOutputAspects.aspects.clear();
+    }
+
+    private int expectedPower() {
+        return (int) (Math.pow(this.getMaxEnergyInputTier_EM(), 2) * NODE_COST_MULTIPLIER);
+    }
+
+    private boolean isFullPower() {
+        return this.nodePower > expectedPower();
+    }
+
+    private void generateFluxGas(World world, int x, int y, int z) {
+        world.setBlock(x, y, z, ConfigBlocks.blockFluxGas, 8, 3);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setDouble("mParallel", this.mParallel);
+        aNBT.setDouble("nodePower", this.nodePower);
+        aNBT.setDouble("nodePurificationEfficiency", this.nodePurificationEfficiency);
+        aNBT.setDouble("nodeIncrease", this.nodeIncrease);
+
+        Aspect[] aspectA = this.mOutputAspects.getAspects();
+        NBTTagList nbtTagList = new NBTTagList();
+        for (Aspect aspect : aspectA) {
+            if (aspect != null) {
+                NBTTagCompound f = new NBTTagCompound();
+                f.setString("key", aspect.getTag());
+                f.setInteger("amount", this.mOutputAspects.getAmount(aspect));
+                nbtTagList.appendTag(f);
+            }
+        }
+        aNBT.setTag("Aspects", nbtTagList);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        this.mParallel = aNBT.getDouble("mParallel");
+        this.nodePower = aNBT.getInteger("nodePower");
+        this.nodePurificationEfficiency = aNBT.getInteger("nodePurificationEfficiency");
+        this.nodeIncrease = aNBT.getInteger("nodeIncrease");
+
+        this.mOutputAspects.aspects.clear();
+        NBTTagList tlist = aNBT.getTagList("Aspects", 10);
+        for (int j = 0; j < tlist.tagCount(); ++j) {
+            NBTTagCompound rs = tlist.getCompoundTagAt(j);
+            if (rs.hasKey("key"))
+                this.mOutputAspects.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount"));
+        }
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    protected void addClassicOutputs_EM() {
+        super.addClassicOutputs_EM();
+        fillEssentiaOutputHatch();
+    }
+
+    @Override
+    public void stopMachine() {
+        super.stopMachine();
+        this.mOutputAspects.aspects.clear();
+    }
+
+    private void drainNodePower(World world, int x, int y, int z) {
+        int power = this.expectedPower();
+        if (this.nodePower < power * 10) {
+            this.nodePower += VisNetHandler.drainVis(world, x, y, z, Aspect.WATER, power);
+            this.nodePower += VisNetHandler.drainVis(world, x, y, z, Aspect.FIRE, power);
+        }
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        if (aTick % 5 == 0 && this.mMachine) {
+            final World WORLD = this.getBaseMetaTileEntity()
+                .getWorld();
+            int x = this.getBaseMetaTileEntity()
+                .getXCoord();
+            int y = this.getBaseMetaTileEntity()
+                .getYCoord();
+            int z = this.getBaseMetaTileEntity()
+                .getZCoord();
+
+            this.drainNodePower(WORLD, x, y, z);
+
+            this.nodePurificationEfficiency = Math.max(0, this.nodePurificationEfficiency - 1);
+            if (this.nodePurificationEfficiency < 100) {
+                this.nodePurificationEfficiency = (int) Math.min(
+                    100,
+                    this.nodePurificationEfficiency
+                        + Math.ceil(VisNetHandler.drainVis(WORLD, x, y, z, Aspect.ORDER, 200) * 0.05));
+            }
+
+            this.nodeIncrease = Math.min(100, VisNetHandler.drainVis(WORLD, x, y, z, Aspect.ENTROPY, 125));
+        }
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack aStack) {
+        this.nodePurificationEfficiency = Math.max(0, this.nodePurificationEfficiency - 1);
+        if (xstr.nextInt(20) == 0) {
+            if (xstr.nextInt(100) < Math.max(100 - this.nodePurificationEfficiency, 0)) {
+                final World WORLD = this.getBaseMetaTileEntity()
+                    .getWorld();
+                GT_MetaTileEntity_Hatch_Muffler mufflerHatch = this.mMufflerHatches
+                    .get(xstr.nextInt(this.mMufflerHatches.size()));
+                int x = mufflerHatch.getBaseMetaTileEntity()
+                    .getXCoord();
+                int y = mufflerHatch.getBaseMetaTileEntity()
+                    .getYCoord();
+                int z = mufflerHatch.getBaseMetaTileEntity()
+                    .getZCoord();
+
+                ForgeDirection facing = mufflerHatch.getBaseMetaTileEntity()
+                    .getFrontFacing();
+                switch (facing) {
+                    case SOUTH:
+                        z += 1;
+                        break;
+                    case NORTH:
+                        z -= 1;
+                        break;
+                    case WEST:
+                        x -= 1;
+                        break;
+                    case EAST:
+                        x += 1;
+                        break;
+                    default:
+                        y += 1;
+                }
+                generateFluxGas(WORLD, x, y, z);
+            }
+        }
+        return super.onRunningTick(aStack);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack itemStack) {
+        return true;
+    }
+
+    @Override
+    public int getPollutionPerSecond(ItemStack aStack) {
+        return 22 * (100 - this.nodePurificationEfficiency);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack itemStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack itemStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack itemStack) {
+        return false;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new LargeEssentiaSmeltery(this.mName);
+    }
+
+    @Override
+    protected void maintenance_EM() {
+        super.maintenance_EM();
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        int built = survivialBuildPiece(STRUCTURE_PIECE_FIRST, stackSize, 2, 2, 0, elementBudget, env, false, true);
+        if (built >= 0) return built;
+        int length = stackSize.stackSize + 2;
+        if (length > MAX_CONFIGURABLE_LENGTH) length = MAX_CONFIGURABLE_LENGTH + 2;
+        for (int i = 1; i <= length; i++) {
+            built = survivialBuildPiece(STRUCTURE_PIECE_LATER, stackSize, 2, 2, -i, elementBudget, env, false, true);
+            if (built >= 0) return built;
+        }
+        return survivialBuildPiece(STRUCTURE_PIECE_LAST, stackSize, 2, 2, -length - 1, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java
new file mode 100644
index 0000000000..cad1cb001c
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java
@@ -0,0 +1,170 @@
+package goodgenerator.blocks.tileEntity;
+
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION1;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION1_GLOW;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+
+import goodgenerator.blocks.tileEntity.base.LargeFusionComputer;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+
+public class LargeFusionComputer1 extends LargeFusionComputer {
+
+    private static final ITexture textureOverlay = TextureFactory.of(
+        TextureFactory.builder()
+            .addIcon(OVERLAY_FUSION1)
+            .extFacing()
+            .build(),
+        TextureFactory.builder()
+            .addIcon(OVERLAY_FUSION1_GLOW)
+            .extFacing()
+            .glow()
+            .build());
+
+    public LargeFusionComputer1(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public LargeFusionComputer1(String name) {
+        super(name);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fusion Reactor")
+            .addInfo("Millions of nuclear.")
+            .addInfo("Controller block for the Compact Fusion Reactor MK-I Prototype.")
+            .addInfo(
+                EnumChatFormatting.AQUA + GT_Utility.formatNumbers(getSingleHatchPower())
+                    + EnumChatFormatting.GRAY
+                    + " EU/t and "
+                    + EnumChatFormatting.AQUA
+                    + GT_Utility.formatNumbers(capableStartupCanonical() / 32 / M)
+                    + "M"
+                    + EnumChatFormatting.GRAY
+                    + " EU capacity per Energy Hatch")
+            .addInfo("If the recipe has a startup cost greater than the")
+            .addInfo("number of energy hatches * cap, you can't do it")
+            .addInfo(
+                "If the recipe requires a voltage tier over " + GT_Utility.getColoredTierNameFromTier((byte) tier())
+                    + EnumChatFormatting.GRAY
+                    + " , you can't do it either")
+            .addInfo("Make sure the whole structure is built in the 3x3")
+            .addInfo("chunk area of the ring center (not controller).")
+            .addInfo("It can run 64x recipes at most.")
+            .addInfo(
+                "Support" + EnumChatFormatting.BLUE
+                    + " Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " Energy/Laser Hatches!")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addCasingInfo("LuV Machine Casing", 1664)
+            .addCasingInfo("Ameliorated Superconduct Coil", 560)
+            .addCasingInfo("Naquadah Alloy Frame Boxes", 128)
+            .addCasingInfo("Rhodium-Plated Palladium Reinforced Borosilicate Glass Block", 63)
+            .addEnergyHatch("1-32, Hint block with dot 2", 2)
+            .addInputHatch("1-16, Hint block with dot 1", 1)
+            .addOutputHatch("1-16, Hint block with dot 1", 1)
+            .addStructureInfo("Supports Crafting Input Buffer")
+            .addStructureInfo(
+                "ALL Hatches must be " + GT_Utility.getColoredTierNameFromTier((byte) hatchTier())
+                    + EnumChatFormatting.GRAY
+                    + " or better")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public int tier() {
+        return 6;
+    }
+
+    @Override
+    public long capableStartupCanonical() {
+        return 160_000_000;
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return GregTech_API.sBlockCasings1;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 6;
+    }
+
+    @Override
+    public Block getCoilBlock() {
+        return Loaders.compactFusionCoil;
+    }
+
+    @Override
+    public int getCoilMeta() {
+        return 0;
+    }
+
+    @Override
+    public Block getGlassBlock() {
+        return ItemRegistry.bw_realglas;
+    }
+
+    @Override
+    public int getGlassMeta() {
+        return 3;
+    }
+
+    @Override
+    public int hatchTier() {
+        return 6;
+    }
+
+    @Override
+    public Materials getFrameBox() {
+        return Materials.NaquadahAlloy;
+    }
+
+    @Override
+    public int getMaxPara() {
+        return 64;
+    }
+
+    @Override
+    public int extraPara(int startEnergy) {
+        return 1;
+    }
+
+    @Override
+    public ITexture getTextureOverlay() {
+        return textureOverlay;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("LargeFusion1.hint", 9);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new LargeFusionComputer1(mName);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer2.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer2.java
new file mode 100644
index 0000000000..7a72e7842f
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer2.java
@@ -0,0 +1,171 @@
+package goodgenerator.blocks.tileEntity;
+
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION2;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION2_GLOW;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+
+import goodgenerator.blocks.tileEntity.base.LargeFusionComputer;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+
+public class LargeFusionComputer2 extends LargeFusionComputer {
+
+    private static final ITexture textureOverlay = TextureFactory.of(
+        TextureFactory.builder()
+            .addIcon(OVERLAY_FUSION2)
+            .extFacing()
+            .build(),
+        TextureFactory.builder()
+            .addIcon(OVERLAY_FUSION2_GLOW)
+            .extFacing()
+            .glow()
+            .build());
+
+    public LargeFusionComputer2(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public LargeFusionComputer2(String name) {
+        super(name);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fusion Reactor")
+            .addInfo("Millions of nuclear.")
+            .addInfo("Controller block for the Compact Fusion Reactor MK-II.")
+            .addInfo(
+                EnumChatFormatting.AQUA + GT_Utility.formatNumbers(getSingleHatchPower())
+                    + EnumChatFormatting.GRAY
+                    + " EU/t and "
+                    + EnumChatFormatting.AQUA
+                    + GT_Utility.formatNumbers(capableStartupCanonical() / 32 / M)
+                    + "M"
+                    + EnumChatFormatting.GRAY
+                    + " EU capacity per Energy Hatch")
+            .addInfo("If the recipe has a startup cost greater than the")
+            .addInfo("number of energy hatches * cap, you can't do it")
+            .addInfo(
+                "If the recipe requires a voltage tier over " + GT_Utility.getColoredTierNameFromTier((byte) tier())
+                    + EnumChatFormatting.GRAY
+                    + " , you can't do it either")
+            .addInfo("Make sure the whole structure is built in the 3x3")
+            .addInfo("chunk area of the ring center (not controller).")
+            .addInfo("Startup < 160,000,000 EU: 128x Parallel")
+            .addInfo("Startup >= 160,000,000 EU: 64x Parallel")
+            .addInfo(
+                "Support" + EnumChatFormatting.BLUE
+                    + " Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " Energy/Laser Hatches!")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addCasingInfo("Fusion Machine Casing", 1664)
+            .addCasingInfo("Compact Fusion Coil", 560)
+            .addCasingInfo("Duranium Frame Box", 128)
+            .addCasingInfo("Iridium Reinforced Borosilicate Glass Block", 63)
+            .addEnergyHatch("1-32, Hint block with dot 2", 2)
+            .addInputHatch("1-16, Hint block with dot 1", 1)
+            .addOutputHatch("1-16, Hint block with dot 1", 1)
+            .addStructureInfo("Supports Crafting Input Buffer")
+            .addStructureInfo(
+                "ALL Hatches must be " + GT_Utility.getColoredTierNameFromTier((byte) hatchTier())
+                    + EnumChatFormatting.GRAY
+                    + " or better")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public int tier() {
+        return 7;
+    }
+
+    @Override
+    public long capableStartupCanonical() {
+        return 320_000_000;
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return GregTech_API.sBlockCasings4;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 6;
+    }
+
+    @Override
+    public Block getCoilBlock() {
+        return Loaders.compactFusionCoil;
+    }
+
+    @Override
+    public int getCoilMeta() {
+        return 1;
+    }
+
+    @Override
+    public Block getGlassBlock() {
+        return ItemRegistry.bw_realglas;
+    }
+
+    @Override
+    public int getGlassMeta() {
+        return 4;
+    }
+
+    @Override
+    public int hatchTier() {
+        return 7;
+    }
+
+    @Override
+    public Materials getFrameBox() {
+        return Materials.Duranium;
+    }
+
+    @Override
+    public int getMaxPara() {
+        return 64;
+    }
+
+    @Override
+    public int extraPara(int startEnergy) {
+        return startEnergy < 160000000 ? 2 : 1;
+    }
+
+    @Override
+    public ITexture getTextureOverlay() {
+        return textureOverlay;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("LargeFusion2.hint", 9);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new LargeFusionComputer2(mName);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer3.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer3.java
new file mode 100644
index 0000000000..4a4f9832d0
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer3.java
@@ -0,0 +1,172 @@
+package goodgenerator.blocks.tileEntity;
+
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION3;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION3_GLOW;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+
+import goodgenerator.blocks.tileEntity.base.LargeFusionComputer;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+
+public class LargeFusionComputer3 extends LargeFusionComputer {
+
+    private static final ITexture textureOverlay = TextureFactory.of(
+        TextureFactory.builder()
+            .addIcon(OVERLAY_FUSION3)
+            .extFacing()
+            .build(),
+        TextureFactory.builder()
+            .addIcon(OVERLAY_FUSION3_GLOW)
+            .extFacing()
+            .glow()
+            .build());
+
+    public LargeFusionComputer3(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public LargeFusionComputer3(String name) {
+        super(name);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fusion Reactor")
+            .addInfo("Millions of nuclear.")
+            .addInfo("Controller block for the Compact Fusion Reactor MK-III.")
+            .addInfo(
+                EnumChatFormatting.AQUA + GT_Utility.formatNumbers(getSingleHatchPower())
+                    + EnumChatFormatting.GRAY
+                    + " EU/t and "
+                    + EnumChatFormatting.AQUA
+                    + GT_Utility.formatNumbers(capableStartupCanonical() / 32 / M)
+                    + "M"
+                    + EnumChatFormatting.GRAY
+                    + " EU capacity per Energy Hatch")
+            .addInfo("If the recipe has a startup cost greater than the")
+            .addInfo("number of energy hatches * cap, you can't do it")
+            .addInfo(
+                "If the recipe requires a voltage tier over " + GT_Utility.getColoredTierNameFromTier((byte) tier())
+                    + EnumChatFormatting.GRAY
+                    + " , you can't do it either")
+            .addInfo("Make sure the whole structure is built in the 3x3")
+            .addInfo("chunk area of the ring center (not controller).")
+            .addInfo("Startup < 160,000,000 EU: 192x Parallel")
+            .addInfo("Startup < 320,000,000 EU: 128x Parallel")
+            .addInfo("Startup >= 320,000,000 EU: 64x Parallel")
+            .addInfo(
+                "Support" + EnumChatFormatting.BLUE
+                    + " Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " Energy/Laser Hatches!")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addCasingInfo("Fusion Machine Casing MK II", 1664)
+            .addCasingInfo("Advanced Compact Fusion Coil", 560)
+            .addCasingInfo("Neutronium Frame Box", 128)
+            .addCasingInfo("Osmium Reinforced Borosilicate Glass Block", 63)
+            .addEnergyHatch("1-32, Hint block with dot 2", 2)
+            .addInputHatch("1-16, Hint block with dot 1", 1)
+            .addOutputHatch("1-16, Hint block with dot 1", 1)
+            .addStructureInfo("Supports Crafting Input Buffer")
+            .addStructureInfo(
+                "ALL Hatches must be " + GT_Utility.getColoredTierNameFromTier((byte) hatchTier())
+                    + EnumChatFormatting.GRAY
+                    + " or better")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public int tier() {
+        return 8;
+    }
+
+    @Override
+    public long capableStartupCanonical() {
+        return 640_000_000;
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return GregTech_API.sBlockCasings4;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 8;
+    }
+
+    @Override
+    public Block getCoilBlock() {
+        return Loaders.compactFusionCoil;
+    }
+
+    @Override
+    public int getCoilMeta() {
+        return 2;
+    }
+
+    @Override
+    public Block getGlassBlock() {
+        return ItemRegistry.bw_realglas;
+    }
+
+    @Override
+    public int getGlassMeta() {
+        return 5;
+    }
+
+    @Override
+    public int hatchTier() {
+        return 8;
+    }
+
+    @Override
+    public Materials getFrameBox() {
+        return Materials.Neutronium;
+    }
+
+    @Override
+    public int getMaxPara() {
+        return 64;
+    }
+
+    @Override
+    public int extraPara(int startEnergy) {
+        return (startEnergy < 160000000 ? 3 : (startEnergy < 320000000 ? 2 : 1));
+    }
+
+    @Override
+    public ITexture getTextureOverlay() {
+        return textureOverlay;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("LargeFusion3.hint", 9);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new LargeFusionComputer3(mName);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java
new file mode 100644
index 0000000000..96a9662475
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java
@@ -0,0 +1,227 @@
+package goodgenerator.blocks.tileEntity;
+
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+
+import goodgenerator.blocks.tileEntity.base.LargeFusionComputerPP;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TAE;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.IDualInputHatch;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+
+public class LargeFusionComputer4 extends LargeFusionComputerPP {
+
+    public LargeFusionComputer4(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public LargeFusionComputer4(String name) {
+        super(name);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fusion Reactor")
+            .addInfo("Galaxy Collapse.")
+            .addInfo("Controller block for the Compact Fusion Reactor MK-IV Prototype.")
+            .addInfo(
+                EnumChatFormatting.AQUA + GT_Utility.formatNumbers(getSingleHatchPower())
+                    + EnumChatFormatting.GRAY
+                    + " EU/t and "
+                    + EnumChatFormatting.AQUA
+                    + GT_Utility.formatNumbers(capableStartupCanonical() / 32 / M)
+                    + "M"
+                    + EnumChatFormatting.GRAY
+                    + " EU capacity per Energy Hatch")
+            .addInfo("If the recipe has a startup cost greater than the")
+            .addInfo("number of energy hatches * cap, you can't do it")
+            .addInfo(
+                "If the recipe requires a voltage tier over " + GT_Utility.getColoredTierNameFromTier((byte) tier())
+                    + EnumChatFormatting.GRAY
+                    + " , you can't do it either")
+            .addInfo("Make sure the whole structure is built in the 3x3")
+            .addInfo("chunk area of the ring center (not controller).")
+            .addInfo("Performs 4/4 overclock.")
+            .addInfo("Startup < 160,000,000 EU: 256x Parallel")
+            .addInfo("Startup < 320,000,000 EU: 192x Parallel")
+            .addInfo("Startup < 640,000,000 EU: 128x Parallel")
+            .addInfo("Startup >= 640,000,000 EU: 64x Parallel")
+            .addInfo(
+                "Support" + EnumChatFormatting.BLUE
+                    + " Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " Energy/Laser Hatches!")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addCasingInfo("Fusion Machine Casing MK III", 1664)
+            .addCasingInfo("Compact Fusion Coil MK-II Prototype", 560)
+            .addCasingInfo("Infinity Catalyst Frame Box", 128)
+            .addCasingInfo("Neutronium Reinforced Borosilicate Glass Block", 63)
+            .addEnergyHatch("1-32, Hint block with dot 2", 2)
+            .addInputHatch("1-16, Hint block with dot 1", 1)
+            .addOutputHatch("1-16, Hint block with dot 1", 1)
+            .addStructureInfo("Supports Crafting Input Buffer")
+            .addStructureInfo(
+                "ALL Hatches must be " + GT_Utility.getColoredTierNameFromTier((byte) hatchTier())
+                    + EnumChatFormatting.GRAY
+                    + " or better")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public int tier() {
+        return 9;
+    }
+
+    @Override
+    public long capableStartupCanonical() {
+        return 5_120_000_000L;
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return ModBlocks.blockCasings3Misc;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 12;
+    }
+
+    @Override
+    public Block getCoilBlock() {
+        return Loaders.compactFusionCoil;
+    }
+
+    @Override
+    public int getCoilMeta() {
+        return 3;
+    }
+
+    @Override
+    public Block getGlassBlock() {
+        return ItemRegistry.bw_realglas;
+    }
+
+    @Override
+    public int getGlassMeta() {
+        return 13;
+    }
+
+    @Override
+    public int hatchTier() {
+        return 9;
+    }
+
+    @Override
+    public Materials getFrameBox() {
+        return Materials.InfinityCatalyst;
+    }
+
+    @Override
+    public ITexture getTextureOverlay() {
+        if (this.mMaxProgresstime > 0) return TextureFactory.of(
+            TextureFactory.builder()
+                .addIcon(TexturesGtBlock.Casing_Machine_Screen_3)
+                .extFacing()
+                .build());
+        else return TextureFactory.of(
+            TextureFactory.builder()
+                .addIcon(TexturesGtBlock.Casing_Machine_Screen_1)
+                .extFacing()
+                .build());
+    }
+
+    @Override
+    public int getMaxPara() {
+        return 64;
+    }
+
+    @Override
+    public int extraPara(int startEnergy) {
+        if (startEnergy < 160000000) return 4;
+        if (startEnergy < 320000000) return 3;
+        if (startEnergy < 640000000) return 2;
+        return 1;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("LargeFusion4.hint", 9);
+    }
+
+    @Override
+    public boolean turnCasingActive(boolean status) {
+        if (this.mEnergyHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53);
+            }
+        }
+        if (this.eEnergyMulti != null) {
+            for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53);
+            }
+        }
+        if (this.mOutputHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53);
+            }
+        }
+        if (this.mInputHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53);
+            }
+        }
+        if (this.mDualInputHatches != null) {
+            for (IDualInputHatch hatch : this.mDualInputHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) return new ITexture[] { TextureFactory.builder()
+            .addIcon(MACHINE_CASING_FUSION_GLASS)
+            .extFacing()
+            .build(), getTextureOverlay() };
+        if (!aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(52) };
+        return new ITexture[] { TextureFactory.builder()
+            .addIcon(TexturesGtBlock.TEXTURE_CASING_FUSION_CASING_ULTRA)
+            .extFacing()
+            .build() };
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new LargeFusionComputer4(mName);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java
new file mode 100644
index 0000000000..aa4766a01a
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java
@@ -0,0 +1,231 @@
+package goodgenerator.blocks.tileEntity;
+
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+
+import goodgenerator.blocks.tileEntity.base.LargeFusionComputerPP;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TAE;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.IDualInputHatch;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+
+public class LargeFusionComputer5 extends LargeFusionComputerPP {
+
+    public LargeFusionComputer5(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public LargeFusionComputer5(String name) {
+        super(name);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fusion Reactor")
+            .addInfo("Galaxy Collapse.")
+            .addInfo("Controller block for the Compact Fusion Reactor MK-V.")
+            .addInfo(
+                EnumChatFormatting.AQUA + GT_Utility.formatNumbers(getSingleHatchPower())
+                    + EnumChatFormatting.GRAY
+                    + " EU/t and "
+                    + EnumChatFormatting.AQUA
+                    + GT_Utility.formatNumbers(capableStartupCanonical() / 32 / M)
+                    + "M"
+                    + EnumChatFormatting.GRAY
+                    + " EU capacity per Energy Hatch")
+            .addInfo("If the recipe has a startup cost greater than the")
+            .addInfo("number of energy hatches * cap, you can't do it")
+            .addInfo(
+                "If the recipe requires a voltage tier over " + GT_Utility.getColoredTierNameFromTier((byte) tier())
+                    + EnumChatFormatting.GRAY
+                    + " , you can't do it either")
+            .addInfo("Make sure the whole structure is built in the 3x3")
+            .addInfo("chunk area of the ring center (not controller).")
+            .addInfo("Performs 4/4 overclock.")
+            .addInfo("Startup < 160,000,000 EU: 320x Parallel")
+            .addInfo("Startup < 320,000,000 EU: 256x Parallel")
+            .addInfo("Startup < 640,000,000 EU: 192x Parallel")
+            .addInfo("Startup < 1,200,000,000 EU: 128x Parallel")
+            .addInfo("Startup >= 1,200,000,000 EU: 64x Parallel")
+            .addInfo(
+                "Support" + EnumChatFormatting.BLUE
+                    + " Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " Energy/Laser Hatches!")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addCasingInfo("Fusion Machine Casing MK IV", 1664)
+            .addCasingInfo("Compact Fusion Coil MK-II Finaltype", 560)
+            .addCasingInfo("Infinity Frame Box", 128)
+            .addCasingInfo("Cosmic Neutronium Reinforced Borosilicate Glass Block", 63)
+            .addEnergyHatch("1-32, Hint block with dot 2", 2)
+            .addInputHatch("1-16, Hint block with dot 1", 1)
+            .addOutputHatch("1-16, Hint block with dot 1", 1)
+            .addStructureInfo("Supports Crafting Input Buffer")
+            .addStructureInfo(
+                "ALL Hatches must be " + GT_Utility.getColoredTierNameFromTier((byte) hatchTier())
+                    + EnumChatFormatting.GRAY
+                    + " or better")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public int tier() {
+        return 10;
+    }
+
+    @Override
+    public long capableStartupCanonical() {
+        return 20_480_000_000L;
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return ModBlocks.blockCasings6Misc;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 0;
+    }
+
+    @Override
+    public Block getCoilBlock() {
+        return Loaders.compactFusionCoil;
+    }
+
+    @Override
+    public int getCoilMeta() {
+        return 4;
+    }
+
+    @Override
+    public Block getGlassBlock() {
+        return ItemRegistry.bw_realglas;
+    }
+
+    @Override
+    public int getGlassMeta() {
+        return 14;
+    }
+
+    @Override
+    public int hatchTier() {
+        return 10;
+    }
+
+    @Override
+    public Materials getFrameBox() {
+        return Materials.Infinity;
+    }
+
+    @Override
+    public ITexture getTextureOverlay() {
+        if (this.getBaseMetaTileEntity()
+            .isActive())
+            return TextureFactory.of(
+                TextureFactory.builder()
+                    .addIcon(TexturesGtBlock.Casing_Machine_Screen_Rainbow)
+                    .extFacing()
+                    .build());
+        else return TextureFactory.of(
+            TextureFactory.builder()
+                .addIcon(TexturesGtBlock.Casing_Machine_Screen_1)
+                .extFacing()
+                .build());
+    }
+
+    @Override
+    public int getMaxPara() {
+        return 64;
+    }
+
+    @Override
+    public int extraPara(int startEnergy) {
+        if (startEnergy < 160000000) return 5;
+        if (startEnergy < 320000000) return 4;
+        if (startEnergy < 640000000) return 3;
+        if (startEnergy < 1200000000) return 2;
+        return 1;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("LargeFusion5.hint", 9);
+    }
+
+    @Override
+    public boolean turnCasingActive(boolean status) {
+        if (this.mEnergyHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(3, 6) : 53);
+            }
+        }
+        if (this.eEnergyMulti != null) {
+            for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(3, 6) : 53);
+            }
+        }
+        if (this.mOutputHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(3, 6) : 53);
+            }
+        }
+        if (this.mInputHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(3, 6) : 53);
+            }
+        }
+        if (this.mDualInputHatches != null) {
+            for (IDualInputHatch hatch : this.mDualInputHatches) {
+                hatch.updateTexture(status ? TAE.getIndexFromPage(3, 6) : 53);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) return new ITexture[] { TextureFactory.builder()
+            .addIcon(MACHINE_CASING_FUSION_GLASS)
+            .extFacing()
+            .build(), getTextureOverlay() };
+        if (!aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(52) };
+        return new ITexture[] { TextureFactory.builder()
+            .addIcon(TexturesGtBlock.TEXTURE_CASING_FUSION_CASING_HYPER)
+            .extFacing()
+            .build() };
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new LargeFusionComputer5(mName);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java
new file mode 100644
index 0000000000..cd53c48974
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java
@@ -0,0 +1,471 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.main.GG_Config_Loader.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.bartimaeusnek.bartworks.util.Pair;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.items.MyMaterial;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.CrackRecipeAdder;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+
+public class MultiNqGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    protected IStructureDefinition<MultiNqGenerator> multiDefinition = null;
+    protected long leftEnergy = 0;
+    protected long trueOutput = 0;
+    protected int trueEff = 0;
+    protected FluidStack lockedFluid = null;
+    protected int times = 1;
+    protected int basicOutput;
+
+    private static final List<Pair<FluidStack, Integer>> excitedLiquid;
+
+    private static final List<Pair<FluidStack, Integer>> coolant;
+
+    static {
+        excitedLiquid = Arrays.asList(
+            new Pair<>(MaterialsUEVplus.Space.getMolten(20L), ExcitedLiquidCoe[0]),
+            new Pair<>(MyMaterial.atomicSeparationCatalyst.getMolten(20), ExcitedLiquidCoe[1]),
+            new Pair<>(Materials.Naquadah.getMolten(20L), ExcitedLiquidCoe[2]),
+            new Pair<>(Materials.Uranium235.getMolten(180L), ExcitedLiquidCoe[3]),
+            new Pair<>(Materials.Caesium.getMolten(180L), ExcitedLiquidCoe[4]));
+        coolant = Arrays.asList(
+            new Pair<>(MaterialsUEVplus.Time.getMolten(20L), CoolantEfficiency[0]),
+            new Pair<>(FluidRegistry.getFluidStack("cryotheum", 1000), CoolantEfficiency[1]),
+            new Pair<>(Materials.SuperCoolant.getFluid(1000L), CoolantEfficiency[2]),
+            new Pair<>(FluidRegistry.getFluidStack("ic2coolant", 1000), CoolantEfficiency[3]));
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean hintsOnly) {
+        structureBuild_EM(mName, 3, 7, 0, itemStack, hintsOnly);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("MultiNqGenerator.hint", 8);
+    }
+
+    public final boolean addToGeneratorList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity == null) {
+                return false;
+            } else {
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch) {
+                    ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                }
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+                    return this.mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+                    return this.mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Dynamo) {
+                    return this.mDynamoHatches.add((GT_MetaTileEntity_Hatch_Dynamo) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) {
+                    return this.mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoMulti) {
+                    return this.eDynamoMulti.add((GT_MetaTileEntity_Hatch_DynamoMulti) aMetaTileEntity);
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+
+    @Override
+    public IStructureDefinition<MultiNqGenerator> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<MultiNqGenerator>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] {
+                            { "AAAAAAA", "AAAAAAA", "AAAAAAA", "AAAAAAA", "AAAAAAA", "AAAAAAA", "AAAAAAA" },
+                            { "N     N", "       ", "  CCC  ", "  CPC  ", "  CCC  ", "       ", "N     N" },
+                            { "N     N", "       ", "  CCC  ", "  CPC  ", "  CCC  ", "       ", "N     N" },
+                            { "N     N", "       ", "  CCC  ", "  CPC  ", "  CCC  ", "       ", "N     N" },
+                            { "N     N", "       ", "  CCC  ", "  CPC  ", "  CCC  ", "       ", "N     N" },
+                            { "AAAAAAA", "A     A", "A CCC A", "A CPC A", "A CCC A", "A     A", "AAAAAAA" },
+                            { "ANNNNNA", "N     N", "N CCC N", "N CPC N", "N CCC N", "N     N", "ANNNNNA" },
+                            { "XXX~XXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX" }, }))
+                .addElement(
+                    'X',
+                    ofChain(
+                        buildHatchAdder(MultiNqGenerator.class)
+                            .atLeast(
+                                HatchElement.DynamoMulti.or(GT_HatchElement.Dynamo),
+                                GT_HatchElement.InputHatch,
+                                GT_HatchElement.OutputHatch,
+                                GT_HatchElement.Maintenance)
+                            .casingIndex(44)
+                            .dot(1)
+                            .build(),
+                        ofBlock(GregTech_API.sBlockCasings3, 12)))
+                .addElement('A', ofBlock(GregTech_API.sBlockCasings3, 12))
+                .addElement('N', ofBlock(Loaders.radiationProtectionSteelFrame, 0))
+                .addElement('C', ofBlock(Loaders.MAR_Casing, 0))
+                .addElement('P', ofBlock(GregTech_API.sBlockCasings2, 15))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    public MultiNqGenerator(String name) {
+        super(name);
+    }
+
+    public MultiNqGenerator(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        this.times = aNBT.getInteger("mTimes");
+        this.leftEnergy = aNBT.getLong("mLeftEnergy");
+        this.basicOutput = aNBT.getInteger("mbasicOutput");
+        if (FluidRegistry.getFluid(aNBT.getString("mLockedFluidName")) != null) this.lockedFluid = new FluidStack(
+            FluidRegistry.getFluid(aNBT.getString("mLockedFluidName")),
+            aNBT.getInteger("mLockedFluidAmount"));
+        else this.lockedFluid = null;
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("mTimes", this.times);
+        aNBT.setLong("mLeftEnergy", this.leftEnergy);
+        aNBT.setInteger("mbasicOutput", this.basicOutput);
+        if (lockedFluid != null) {
+            aNBT.setString(
+                "mLockedFluidName",
+                this.lockedFluid.getFluid()
+                    .getName());
+            aNBT.setInteger("mLockedFluidAmount", this.lockedFluid.amount);
+        }
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return GoodGeneratorRecipeMaps.naquadahReactorFuels;
+    }
+
+    @Override
+    protected boolean filtersFluid() {
+        return false;
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing_EM() {
+
+        ArrayList<FluidStack> tFluids = getStoredFluids();
+        for (int i = 0; i < tFluids.size() - 1; i++) {
+            for (int j = i + 1; j < tFluids.size(); j++) {
+                if (GT_Utility.areFluidsEqual(tFluids.get(i), tFluids.get(j))) {
+                    if ((tFluids.get(i)).amount >= (tFluids.get(j)).amount) {
+                        tFluids.remove(j--);
+                    } else {
+                        tFluids.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+
+        GT_Recipe tRecipe = GoodGeneratorRecipeMaps.naquadahReactorFuels
+            .findRecipe(this.getBaseMetaTileEntity(), true, 1 << 30, tFluids.toArray(new FluidStack[0]));
+        if (tRecipe != null) {
+            Pair<FluidStack, Integer> excitedInfo = getExcited(tFluids.toArray(new FluidStack[0]), false);
+            int pall = excitedInfo == null ? 1 : excitedInfo.getValue();
+            if (consumeFuel(
+                CrackRecipeAdder.copyFluidWithAmount(tRecipe.mFluidInputs[0], pall),
+                tFluids.toArray(new FluidStack[0]))) {
+                mOutputFluids = new FluidStack[] {
+                    CrackRecipeAdder.copyFluidWithAmount(tRecipe.mFluidOutputs[0], pall) };
+                basicOutput = tRecipe.mSpecialValue;
+                times = pall;
+                lockedFluid = excitedInfo == null ? null : excitedInfo.getKey();
+                mMaxProgresstime = tRecipe.mDuration;
+                return CheckRecipeResultRegistry.GENERATING;
+            }
+        }
+
+        return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack stack) {
+        if (this.getBaseMetaTileEntity()
+            .isServerSide()) {
+            if (mMaxProgresstime != 0 && mProgresstime % 20 == 0) {
+                // If there's no startRecipeProcessing, ME input hatch wouldn't work
+                startRecipeProcessing();
+                FluidStack[] input = getStoredFluids().toArray(new FluidStack[0]);
+                int time = 1;
+                if (LiquidAirConsumptionPerSecond != 0
+                    && !consumeFuel(Materials.LiquidAir.getFluid(LiquidAirConsumptionPerSecond), input)) {
+                    this.mEUt = 0;
+                    this.trueEff = 0;
+                    this.trueOutput = 0;
+                    endRecipeProcessing();
+                    return true;
+                }
+                int eff = consumeCoolant(input);
+                if (consumeFuel(lockedFluid, input)) time = times;
+                this.mEUt = basicOutput * eff * time / 100;
+                this.trueEff = eff;
+                this.trueOutput = (long) basicOutput * (long) eff * (long) time / 100;
+                endRecipeProcessing();
+            }
+            addAutoEnergy(trueOutput);
+        }
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        String[] info = super.getInfoData();
+        info[4] = "Probably makes: " + EnumChatFormatting.RED
+            + GT_Utility.formatNumbers(Math.abs(this.trueOutput))
+            + EnumChatFormatting.RESET
+            + " EU/t";
+        info[6] = "Problems: " + EnumChatFormatting.RED
+            + (this.getIdealStatus() - this.getRepairStatus())
+            + EnumChatFormatting.RESET
+            + " Efficiency: "
+            + EnumChatFormatting.YELLOW
+            + trueEff
+            + EnumChatFormatting.RESET
+            + " %";
+        return info;
+    }
+
+    public boolean consumeFuel(FluidStack target, FluidStack[] input) {
+        if (target == null) return false;
+        for (FluidStack inFluid : input) {
+            if (inFluid != null && inFluid.isFluidEqual(target) && inFluid.amount >= target.amount) {
+                inFluid.amount -= target.amount;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public Pair<FluidStack, Integer> getExcited(FluidStack[] input, boolean isConsume) {
+        for (Pair<FluidStack, Integer> fluidPair : excitedLiquid) {
+            FluidStack tFluid = fluidPair.getKey();
+            for (FluidStack inFluid : input) {
+                if (inFluid != null && inFluid.isFluidEqual(tFluid) && inFluid.amount >= tFluid.amount) {
+                    if (isConsume) inFluid.amount -= tFluid.amount;
+                    return fluidPair;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Finds valid coolant from given inputs and consumes if found.
+     *
+     * @param input Fluid inputs.
+     * @return Efficiency of the coolant. 100 if not found.
+     */
+    private int consumeCoolant(FluidStack[] input) {
+        for (Pair<FluidStack, Integer> fluidPair : coolant) {
+            FluidStack tFluid = fluidPair.getKey();
+            for (FluidStack inFluid : input) {
+                if (inFluid != null && inFluid.isFluidEqual(tFluid) && inFluid.amount >= tFluid.amount) {
+                    inFluid.amount -= tFluid.amount;
+                    return fluidPair.getValue();
+                }
+            }
+        }
+        return 100;
+    }
+
+    public void addAutoEnergy(long outputPower) {
+        if (this.eDynamoMulti.size() > 0) for (GT_MetaTileEntity_Hatch tHatch : this.eDynamoMulti) {
+            long voltage = tHatch.maxEUOutput();
+            long power = voltage * tHatch.maxAmperesOut();
+            long outputAmperes;
+            if (outputPower > power) doExplosion(8 * GT_Utility.getTier(power));
+            if (outputPower >= voltage) {
+                leftEnergy += outputPower;
+                outputAmperes = leftEnergy / voltage;
+                leftEnergy -= outputAmperes * voltage;
+                addEnergyOutput_EM(voltage, outputAmperes);
+            } else {
+                addEnergyOutput_EM(outputPower, 1);
+            }
+        }
+        if (this.mDynamoHatches.size() > 0) for (GT_MetaTileEntity_Hatch tHatch : this.mDynamoHatches) {
+            long voltage = tHatch.maxEUOutput();
+            long power = voltage * tHatch.maxAmperesOut();
+            long outputAmperes;
+            if (outputPower > power) doExplosion(8 * GT_Utility.getTier(power));
+            if (outputPower >= voltage) {
+                leftEnergy += outputPower;
+                outputAmperes = leftEnergy / voltage;
+                leftEnergy -= outputAmperes * voltage;
+                addEnergyOutput_EM(voltage, outputAmperes);
+            } else {
+                addEnergyOutput_EM(outputPower, 1);
+            }
+        }
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return structureCheck_EM(mName, 3, 7, 0) && mMaintenanceHatches.size() == 1
+            && mDynamoHatches.size() + eDynamoMulti.size() == 1;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MultiNqGenerator(this.mName);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Naquadah Reactor")
+            .addInfo("Controller block for the Naquadah Reactor")
+            .addInfo("Environmentally Friendly!")
+            .addInfo("Generate power from high-energy liquids.")
+            .addInfo(
+                String.format(
+                    "Consumes %d L/s Liquid Air to keep running, otherwise" + EnumChatFormatting.YELLOW
+                        + " it will void your fuel"
+                        + EnumChatFormatting.GRAY
+                        + ".",
+                    LiquidAirConsumptionPerSecond))
+            .addInfo("Input liquid nuclear fuel or liquid naquadah fuel.")
+            .addInfo(
+                "The reactor will explode when there is more than" + EnumChatFormatting.RED
+                    + " ONE"
+                    + EnumChatFormatting.GRAY
+                    + " type of fuel in hatches!")
+            .addInfo("Can consume 1000L/s of coolant to increase efficiency:")
+            .addInfo(
+                String.format(
+                    "IC2 Coolant %d%%, Super Coolant %d%%, Cryotheum %d%%, Tachyon Rich Temporal Fluid %d%%",
+                    CoolantEfficiency[3],
+                    CoolantEfficiency[2],
+                    CoolantEfficiency[1],
+                    CoolantEfficiency[0]))
+            .addInfo("Can consume excited liquid to increase the output power and fuel usage:")
+            .addInfo(String.format("Molten Caesium | %dx power | 180 L/s ", ExcitedLiquidCoe[4]))
+            .addInfo(String.format("Molten Uranium-235 | %dx power | 180 L/s", ExcitedLiquidCoe[3]))
+            .addInfo(String.format("Molten Naquadah | %dx power | 20 L/s", ExcitedLiquidCoe[2]))
+            .addInfo(String.format("Molten Atomic Separation Catalyst | %dx power | 20 L/s", ExcitedLiquidCoe[1]))
+            .addInfo(String.format("Spatially Enlarged Fluid | %dx power | 20 L/s", ExcitedLiquidCoe[0]))
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .beginStructureBlock(7, 8, 7, true)
+            .addController("Front bottom")
+            .addDynamoHatch("Any bottom layer casing, only accept ONE!")
+            .addInputHatch("Any bottom layer casing")
+            .addOutputHatch("Any bottom layer casing")
+            .addMaintenanceHatch("Any bottom layer casing")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    @SuppressWarnings("ALL")
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(44),
+                new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE),
+                TextureFactory.builder()
+                    .addIcon(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE_GLOW)
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(44),
+                new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_FRONT) };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(44) };
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 3, 7, 0, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java
new file mode 100644
index 0000000000..f3a4fd7d3c
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java
@@ -0,0 +1,515 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizons.modularui.api.NumberFormatMUI;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator;
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronSensor;
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import goodgenerator.util.ItemRefer;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IHatchElement;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.multitileentity.multiblock.casing.Glasses;
+import gregtech.api.objects.XSTR;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.IGT_HatchAdder;
+
+public class NeutronActivator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    protected static IStructureDefinition<NeutronActivator> multiDefinition = null;
+    protected final ArrayList<NeutronAccelerator> mNeutronAccelerator = new ArrayList<>();
+    protected final ArrayList<NeutronSensor> mNeutronSensor = new ArrayList<>();
+    protected int casingAmount = 0;
+    protected int height = 0;
+    protected int eV = 0, mCeil = 0, mFloor = 0;
+    private GT_Recipe lastRecipe;
+    protected static final NumberFormatMUI numberFormat;
+    static {
+        numberFormat = new NumberFormatMUI();
+        numberFormat.setMinimumFractionDigits(2);
+        numberFormat.setMaximumFractionDigits(2);
+    }
+    final XSTR R = new XSTR();
+
+    private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("icons/NeutronActivator_On");
+    private static final IIconContainer textureFontOn_Glow = new Textures.BlockIcons.CustomIcon(
+        "icons/NeutronActivator_On_GLOW");
+    private static final IIconContainer textureFontOff = new Textures.BlockIcons.CustomIcon(
+        "icons/NeutronActivator_Off");
+    private static final IIconContainer textureFontOff_Glow = new Textures.BlockIcons.CustomIcon(
+        "icons/NeutronActivator_Off_GLOW");
+
+    protected final String NA_BOTTOM = mName + "buttom";
+    protected final String NA_MID = mName + "mid";
+    protected final String NA_TOP = mName + "top";
+
+    public NeutronActivator(String name) {
+        super(name);
+    }
+
+    public NeutronActivator(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return GT_OverclockCalculator.ofNoOverclock(recipe)
+                    .setDuration((int) Math.ceil(recipe.mDuration * Math.pow(0.9f, height - 4)))
+                    .setDurationUnderOneTickSupplier(() -> recipe.mDuration * Math.pow(0.9f, height - 4));
+            }
+
+            @NotNull
+            @Override
+            public CheckRecipeResult process() {
+                CheckRecipeResult result = super.process();
+                if (!result.wasSuccessful()) {
+                    return result;
+                }
+                mFloor = (lastRecipe.mSpecialValue % 10000) * 1000000;
+                mCeil = (lastRecipe.mSpecialValue / 10000) * 1000000;
+                if (eV > mCeil || eV < mFloor) {
+                    setOutputItems(ItemRefer.Radioactive_Waste.get(4));
+                }
+                // NA does not consume power, its hatches do. Set it to 0 to be sure
+                calculatedEut = 0;
+                return result;
+            }
+        };
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        // NA does not use power, to prevent GT_ParallelHelper from failing we trick it into thinking
+        // we have infinite power
+        logic.setAvailableVoltage(Long.MAX_VALUE);
+        logic.setAvailableAmperage(1);
+    }
+
+    @Override
+    public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
+        float aX, float aY, float aZ) {
+        batchMode = !batchMode;
+        if (batchMode) {
+            GT_Utility.sendChatToPlayer(aPlayer, StatCollector.translateToLocal("misc.BatchModeTextOn"));
+        } else {
+            GT_Utility.sendChatToPlayer(aPlayer, StatCollector.translateToLocal("misc.BatchModeTextOff"));
+        }
+        return true;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        eV = aNBT.getInteger("mKeV");
+        mCeil = aNBT.getInteger("mCeil");
+        mFloor = aNBT.getInteger("mFloor");
+        height = aNBT.getInteger("height");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("mKeV", eV);
+        aNBT.setInteger("mCeil", mCeil);
+        aNBT.setInteger("mFloor", mFloor);
+        aNBT.setInteger("height", height);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return GoodGeneratorRecipeMaps.neutronActivatorRecipes;
+    }
+
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Neutron Activator")
+            .addInfo("Controller block for the Neutron Activator")
+            .addInfo("Superluminal-velocity Motion.")
+            .addInfo("The minimum height of the Speeding Pipe Casing is 4.")
+            .addInfo("Per extra Speeding Pipe Casing will give time discount.")
+            .addInfo("But it will reduce the Neutron Accelerator efficiency.")
+            .addInfo("You need to input energy to the Neutron Accelerator to get it running.")
+            .addInfo("It will output correct products with Specific Neutron Kinetic Energy.")
+            .addInfo("Otherwise it will output trash.")
+            .addInfo("The Neutron Kinetic Energy will decrease 72KeV/s when no Neutron Accelerator is running.")
+            .addInfo(
+                "It will explode when the Neutron Kinetic Energy is over" + EnumChatFormatting.RED
+                    + " 1200MeV"
+                    + EnumChatFormatting.GRAY
+                    + ".")
+            .addInfo("Inputting Graphite/Beryllium dust can reduce 10MeV per dust immediately.")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addController("Front bottom")
+            .addInputHatch("Hint block with dot 1")
+            .addInputBus("Hint block with dot 1")
+            .addOutputHatch("Hint block with dot 2")
+            .addOutputBus("Hint block with dot 2")
+            .addMaintenanceHatch("Hint block with dot 2")
+            .addOtherStructurePart("Neutron Accelerator", "Hint block with dot 2")
+            .addOtherStructurePart("Neutron Sensor", "Hint block with dot 2")
+            .addCasingInfoRange("Clean Stainless Steel Machine Casing", 7, 31, false)
+            .addCasingInfoExactly("Processor Machine Casing", 18, false)
+            .addCasingInfoMin("Steel Frame Box", 16, false)
+            .addCasingInfoMin("Speeding Pipe Casing", 4, false)
+            .addCasingInfoMin("EV+ Glass", 32, false)
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public IStructureDefinition<NeutronActivator> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<NeutronActivator>builder()
+                .addShape(NA_TOP, transpose(new String[][] { { "CCCCC", "CDDDC", "CDDDC", "CDDDC", "CCCCC" } }))
+                .addShape(NA_MID, transpose(new String[][] { { "F   F", " GGG ", " GPG ", " GGG ", "F   F" } }))
+                .addShape(NA_BOTTOM, transpose(new String[][] { { "XX~XX", "XDDDX", "XDDDX", "XDDDX", "XXXXX" } }))
+                .addElement(
+                    'C',
+                    ofChain(
+                        buildHatchAdder(NeutronActivator.class)
+                            .atLeast(GT_HatchElement.InputHatch, GT_HatchElement.InputBus, GT_HatchElement.Maintenance)
+                            .casingIndex(49)
+                            .dot(1)
+                            .build(),
+                        onElementPass(NeutronActivator::onCasingFound, ofBlock(GregTech_API.sBlockCasings4, 1))))
+                .addElement('D', ofBlock(GregTech_API.sBlockCasings2, 6))
+                .addElement('F', ofFrame(Materials.Steel))
+                .addElement('G', Glasses.chainAllGlasses())
+                .addElement('P', ofBlock(Loaders.speedingPipe, 0))
+                .addElement(
+                    'X',
+                    ofChain(
+                        buildHatchAdder(NeutronActivator.class)
+                            .atLeast(
+                                GT_HatchElement.OutputHatch,
+                                GT_HatchElement.OutputBus,
+                                GT_HatchElement.Maintenance,
+                                NeutronHatchElement.NeutronAccelerator,
+                                NeutronHatchElement.NeutronSensor)
+                            .casingIndex(49)
+                            .dot(2)
+                            .build(),
+                        onElementPass(NeutronActivator::onCasingFound, ofBlock(GregTech_API.sBlockCasings4, 1))))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    @Override
+    protected void clearHatches_EM() {
+        super.clearHatches_EM();
+        this.mNeutronAccelerator.clear();
+        this.mNeutronSensor.clear();
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        this.casingAmount = 0;
+        if (!structureCheck_EM(NA_BOTTOM, 2, 0, 0)) return false;
+        height = 0;
+        while (structureCheck_EM(NA_MID, 2, height + 1, 0)) {
+            height++;
+        }
+        if (height < 4) return false;
+        return structureCheck_EM(NA_TOP, 2, height + 1, 0) && casingAmount >= 7;
+    }
+
+    public final boolean addAcceleratorAndSensor(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof NeutronAccelerator) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mNeutronAccelerator.add((NeutronAccelerator) aMetaTileEntity);
+            } else if (aMetaTileEntity instanceof NeutronSensor) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mNeutronSensor.add((NeutronSensor) aMetaTileEntity);
+            }
+        }
+        return false;
+    }
+
+    public int maxNeutronKineticEnergy() {
+        return 1200000000;
+    }
+
+    public int getCurrentNeutronKineticEnergy() {
+        return eV;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    public boolean protectsExcessItem() {
+        return !eSafeVoid;
+    }
+
+    @Override
+    public boolean protectsExcessFluid() {
+        return !eSafeVoid;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new NeutronActivator(this.mName);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        boolean anyWorking = false;
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (this.eV > 0 && (aTick % 20 == 0 || eV > mCeil)) {
+                tryUseModerator();
+            }
+
+            for (NeutronAccelerator tHatch : mNeutronAccelerator) {
+                if (tHatch.getBaseMetaTileEntity()
+                    .isActive() && this.getRepairStatus() == this.getIdealStatus()) {
+                    anyWorking = true;
+                    this.eV += Math.max(
+                        (R.nextInt(tHatch.getMaxEUConsume() + 1) + tHatch.getMaxEUConsume()) * 10
+                            * Math.pow(0.95, height - 4),
+                        10);
+                }
+            }
+            if (!anyWorking) {
+                if (this.eV >= 72000 && aTick % 20 == 0) {
+                    this.eV -= 72000;
+                } else if (this.eV > 0 && aTick % 20 == 0) {
+                    this.eV = 0;
+                }
+            }
+            if (this.eV < 0) this.eV = 0;
+            if (this.eV > maxNeutronKineticEnergy()) doExplosion(4 * 32);
+
+            for (NeutronSensor tHatch : mNeutronSensor) {
+                tHatch.updateRedstoneOutput(this.eV);
+            }
+
+            if (mProgresstime < mMaxProgresstime && (eV > mCeil || eV < mFloor)) {
+                this.mOutputFluids = null;
+                this.mOutputItems = new ItemStack[] { ItemRefer.Radioactive_Waste.get(4) };
+            }
+        }
+    }
+
+    private void tryUseModerator() {
+        startRecipeProcessing();
+        for (ItemStack input : getStoredInputs()) {
+            if (input.isItemEqual(Materials.Graphite.getDust(1)) || input.isItemEqual(Materials.Beryllium.getDust(1))) {
+                int consume = Math.min(this.eV / 10000000, input.stackSize);
+                depleteInput(GT_Utility.copyAmount(consume, input));
+                this.eV -= 10000000 * consume;
+            }
+        }
+        endRecipeProcessing();
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        structureBuild_EM(NA_BOTTOM, 2, 0, 0, stackSize, hintsOnly);
+        int heights = stackSize.stackSize + 3;
+        structureBuild_EM(NA_TOP, 2, heights + 1, 0, stackSize, hintsOnly);
+        while (heights > 0) {
+            structureBuild_EM(NA_MID, 2, heights, 0, stackSize, hintsOnly);
+            heights--;
+        }
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("NeutronActivator.hint", 7);
+    }
+
+    @Override
+    public String[] getInfoData() {
+        int currentNKEInput = 0;
+        boolean anyWorking = false;
+        for (NeutronAccelerator tHatch : mNeutronAccelerator) {
+            if (tHatch.getBaseMetaTileEntity()
+                .isActive()) {
+                currentNKEInput += (R.nextInt(tHatch.getMaxEUConsume() + 1) + tHatch.getMaxEUConsume()) * 10
+                    * Math.pow(0.95, height - 4);
+                anyWorking = true;
+            }
+        }
+        if (!anyWorking) currentNKEInput = -72000;
+        return new String[] { "Progress:",
+            EnumChatFormatting.GREEN + Integer.toString(this.mProgresstime / 20)
+                + EnumChatFormatting.RESET
+                + " s / "
+                + EnumChatFormatting.YELLOW
+                + this.mMaxProgresstime / 20
+                + EnumChatFormatting.RESET
+                + " s",
+            "Current Neutron Kinetic Energy Input: " + EnumChatFormatting.GREEN
+                + GT_Utility.formatNumbers(currentNKEInput)
+                + EnumChatFormatting.RESET
+                + "eV",
+            StatCollector.translateToLocal("scanner.info.NA") + " "
+                + EnumChatFormatting.LIGHT_PURPLE
+                + GT_Utility.formatNumbers(getCurrentNeutronKineticEnergy())
+                + EnumChatFormatting.RESET
+                + "eV" };
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(49),
+                TextureFactory.of(textureFontOn), TextureFactory.builder()
+                    .addIcon(textureFontOn_Glow)
+                    .glow()
+                    .build() };
+            else return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(49),
+                TextureFactory.of(textureFontOff), TextureFactory.builder()
+                    .addIcon(textureFontOff_Glow)
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(49) };
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+
+        int built = survivialBuildPiece(NA_BOTTOM, stackSize, 2, 0, 0, elementBudget, env, false, true);
+        if (built >= 0) return built;
+        int heights = stackSize.stackSize + 3;
+        for (int i = 1; i <= heights; i++) {
+            built = survivialBuildPiece(NA_MID, stackSize, 2, i, 0, elementBudget, env, false, true);
+            if (built >= 0) return built;
+        }
+        return survivialBuildPiece(NA_TOP, stackSize, 2, heights + 1, 0, elementBudget, env, false, true);
+    }
+
+    protected void onCasingFound() {
+        casingAmount++;
+    }
+
+    @Override
+    protected void drawTexts(DynamicPositionedColumn screenElements, SlotWidget inventorySlot) {
+        super.drawTexts(screenElements, inventorySlot);
+
+        screenElements
+            .widget(
+                new TextWidget(StatCollector.translateToLocal("gui.NeutronActivator.0"))
+                    .setDefaultColor(COLOR_TEXT_WHITE.get()))
+            .widget(
+                new TextWidget().setStringSupplier(() -> numberFormat.format(eV / 1_000_000d) + " MeV")
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.IntegerSyncer(() -> eV, val -> eV = val));
+    }
+
+    private enum NeutronHatchElement implements IHatchElement<NeutronActivator> {
+
+        NeutronSensor(NeutronActivator::addAcceleratorAndSensor, NeutronSensor.class) {
+
+            @Override
+            public long count(NeutronActivator t) {
+                return t.mNeutronSensor.size();
+            }
+        },
+        NeutronAccelerator(NeutronActivator::addAcceleratorAndSensor, NeutronAccelerator.class) {
+
+            @Override
+            public long count(NeutronActivator t) {
+                return t.mNeutronAccelerator.size();
+            }
+        };
+
+        private final List<Class<? extends IMetaTileEntity>> mteClasses;
+        private final IGT_HatchAdder<NeutronActivator> adder;
+
+        @SafeVarargs
+        NeutronHatchElement(IGT_HatchAdder<NeutronActivator> adder, Class<? extends IMetaTileEntity>... mteClasses) {
+            this.mteClasses = Collections.unmodifiableList(Arrays.asList(mteClasses));
+            this.adder = adder;
+        }
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return mteClasses;
+        }
+
+        public IGT_HatchAdder<? super NeutronActivator> adder() {
+            return adder;
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java
new file mode 100644
index 0000000000..610716fc8a
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java
@@ -0,0 +1,491 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.github.bartimaeusnek.bartworks.util.BW_Util.ofGlassTieredMixed;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.GT_HatchElement.*;
+import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
+import static gregtech.api.util.GT_Utility.filterValidMTEs;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizon.structurelib.structure.StructureUtility;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget;
+
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+import goodgenerator.client.GUI.GG_UITextures;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.GregTechTileClientEvents;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBus;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_HatchElementBuilder;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.IDualInputHatch;
+
+public class PreciseAssembler extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<PreciseAssembler>
+    implements IConstructable, ISurvivalConstructable {
+
+    private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QTANK");
+    private static final IIconContainer textureFontOn_Glow = new Textures.BlockIcons.CustomIcon(
+        "iconsets/OVERLAY_QTANK_GLOW");
+    private static final IIconContainer textureFontOff = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QCHEST");
+    private static final IIconContainer textureFontOff_Glow = new Textures.BlockIcons.CustomIcon(
+        "iconsets/OVERLAY_QCHEST_GLOW");
+
+    protected IStructureDefinition<PreciseAssembler> multiDefinition = null;
+    protected int casingAmount;
+    protected int casingTier;
+    protected int machineTier;
+    protected int mode;
+    protected int energyHatchTier;
+
+    public PreciseAssembler(String name) {
+        super(name);
+    }
+
+    public PreciseAssembler(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public IStructureDefinition<PreciseAssembler> getStructureDefinition() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<PreciseAssembler>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] { { "CCCCCCCCC", "CCCCCCCCC", "CCCCCCCCC", "CCCCCCCCC", "CCCCCCCCC" },
+                            { "F       F", "CGGGGGGGC", "C-------C", "CGGGGGGGC", "F       F" },
+                            { "F       F", "CGGGGGGGC", "C-------C", "CGGGGGGGC", "F       F" },
+                            { "F       F", "CGGGGGGGC", "C-------C", "CGGGGGGGC", "F       F" },
+                            { "CCCC~CCCC", "CMMMMMMMC", "CMMMMMMMC", "CMMMMMMMC", "CCCCCCCCC" } }))
+                .addElement(
+                    'C',
+                    GT_HatchElementBuilder.<PreciseAssembler>builder()
+                        .atLeast(
+                            InputBus,
+                            InputHatch,
+                            OutputHatch,
+                            OutputBus,
+                            Maintenance,
+                            Muffler,
+                            ExoticEnergy.or(Energy))
+                        .adder(PreciseAssembler::addToPAssList)
+                        .casingIndex(1539)
+                        .dot(1)
+                        .buildAndChain(
+                            onElementPass(
+                                x -> x.casingAmount++,
+                                StructureUtility.ofBlocksTiered(
+                                    (block, meta) -> block == Loaders.preciseUnitCasing ? meta : -2,
+                                    IntStream.range(0, 3)
+                                        .mapToObj(
+                                            meta -> org.apache.commons.lang3.tuple.Pair
+                                                .of(Loaders.preciseUnitCasing, meta))
+                                        .collect(Collectors.toList()),
+                                    -1,
+                                    PreciseAssembler::setCasingTier,
+                                    PreciseAssembler::getCasingTier))))
+                .addElement('F', ofFrame(Materials.TungstenSteel))
+                .addElement('G', ofGlassTieredMixed((byte) 4, (byte) 127, 2))
+                .addElement(
+                    'M',
+                    StructureUtility.ofBlocksTiered(
+                        (block, meta) -> block == GregTech_API.sBlockCasings1 ? meta : -2,
+                        IntStream.range(0, 10)
+                            .mapToObj(meta -> org.apache.commons.lang3.tuple.Pair.of(GregTech_API.sBlockCasings1, meta))
+                            .collect(Collectors.toList()),
+                        -1,
+                        PreciseAssembler::setMachineTier,
+                        PreciseAssembler::getMachineTier))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    public boolean addToPAssList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        }
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) {
+            return false;
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+            return mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof IDualInputHatch) {
+            return mDualInputHatches.add((IDualInputHatch) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus) {
+            return mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+            return mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_OutputBus) {
+            return mOutputBusses.add((GT_MetaTileEntity_Hatch_OutputBus) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+            return mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) {
+            return mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Muffler) {
+            return mMufflerHatches.add((GT_MetaTileEntity_Hatch_Muffler) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+            return mExoticEnergyHatches.add((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        casingTier = aNBT.getInteger("casingTier");
+        machineTier = aNBT.getInteger("machineTier");
+        mode = aNBT.getInteger("RunningMode");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("casingTier", casingTier);
+        aNBT.setInteger("machineTier", machineTier);
+        aNBT.setInteger("RunningMode", mode);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public final void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (getBaseMetaTileEntity().isServerSide()) {
+            this.mode = (this.mode + 1) % 2;
+            GT_Utility.sendChatToPlayer(aPlayer, StatCollector.translateToLocal("preciseassembler.chat." + this.mode));
+        }
+        super.onScrewdriverRightClick(side, aPlayer, aX, aY, aZ);
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @Nonnull
+            @Override
+            protected CheckRecipeResult validateRecipe(@Nonnull GT_Recipe recipe) {
+                if (mode == 0) {
+                    if (recipe.mSpecialValue > (casingTier + 1)) {
+                        return CheckRecipeResultRegistry.insufficientMachineTier(recipe.mSpecialValue);
+                    }
+                }
+                if (availableVoltage < recipe.mEUt) {
+                    return CheckRecipeResultRegistry.insufficientPower(recipe.mEUt);
+                }
+                return CheckRecipeResultRegistry.SUCCESSFUL;
+            }
+
+            @Nonnull
+            @Override
+            protected GT_OverclockCalculator createOverclockCalculator(@Nonnull GT_Recipe recipe) {
+                return super.createOverclockCalculator(recipe).setSpeedBoost(mode == 0 ? 1 : 0.5F);
+            }
+        }.setMaxParallelSupplier(() -> mode == 0 ? 1 : (int) Math.pow(2, 4 + (casingTier + 1)));
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        boolean useSingleAmp = mEnergyHatches.size() == 1 && mExoticEnergyHatches.isEmpty();
+        logic.setAvailableVoltage(getMachineVoltageLimit());
+        logic.setAvailableAmperage(useSingleAmp ? 1 : getMaxInputAmps());
+        logic.setAmperageOC(true);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    public long getMachineVoltageLimit() {
+        if (machineTier < 0) return 0;
+        if (machineTier >= 9) return GT_Values.V[energyHatchTier];
+        else return GT_Values.V[Math.min(machineTier, energyHatchTier)];
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        if (this.mode == 0) return GoodGeneratorRecipeMaps.preciseAssemblerRecipes;
+        else return RecipeMaps.assemblerRecipes;
+    }
+
+    @Nonnull
+    @Override
+    public Collection<RecipeMap<?>> getAvailableRecipeMaps() {
+        return Arrays.asList(GoodGeneratorRecipeMaps.preciseAssemblerRecipes, RecipeMaps.assemblerRecipes);
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(mName, stackSize, hintsOnly, 4, 4, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 4, 4, 0, elementBudget, env, false, true);
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        this.machineTier = -1;
+        this.casingAmount = 0;
+        this.casingTier = -1;
+        this.energyHatchTier = 0;
+        if (checkPiece(mName, 4, 4, 0)) {
+            energyHatchTier = checkEnergyHatchTier();
+            if (casingTier >= 0) {
+                reUpdate(1539 + casingTier);
+            }
+            getBaseMetaTileEntity().sendBlockEvent(GregTechTileClientEvents.CHANGE_CUSTOM_DATA, getUpdateData());
+            return casingAmount >= 42 && machineTier >= 0
+                && casingTier >= 0
+                && mMaintenanceHatches.size() == 1
+                && !mMufflerHatches.isEmpty();
+        }
+        return false;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Precise Assembler/Assembler")
+            .addInfo("Controller block for the Precise Assembler")
+            .addInfo("The error is no more than 7nm.")
+            .addInfo("Can assemble precise component in Precise Mode.")
+            .addInfo("Can work like a normal assembler in Normal Mode.")
+            .addInfo("Use screwdriver to change mode.")
+            .addInfo("Machine Casing and Energy Hatch limits the voltage tier the machine can work on.")
+            .addInfo("UHV Machine Casing will unlock all voltage, but you still need good Energy Hatch.")
+            .addInfo("Precise Electronic Unit Casing won't limit recipe in Normal Mode.")
+            .addInfo("But gives more parallel with more advanced one.")
+            .addInfo("It is 100% faster in Normal Mode.")
+            .addInfo("MK-I = 32x, MK-II = 64x, MK-III = 128x")
+            .addPollutionAmount(getPollutionPerSecond(null))
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .beginStructureBlock(9, 5, 5, true)
+            .addController("Front bottom")
+            .addCasingInfoExactly("Machine Casing", 21, true)
+            .addCasingInfoExactly("Glass (EV+)", 42, false)
+            .addCasingInfoRange("Precise Electronic Unit Casing", 42, 86, true)
+            .addInputHatch("Any Casing")
+            .addInputBus("Any Casing")
+            .addOutputHatch("Any Casing")
+            .addOutputBus("Any Casing")
+            .addEnergyHatch("Any Casing")
+            .addMufflerHatch("Any Casing")
+            .addMaintenanceHatch("Any Casing")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public int getPollutionPerSecond(ItemStack aStack) {
+        return 780;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("PreciseAssembler.hint", 7);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new PreciseAssembler(this.mName);
+    }
+
+    private int checkEnergyHatchTier() {
+        int tier = 0;
+        for (GT_MetaTileEntity_Hatch_Energy tHatch : filterValidMTEs(mEnergyHatches)) {
+            tier = Math.max(tHatch.mTier, tier);
+        }
+        for (GT_MetaTileEntity_Hatch tHatch : filterValidMTEs(mExoticEnergyHatches)) {
+            tier = Math.max(tHatch.mTier, tier);
+        }
+        return tier;
+    }
+
+    public int getCasingTier() {
+        return casingTier;
+    }
+
+    public void setCasingTier(int i) {
+        casingTier = i;
+    }
+
+    public int getMachineTier() {
+        return machineTier;
+    }
+
+    public void setMachineTier(int i) {
+        machineTier = i;
+    }
+
+    public void reUpdate(int texture) {
+        for (IDualInputHatch hatch : mDualInputHatches) {
+            if (((MetaTileEntity) hatch).isValid()) {
+                hatch.updateTexture(texture);
+            }
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mInputHatches)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mInputBusses)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mOutputHatches)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mOutputBusses)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mEnergyHatches)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mMaintenanceHatches)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mMufflerHatches)) {
+            hatch.updateTexture(texture);
+        }
+        for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(mExoticEnergyHatches)) {
+            hatch.updateTexture(texture);
+        }
+    }
+
+    @Override
+    public byte getUpdateData() {
+        return (byte) casingTier;
+    }
+
+    @Override
+    public void receiveClientEvent(byte aEventID, byte aValue) {
+        super.receiveClientEvent(aEventID, aValue);
+        if (aEventID == GregTechTileClientEvents.CHANGE_CUSTOM_DATA && (aValue & 0x80) == 0) {
+            casingTier = aValue;
+        }
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        int t = Math.max(getCasingTier(), 0);
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1539 + t),
+                TextureFactory.of(textureFontOn), TextureFactory.builder()
+                    .addIcon(textureFontOn_Glow)
+                    .glow()
+                    .build() };
+            else return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1539 + t),
+                TextureFactory.of(textureFontOff), TextureFactory.builder()
+                    .addIcon(textureFontOff_Glow)
+                    .glow()
+                    .build() };
+        } else return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1539 + t) };
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        super.addUIWidgets(builder, buildContext);
+        builder.widget(
+            new CycleButtonWidget().setToggle(() -> mode == 1, val -> mode = val ? 1 : 0)
+                .setTextureGetter(
+                    state -> state == 1 ? GG_UITextures.OVERLAY_BUTTON_ASSEMBLER_MODE
+                        : GG_UITextures.OVERLAY_BUTTON_PRECISE_MODE)
+                .setBackground(GT_UITextures.BUTTON_STANDARD)
+                .setPos(80, 91)
+                .setSize(16, 16)
+                .dynamicTooltip(
+                    () -> Collections.singletonList(StatCollector.translateToLocal("preciseassembler.chat." + mode)))
+                .setUpdateTooltipEveryTick(true)
+                .setTooltipShowUpDelay(TOOLTIP_DELAY));
+    }
+
+    @Override
+    public boolean isInputSeparationEnabled() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java
new file mode 100644
index 0000000000..7c8d9ee154
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java
@@ -0,0 +1,184 @@
+package goodgenerator.blocks.tileEntity;
+
+import java.util.ArrayList;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_LargeTurbineBase;
+import goodgenerator.loader.Loaders;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.objects.XSTR;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+
+public class SupercriticalFluidTurbine extends GT_MetaTileEntity_LargeTurbineBase {
+
+    private boolean looseFit = false;
+
+    private static final IIconContainer turbineOn = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_05");
+    private static final IIconContainer turbineOff = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_15");
+    private static final IIconContainer turbineEmpty = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_25");
+
+    public SupercriticalFluidTurbine(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public SupercriticalFluidTurbine(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff) {
+        if (looseFit) {
+            aOptFlow *= 4;
+            double pow = Math.pow(1.1f, ((aBaseEff - 7500) / 10000F) * 20f);
+            if (aBaseEff > 10000) {
+                aOptFlow *= pow;
+                aBaseEff = 7500;
+            } else if (aBaseEff > 7500) {
+                aOptFlow *= pow;
+                aBaseEff *= 0.75f;
+            } else {
+                aBaseEff *= 0.75f;
+            }
+        }
+        int tEU = 0;
+        int totalFlow = 0; // Byproducts are based on actual flow
+        int flow = 0;
+        int remainingFlow = GT_Utility.safeInt((long) (aOptFlow * 1.25f)); // Allowed to use up to 125% of optimal flow.
+                                                                           // Variable required outside of loop for
+        // multi-hatch scenarios.
+        this.realOptFlow = aOptFlow;
+
+        storedFluid = 0;
+        FluidStack tSCSteam = FluidRegistry.getFluidStack("supercriticalsteam", 1);
+        for (int i = 0; i < aFluids.size() && remainingFlow > 0; i++) {
+            final FluidStack aFluidStack = aFluids.get(i);
+            if (tSCSteam.isFluidEqual(aFluidStack)) {
+                flow = Math.min(aFluidStack.amount, remainingFlow);
+                depleteInput(new FluidStack(aFluidStack, flow));
+                this.storedFluid += aFluidStack.amount;
+                remainingFlow -= flow;
+                totalFlow += flow;
+            } else if (GT_ModHandler.isAnySteam(aFluidStack)) {
+                depleteInput(new FluidStack(aFluidStack, aFluidStack.amount));
+            }
+        }
+        if (totalFlow <= 0) return 0;
+        tEU = totalFlow;
+        addOutput(GT_ModHandler.getSteam(totalFlow));
+        if (totalFlow == aOptFlow) {
+            tEU = GT_Utility.safeInt((long) tEU * (long) aBaseEff / 100L);
+        } else {
+            float efficiency = 1.0f - Math.abs((totalFlow - aOptFlow) / (float) aOptFlow);
+            tEU *= efficiency;
+            tEU = Math.max(1, GT_Utility.safeInt((long) tEU * (long) aBaseEff / 100L));
+        }
+
+        if (tEU > maxPower) {
+            tEU = GT_Utility.safeInt(maxPower);
+        }
+
+        return tEU;
+    }
+
+    @Override
+    public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (side == getBaseMetaTileEntity().getFrontFacing()) {
+            looseFit ^= true;
+            GT_Utility.sendChatToPlayer(
+                aPlayer,
+                looseFit ? trans("500", "Fitting: Loose - More Flow")
+                    : trans("501", "Fitting: Tight - More Efficiency"));
+        }
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        // 2x more damage than normal turbine
+        return looseFit ? (XSTR.XSTR_INSTANCE.nextInt(2) == 0 ? 0 : 1) : 2;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        super.looseFit = looseFit;
+        return super.getInfoData();
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setBoolean("turbineFitting", looseFit);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        looseFit = aNBT.getBoolean("turbineFitting");
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return Loaders.supercriticalFluidTurbineCasing;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 0;
+    }
+
+    @Override
+    public int getCasingTextureIndex() {
+        return 1538;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Supercritical Steam Turbine")
+            .addInfo("Controller block for Supercritical Fluid Turbine")
+            .addInfo("Needs a Turbine, place inside controller")
+            .addInfo("Use Supercritical Steam to generate power.")
+            .addInfo("Outputs Steam as well as producing power")
+            .addInfo("1L Supercritical Steam = 100 EU")
+            .addInfo("Extreme Heated Steam will cause more damage to the turbine.")
+            .addInfo("Power output depends on turbine and fitting")
+            .addInfo("Use screwdriver to adjust fitting of turbine")
+            .addSeparator()
+            .beginStructureBlock(3, 3, 4, true)
+            .addController("Front center")
+            .addCasingInfo("SC Turbine Casing", 24)
+            .addDynamoHatch("Back center", 1)
+            .addMaintenanceHatch("Side centered", 2)
+            .addInputHatch("Supercritical Fluid, Side centered", 2)
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new SupercriticalFluidTurbine(mName);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1538),
+            facing == side
+                ? (aActive ? TextureFactory.of(turbineOn)
+                    : hasTurbine() ? TextureFactory.of(turbineOff) : TextureFactory.of(turbineEmpty))
+                : Textures.BlockIcons.getCasingTextureForId(1538) };
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java
new file mode 100644
index 0000000000..6c8ce62539
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java
@@ -0,0 +1,393 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.enums.Mods.GTPlusPlus;
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.TickTime;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.recipe.maps.FuelBackend;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.recipe.GTPPRecipeMaps;
+
+public class UniversalChemicalFuelEngine extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    protected final double DIESEL_EFFICIENCY_COEFFICIENT = 0.04D;
+    protected final double GAS_EFFICIENCY_COEFFICIENT = 0.04D;
+    protected final double ROCKET_EFFICIENCY_COEFFICIENT = 0.005D;
+    protected final double EFFICIENCY_CEILING = 1.5D;
+    protected final int HEATING_TIMER = TickTime.SECOND * 10;
+
+    private long tEff;
+    private int heatingTicks;
+    private boolean isStoppingSafe;
+
+    private IStructureDefinition<UniversalChemicalFuelEngine> multiDefinition = null;
+
+    public UniversalChemicalFuelEngine(String name) {
+        super(name);
+        super.useLongPower = true;
+    }
+
+    public UniversalChemicalFuelEngine(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+        super.useLongPower = true;
+    }
+
+    public final boolean addMaintenance(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity);
+            }
+        }
+        return false;
+    }
+
+    public final boolean addMuffler(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Muffler) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mMufflerHatches.add((GT_MetaTileEntity_Hatch_Muffler) aMetaTileEntity);
+            }
+        }
+        return false;
+    }
+
+    public final boolean addInputHatch(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
+            }
+        }
+        return false;
+    }
+
+    public final boolean addDynamoHatch(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Dynamo) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mDynamoHatches.add((GT_MetaTileEntity_Hatch_Dynamo) aMetaTileEntity);
+            } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoMulti) {
+                ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.eDynamoMulti.add((GT_MetaTileEntity_Hatch_DynamoMulti) aMetaTileEntity);
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public IStructureDefinition<UniversalChemicalFuelEngine> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<UniversalChemicalFuelEngine>builder()
+                .addShape(
+                    mName,
+                    transpose(
+                        new String[][] {
+                            { "TTTTT", "TTMMT", "TTMMT", "TTMMT", "TTMMT", "TTMMT", "TTMMT", "TTMMT", "TTTTT" },
+                            { "TTTTT", "SPCCI-", "SPCCI-", "SPCCI-", "SPCCI-", "SPCCI-", "SPCCI-", "SPCCI-", "TTTTT" },
+                            { "TT~TT", "SPGGI-", "SPGGI-", "SPGGI-", "SPGGI-", "SPGGI-", "SPGGI-", "SPGGI-", "TTETT" },
+                            { "TTWTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT" } }))
+                .addElement('T', ofBlock(GregTech_API.sBlockCasings4, 2))
+                .addElement('W', GT_HatchElement.Maintenance.newAny(50, 1))
+                .addElement('M', GT_HatchElement.Muffler.newAny(50, 2))
+                .addElement('S', GT_HatchElement.InputHatch.newAny(50, 3))
+                .addElement('E', GT_HatchElement.Dynamo.newAny(50, 4))
+                .addElement('P', ofBlock(GregTech_API.sBlockCasings2, 14))
+                .addElement('C', ofBlock(Loaders.titaniumPlatedCylinder, 0))
+                .addElement('G', ofBlock(GregTech_API.sBlockCasings2, 4))
+                .addElement('I', ofBlock(GregTech_API.sBlockCasings4, 13))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return structureCheck_EM(mName, 2, 2, 0);
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        structureBuild_EM(mName, 2, 2, 0, stackSize, hintsOnly);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("UniversalChemicalFuelEngine.hint", 11);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return (int) Math.sqrt(this.getPowerFlow()) / 20;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Chemical Engine")
+            .addInfo("Controller block for the Chemical Engine")
+            .addInfo("BURNING BURNING BURNING")
+            .addInfo("Use combustible liquid to generate power.")
+            .addInfo("You need to supply Combustion Promoter to keep it running.")
+            .addInfo("It will consume all the fuel and promoter in the hatch every second.")
+            .addInfo("If the Dynamo Hatch's buffer fills up, the machine will stop.")
+            .addInfo("When turned on, there's 10-second period where the machine will not stop.")
+            .addInfo("Even if it doesn't stop, all the fuel in the hatch will be consumed.")
+            .addInfo("The efficiency is determined by the proportion of Combustion Promoter to fuel.")
+            .addInfo("The proportion is bigger, and the efficiency will be higher.")
+            .addInfo("Start machine with power button to force structure check.")
+            .addInfo("It creates sqrt(Current Output Power) pollution every second")
+            .addInfo(
+                "If you forget to supply Combustion Promoter, this engine will swallow all the fuel "
+                    + EnumChatFormatting.YELLOW
+                    + "without outputting energy"
+                    + EnumChatFormatting.GRAY
+                    + ".")
+            .addInfo("The efficiency is up to 150%.")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .beginStructureBlock(5, 4, 9, false)
+            .addMaintenanceHatch("Hint block with dot 1")
+            .addMufflerHatch("Hint block with dot 2 (fill all slots with mufflers)")
+            .addInputHatch("Hint block with dot 3 (fill all slots with input hatches)")
+            .addDynamoHatch("Hint block with dot 4")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing_EM() {
+
+        ArrayList<FluidStack> tFluids = getStoredFluids();
+
+        long PromoterAmount = findLiquidAmount(getPromoter(), tFluids);
+
+        CheckRecipeResult result;
+
+        result = processFuel(tFluids, RecipeMaps.dieselFuels, PromoterAmount, DIESEL_EFFICIENCY_COEFFICIENT, 1);
+        if (result.wasSuccessful()) return result;
+
+        result = processFuel(tFluids, RecipeMaps.gasTurbineFuels, PromoterAmount, GAS_EFFICIENCY_COEFFICIENT, 1);
+        if (result.wasSuccessful()) return result;
+
+        if (GTPlusPlus.isModLoaded()) {
+            result = processFuel(tFluids, GTPPRecipeMaps.rocketFuels, PromoterAmount, ROCKET_EFFICIENCY_COEFFICIENT, 3);
+            if (result.wasSuccessful()) return result;
+        }
+
+        return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+    }
+
+    protected CheckRecipeResult processFuel(ArrayList<FluidStack> tFluids, RecipeMap<FuelBackend> recipeMap,
+        long PromoterAmount, double efficiencyCoefficient, double FuelsValueBonus) {
+        for (GT_Recipe recipe : recipeMap.getAllRecipes()) {
+            FluidStack tFuel = findFuel(recipe);
+            if (tFuel == null) continue;
+            long FuelAmount = findLiquidAmount(tFuel, tFluids);
+            if (FuelAmount == 0) continue;
+            calculateEfficiency(FuelAmount, PromoterAmount, efficiencyCoefficient);
+            consumeAllLiquid(tFuel, tFluids);
+            consumeAllLiquid(getPromoter(), tFluids);
+            this.setPowerFlow((long) (FuelAmount * recipe.mSpecialValue * FuelsValueBonus / 20.0D));
+            this.mMaxProgresstime = 20;
+            this.updateSlots();
+            return CheckRecipeResultRegistry.GENERATING;
+        }
+        return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+    }
+
+    @Override
+    public void stopMachine() {
+        // Reset the counter for heating, so that it works again when the machine restarts
+        heatingTicks = 0;
+        super.stopMachine();
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack stack) {
+        super.onRunningTick(stack);
+        // Counts ticks up to the defined timer (200 ticks, 10 seconds)
+        // The multiblock will not stop due to excess energy during this time
+        // Machine used to explode in the past, this timer was first made to prevent that
+        if (heatingTicks < HEATING_TIMER) {
+            heatingTicks++;
+            isStoppingSafe = true;
+        } else if (isStoppingSafe) isStoppingSafe = false;
+
+        if (this.getBaseMetaTileEntity()
+            .isServerSide()) {
+            addAutoEnergy();
+        }
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        String[] info = super.getInfoData();
+        info[4] = "Probably makes: " + EnumChatFormatting.RED
+            + GT_Utility.formatNumbers(this.getPowerFlow())
+            + EnumChatFormatting.RESET
+            + " EU/t";
+        info[6] = "Problems: " + EnumChatFormatting.RED
+            + GT_Utility.formatNumbers(this.getIdealStatus() - this.getRepairStatus())
+            + EnumChatFormatting.RESET
+            + " Efficiency: "
+            + EnumChatFormatting.YELLOW
+            + GT_Utility.formatNumbers(tEff / 100D)
+            + EnumChatFormatting.RESET
+            + " %";
+        return info;
+    }
+
+    void addAutoEnergy() {
+        long exEU = this.getPowerFlow() * tEff / 10000;
+        if (!mDynamoHatches.isEmpty()) {
+            GT_MetaTileEntity_Hatch_Dynamo tHatch = mDynamoHatches.get(0);
+            if (tHatch.maxEUOutput() * tHatch.maxAmperesOut() >= exEU) {
+                tHatch.setEUVar(
+                    Math.min(
+                        tHatch.maxEUStore(),
+                        tHatch.getBaseMetaTileEntity()
+                            .getStoredEU() + exEU));
+            } else if (!isStoppingSafe) {
+                stopMachine();
+            }
+        }
+        if (!eDynamoMulti.isEmpty()) {
+            GT_MetaTileEntity_Hatch_DynamoMulti tHatch = eDynamoMulti.get(0);
+            if (tHatch.maxEUOutput() * tHatch.maxAmperesOut() >= exEU) {
+                tHatch.setEUVar(
+                    Math.min(
+                        tHatch.maxEUStore(),
+                        tHatch.getBaseMetaTileEntity()
+                            .getStoredEU() + exEU));
+            } else if (!isStoppingSafe) {
+                stopMachine();
+            }
+        }
+    }
+
+    public FluidStack getPromoter() {
+        return FluidRegistry.getFluidStack("combustionpromotor", 1);
+    }
+
+    public FluidStack findFuel(GT_Recipe aFuel) {
+        if (aFuel.mInputs != null && aFuel.mInputs.length > 0)
+            return GT_Utility.getFluidForFilledItem(aFuel.mInputs[0], true);
+        else return aFuel.mFluidInputs[0];
+    }
+
+    public void calculateEfficiency(long aFuel, long aPromoter, double coefficient) {
+        if (aPromoter == 0) {
+            this.tEff = 0;
+            return;
+        }
+        this.tEff = (int) (Math.exp(-coefficient * (double) aFuel / (double) aPromoter) * EFFICIENCY_CEILING * 10000);
+    }
+
+    public long findLiquidAmount(FluidStack liquid, List<FluidStack> input) {
+        long cnt = 0;
+        for (FluidStack fluid : input) {
+            if (fluid.isFluidEqual(liquid)) {
+                cnt += fluid.amount;
+            }
+        }
+        if (cnt < 0) cnt = 0;
+        return cnt;
+    }
+
+    public void consumeAllLiquid(FluidStack liquid, List<FluidStack> input) {
+        for (FluidStack fluid : input) {
+            if (fluid.isFluidEqual(liquid)) fluid.amount = 0;
+        }
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { casingTexturePages[0][50],
+                TextureFactory.of(OVERLAY_FRONT_DIESEL_ENGINE_ACTIVE), TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_DIESEL_ENGINE_ACTIVE_GLOW)
+                    .glow()
+                    .build() };
+            return new ITexture[] { casingTexturePages[0][50], TextureFactory.of(OVERLAY_FRONT_DIESEL_ENGINE),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_DIESEL_ENGINE_GLOW)
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { casingTexturePages[0][50] };
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new UniversalChemicalFuelEngine(this.mName);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 2, 2, 0, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java
new file mode 100644
index 0000000000..f712fa12a7
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java
@@ -0,0 +1,709 @@
+package goodgenerator.blocks.tileEntity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY;
+import static gregtech.api.util.GT_StructureUtility.*;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChatComponentTranslation;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import org.apache.commons.lang3.StringUtils;
+import org.jetbrains.annotations.NotNull;
+
+import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass;
+import com.github.technus.tectech.TecTech;
+import com.github.technus.tectech.thing.gui.TecTechUITextures;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.IStructureElement;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizons.modularui.api.NumberFormatMUI;
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.YOTTAHatch;
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
+import goodgenerator.client.GUI.GG_UITextures;
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.CharExchanger;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.SimpleCheckRecipeResult;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+
+public class YottaFluidTank extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable {
+
+    private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QTANK");
+    private static final IIconContainer textureFontOn_Glow = new Textures.BlockIcons.CustomIcon(
+        "iconsets/OVERLAY_QTANK_GLOW");
+    private static final IIconContainer textureFontOff = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QCHEST");
+    private static final IIconContainer textureFontOff_Glow = new Textures.BlockIcons.CustomIcon(
+        "iconsets/OVERLAY_QCHEST_GLOW");
+
+    protected IStructureDefinition<YottaFluidTank> multiDefinition = null;
+    protected final ArrayList<YOTTAHatch> mYottaHatch = new ArrayList<>();
+
+    private static final BigInteger ONE_HUNDRED = BigInteger.valueOf(100);
+    private static final BigInteger FIVE = BigInteger.valueOf(5);
+
+    /** Tank capacity */
+    public BigInteger mStorage = BigInteger.ZERO;
+    /** Amount of fluid millibuckets currently in the tank */
+    public BigInteger mStorageCurrent = BigInteger.ZERO;
+    /**
+     * Fluid type currently stored in the tank, can be null. Stack size is always 1, real amount is stored in
+     * mStorageCurrent.
+     */
+    public FluidStack mFluid = null;
+    /**
+     * Fluid type currently the tank is currently locked to, can be null. Stack size is always 1, real amount is stored
+     * in mStorageCurrent.
+     */
+    public FluidStack mLockedFluid = null;
+    protected boolean isFluidLocked = false;
+    protected int glassMeta;
+    protected int maxCell;
+    protected final String YOTTANK_BOTTOM = mName + "buttom";
+    protected final String YOTTANK_MID = mName + "mid";
+    protected final String YOTTANK_TOP = mName + "top";
+    protected final NumberFormatMUI numberFormat = new NumberFormatMUI();
+    private int workTickCounter = 0;
+
+    public static final BigInteger MAX_INT_BIGINT = BigInteger.valueOf(Integer.MAX_VALUE);
+
+    protected boolean voidExcessEnabled = false;
+
+    public YottaFluidTank(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public YottaFluidTank(String name) {
+        super(name);
+    }
+
+    public int getMeta() {
+        return glassMeta;
+    }
+
+    public void setMeta(int meta) {
+        glassMeta = meta;
+    }
+
+    public String getCap() {
+        return mStorage.toString(10);
+    }
+
+    public String getStored() {
+        return mStorageCurrent.toString(10);
+    }
+
+    public String getFluidName() {
+        if (mFluid == null) return StatCollector.translateToLocal("scanner.info.YOTTank.empty");
+        return mFluid.getLocalizedName();
+    }
+
+    public String getLockedFluidName() {
+        if (!isFluidLocked) return StatCollector.translateToLocal("scanner.info.YOTTank.none");
+        if (mLockedFluid == null) return StatCollector.translateToLocal("scanner.info.YOTTank.next");
+        return mLockedFluid.getLocalizedName();
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        String tAmount = aNBT.getString("mStorage");
+        String tAmountCurrent = aNBT.getString("mStorageCurrent");
+        if (StringUtils.isEmpty(tAmount)) tAmount = "0";
+        if (StringUtils.isEmpty(tAmountCurrent)) tAmountCurrent = "0";
+        mStorage = new BigInteger(tAmount, 10);
+        mStorageCurrent = new BigInteger(tAmountCurrent, 10);
+        mFluid = FluidRegistry.getFluidStack(aNBT.getString("mFluidName"), 1);
+        mLockedFluid = FluidRegistry.getFluidStack(aNBT.getString("mLockedFluidName"), 1);
+        voidExcessEnabled = aNBT.getBoolean("voidExcessEnabled");
+        isFluidLocked = aNBT.getBoolean("isFluidLocked");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setString("mStorage", mStorage.toString(10));
+        aNBT.setString("mStorageCurrent", mStorageCurrent.toString(10));
+        aNBT.setString(
+            "mFluidName",
+            mFluid == null ? ""
+                : mFluid.getFluid()
+                    .getName());
+        aNBT.setString(
+            "mLockedFluidName",
+            mLockedFluid == null ? ""
+                : mLockedFluid.getFluid()
+                    .getName());
+        aNBT.setBoolean("voidExcessEnabled", voidExcessEnabled);
+        aNBT.setBoolean("isFluidLocked", isFluidLocked);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing_EM() {
+        this.mEUt = 0;
+        this.mMaxProgresstime = 20;
+        return SimpleCheckRecipeResult.ofSuccess("");
+    }
+
+    public boolean getIsVoidExcessEnabled() {
+        return voidExcessEnabled;
+    }
+
+    /**
+     * Attempts to remove {@code amount} of fluid from the tank if possible, does not do partial removals.
+     *
+     * @param amount The millibucket amount of the fluid to remove
+     * @return True if successfully removed amount, false if no fluid was removed.
+     */
+    public boolean reduceFluid(long amount) {
+        final BigInteger bigAmount = BigInteger.valueOf(amount);
+        if (mStorageCurrent.compareTo(bigAmount) < 0) {
+            return false;
+        } else {
+            mStorageCurrent = mStorageCurrent.subtract(bigAmount);
+            return true;
+        }
+    }
+
+    /**
+     * Attempts to put {@code amount} of fluid into the tank if possible, fails if there's not enough space for all of
+     * it.
+     *
+     * @param amount The millibucket amount of the fluid to insert
+     * @param doFill Whether to actually fill, or just simulate a fill
+     * @return True if successfully added the given amount of fluid to the tank, false if failed.
+     */
+    public boolean addFluid(long amount, boolean doFill) {
+        final BigInteger bigAmount = BigInteger.valueOf(amount);
+        final BigInteger newTotal = mStorageCurrent.add(bigAmount);
+        if (newTotal.compareTo(mStorage) > 0) {
+            return false;
+        } else {
+            if (doFill) {
+                mStorageCurrent = newTotal;
+            }
+            return true;
+        }
+    }
+
+    // Avoid allocating a new array on every query
+    private final FluidTankInfo[] tankInfoCache = new FluidTankInfo[1];
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection aSide) {
+        int fluidSize = mStorageCurrent.compareTo(MAX_INT_BIGINT) >= 0 ? Integer.MAX_VALUE : mStorageCurrent.intValue();
+        int tankCapacity = mStorage.compareTo(MAX_INT_BIGINT) >= 0 ? Integer.MAX_VALUE : mStorage.intValue();
+        final boolean cacheNeedsRecreation;
+        if (tankInfoCache[0] == null || tankInfoCache[0].capacity != tankCapacity) {
+            cacheNeedsRecreation = true;
+        } else if (tankInfoCache[0].fluid == null) {
+            cacheNeedsRecreation = (mFluid != null);
+        } else {
+            cacheNeedsRecreation = !tankInfoCache[0].fluid.isFluidEqual(mFluid);
+        }
+        if (cacheNeedsRecreation) {
+            final FluidStack storedFluid = mFluid.copy();
+            storedFluid.amount = fluidSize;
+            tankInfoCache[0] = new FluidTankInfo(storedFluid, tankCapacity);
+        } else if (mFluid != null) {
+            tankInfoCache[0].fluid.amount = fluidSize;
+        }
+        return tankInfoCache;
+    }
+
+    @Override
+    protected void clearHatches_EM() {
+        super.clearHatches_EM();
+        mYottaHatch.clear();
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        mStorage = BigInteger.ZERO;
+        glassMeta = 0;
+        maxCell = 0;
+        if (!structureCheck_EM(YOTTANK_BOTTOM, 2, 0, 0)) return false;
+        int cnt = 0;
+        while (structureCheck_EM(YOTTANK_MID, 2, cnt + 1, 0)) {
+            cnt++;
+        }
+        if (cnt > 15 || cnt < 1) return false;
+        if (!structureCheck_EM(YOTTANK_TOP, 2, cnt + 2, 0)) return false;
+        // maxCell+1 = Tier of highest Cell. glassMeta is the glass voltage tier
+        if (maxCell + 3 <= glassMeta) {
+            if (mStorage.compareTo(mStorageCurrent) < 0) mStorageCurrent = mStorage;
+            if (mFluid == null) {
+                mStorageCurrent = BigInteger.ZERO;
+            }
+            mWrench = true;
+            mScrewdriver = true;
+            mSolderingTool = true;
+            mSoftHammer = true;
+            mHardHammer = true;
+            mCrowbar = true;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public IStructureDefinition<YottaFluidTank> getStructure_EM() {
+        if (multiDefinition == null) {
+            multiDefinition = StructureDefinition.<YottaFluidTank>builder()
+                .addShape(
+                    YOTTANK_BOTTOM,
+                    transpose(
+                        new String[][] { { "MM~MM", "MCCCM", "MCCCM", "MCCCM", "MMMMM" },
+                            { "     ", " OOO ", " OOO ", " OOO ", "     " } }))
+                .addShape(YOTTANK_MID, transpose(new String[][] { { "GGGGG", "GRRRG", "GRRRG", "GRRRG", "GGGGG" } }))
+                .addShape(
+                    YOTTANK_TOP,
+                    transpose(
+                        new String[][] { { "FFFFF", "F   F", "F   F", "F   F", "FFFFF" },
+                            { "CCCCC", "CIIIC", "CIIIC", "CIIIC", "CCCCC" } }))
+                .addElement('C', ofBlock(Loaders.yottaFluidTankCasing, 0))
+                .addElement(
+                    'G',
+                    withChannel(
+                        "glass",
+                        BorosilicateGlass.ofBoroGlass(
+                            (byte) 0,
+                            (byte) 1,
+                            Byte.MAX_VALUE,
+                            YottaFluidTank::setMeta,
+                            te -> (byte) te.getMeta())))
+                .addElement('R', ofChain(cells(10)))
+                .addElement('F', ofFrame(Materials.Steel))
+                .addElement(
+                    'I',
+                    buildHatchAdder(YottaFluidTank.class).atLeast(GT_HatchElement.InputHatch)
+                        .casingIndex(1537)
+                        .dot(1)
+                        .buildAndChain(Loaders.yottaFluidTankCasing, 0))
+                .addElement(
+                    'M',
+                    buildHatchAdder(YottaFluidTank.class).atLeast(GT_HatchElement.Maintenance)
+                        .casingIndex(1537)
+                        .dot(2)
+                        .buildAndChain(Loaders.yottaFluidTankCasing, 0))
+                .addElement(
+                    'O',
+                    buildHatchAdder(YottaFluidTank.class).atLeast(GT_HatchElement.OutputHatch)
+                        .adder(YottaFluidTank::addOutput)
+                        .casingIndex(1537)
+                        .dot(1)
+                        .buildAndChain(Loaders.yottaFluidTankCasing, 0))
+                .build();
+        }
+        return multiDefinition;
+    }
+
+    public List<IStructureElement<YottaFluidTank>> cells(int num) {
+        List<IStructureElement<YottaFluidTank>> out = new ArrayList<>();
+        for (int i = 0; i < num; ++i) {
+            int finalI = i;
+            out.add(onElementPass(x -> {
+                x.mStorage = x.mStorage.add(calStorage(finalI));
+                x.maxCell = Math.max(x.maxCell, finalI);
+            }, ofBlock(Loaders.yottaFluidTankCell, i)));
+        }
+        return out;
+    }
+
+    public final boolean addOutput(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity == null) {
+                return false;
+            } else {
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+                    ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                    return this.mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof YOTTAHatch) {
+                    // only one yothatch allowed
+                    if (!this.mYottaHatch.isEmpty()) return false;
+                    ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                    ((YOTTAHatch) aMetaTileEntity).setTank(this);
+                    return this.mYottaHatch.add((YOTTAHatch) aMetaTileEntity);
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] { StatCollector.translateToLocal("scanner.info.YOTTank.1"),
+            StatCollector.translateToLocal(
+                EnumChatFormatting.YELLOW + CharExchanger.formatNumber(getFluidName() + EnumChatFormatting.RESET)),
+
+            StatCollector.translateToLocal("scanner.info.YOTTank.0"),
+            StatCollector.translateToLocal(
+                EnumChatFormatting.GREEN + CharExchanger.formatNumber(getCap()) + EnumChatFormatting.RESET + " L"),
+
+            StatCollector.translateToLocal("scanner.info.YOTTank.2"),
+            StatCollector.translateToLocal(
+                EnumChatFormatting.GREEN + CharExchanger.formatNumber(getStored())
+                    + EnumChatFormatting.RESET
+                    + " L"
+                    + " ("
+                    + EnumChatFormatting.GREEN
+                    + getPercent()
+                    + "%"
+                    + EnumChatFormatting.RESET
+                    + ")"),
+
+            StatCollector.translateToLocal("scanner.info.YOTTank.3"),
+            StatCollector.translateToLocal(
+                EnumChatFormatting.YELLOW + CharExchanger.formatNumber(getLockedFluidName())
+                    + EnumChatFormatting.RESET) };
+    }
+
+    private String getPercent() {
+        if (mStorage.signum() == 0) return "0";
+        return mStorageCurrent.multiply(ONE_HUNDRED)
+            .divide(mStorage)
+            .toString();
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fluid Tank")
+            .addInfo("Controller block for the YOTTank.")
+            .addInfo("The max output speed is decided by the amount of stored liquid and the output hatch's capacity.")
+            .addInfo("The max fluid cell tier is limited by the glass tier.")
+            .addInfo("HV glass for T1, EV glass for T2, IV glass for T3. . .")
+            .addInfo("The max height of the cell blocks is 15.")
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .beginVariableStructureBlock(5, 5, 1, 15, 5, 5, false)
+            .addController("Front of the second layer")
+            .addCasingInfoExactly("Steel Frame Box", 16, false)
+            .addCasingInfoRange("Glass (HV+)", 16, 240, true)
+            .addCasingInfoRange("Fluid Cell Block", 9, 135, true)
+            .addCasingInfoRange("YOTTank Casing", 25, 43, false)
+            .addInputHatch("Hint block with dot 1")
+            .addOutputHatch("Hint block with dot 3")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    private static final BigInteger[] storageWithCells;
+
+    static {
+        storageWithCells = new BigInteger[10];
+        final BigInteger baseStorage = BigInteger.valueOf(1_000_000);
+        final BigInteger storageMultiplier = BigInteger.valueOf(100);
+        BigInteger currentStorage = baseStorage;
+        for (int i = 0; i < 10; i++) {
+            storageWithCells[i] = currentStorage;
+            currentStorage = currentStorage.multiply(storageMultiplier);
+        }
+    }
+
+    public BigInteger calStorage(int meta) {
+        return storageWithCells[meta];
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack aStack) {
+        super.onRunningTick(aStack);
+        if (this.getBaseMetaTileEntity()
+            .isServerSide()) {
+            ++workTickCounter;
+            if (workTickCounter < 20) {
+                return true;
+            }
+            workTickCounter = 0;
+
+            List<FluidStack> tStore = getStoredFluids();
+            for (FluidStack tFluid : tStore) {
+                if (tFluid == null) continue;
+                if (isFluidLocked) {
+                    if (mLockedFluid != null) {
+                        if (!tFluid.isFluidEqual(mLockedFluid)) continue;;
+                    } else {
+                        mLockedFluid = tFluid.copy();
+                        mLockedFluid.amount = 1;
+                    }
+                }
+                if (mFluid == null || tFluid.isFluidEqual(mFluid)) {
+                    if (mFluid == null) {
+                        mFluid = tFluid.copy();
+                        mFluid.amount = 1;
+                    }
+                    if (addFluid(tFluid.amount, true)) {
+                        tFluid.amount = 0;
+                    } else {
+                        if (voidExcessEnabled) {
+                            tFluid.amount = 0;
+                        } else {
+                            final BigInteger delta = mStorage.subtract(mStorageCurrent);
+                            tFluid.amount -= delta.intValueExact();
+                        }
+                        mStorageCurrent = mStorage;
+                    }
+                }
+            }
+
+            if (mStorageCurrent.compareTo(BigInteger.ZERO) <= 0) {
+                mFluid = null;
+            }
+
+            if (mFluid != null) {
+                // Try to drain 1% of the tank per tick, so 20% per second aka 1/5
+                int outputAmount = mStorageCurrent.divide(FIVE)
+                    .min(MAX_INT_BIGINT)
+                    .max(BigInteger.ONE)
+                    .intValueExact();
+                final int originalOutputAmount = outputAmount;
+
+                for (final GT_MetaTileEntity_Hatch outputHatch : mOutputHatches) {
+                    final FluidStack fluidInHatch = outputHatch.mFluid;
+
+                    final int remainingHatchSpace;
+                    if (fluidInHatch != null) {
+                        if (fluidInHatch.isFluidEqual(mFluid)) {
+                            remainingHatchSpace = outputHatch.getCapacity() - fluidInHatch.amount;
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        remainingHatchSpace = outputHatch.getCapacity();
+                    }
+
+                    final int amountToFillHatch = Math.min(remainingHatchSpace, outputAmount);
+                    if (amountToFillHatch <= 0) {
+                        continue;
+                    }
+                    final FluidStack fillStack = mFluid.copy();
+                    fillStack.amount = amountToFillHatch;
+                    final int transferredAmount = outputHatch.fill(fillStack, true);
+                    outputAmount -= transferredAmount;
+                }
+
+                final int totalDrainedAmount = originalOutputAmount - outputAmount;
+                if (totalDrainedAmount > 0) {
+                    mStorageCurrent = mStorageCurrent.subtract(BigInteger.valueOf(totalDrainedAmount));
+                    if (mStorageCurrent.signum() < 0) {
+                        throw new IllegalStateException(
+                            "YOTTank drained beyond its fluid amount, indicating logic bug: " + mStorageCurrent);
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        structureBuild_EM(YOTTANK_BOTTOM, 2, 0, 0, stackSize, hintsOnly);
+        int height = stackSize.stackSize;
+        if (height > 15) height = 15;
+        structureBuild_EM(YOTTANK_TOP, 2, height + 2, 0, stackSize, hintsOnly);
+        while (height > 0) {
+            structureBuild_EM(YOTTANK_MID, 2, height, 0, stackSize, hintsOnly);
+            height--;
+        }
+    }
+
+    @Override
+    public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
+        float aX, float aY, float aZ, ItemStack toolStack) {
+        if (side == getBaseMetaTileEntity().getFrontFacing()) {
+            voidExcessEnabled ^= true;
+            aPlayer.addChatMessage(
+                new ChatComponentTranslation(
+                    voidExcessEnabled ? "yottank.chat.voidExcessEnabled" : "yottank.chat.voidExcessDisabled"));
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
+        float aX, float aY, float aZ, ItemStack toolStack) {
+        if (side == getBaseMetaTileEntity().getFrontFacing()) {
+            if (mLockedFluid == null) {
+                if (mFluid != null) {
+                    mLockedFluid = mFluid;
+                    aPlayer.addChatMessage(new ChatComponentTranslation("yottank.chat.1", getFluidName()));
+                } else {
+                    aPlayer.addChatMessage(new ChatComponentTranslation("yottank.chat.2"));
+                }
+                isFluidLocked = true;
+            } else {
+                mLockedFluid = null;
+                isFluidLocked = false;
+                aPlayer.addChatMessage(new ChatComponentTranslation("yottank.chat.0"));
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return DescTextLocalization.addText("YOTTank.hint", 8);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new YottaFluidTank(this.mName);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1537),
+                TextureFactory.of(textureFontOn), TextureFactory.builder()
+                    .addIcon(textureFontOn_Glow)
+                    .glow()
+                    .build() };
+            else return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1537),
+                TextureFactory.of(textureFontOff), TextureFactory.builder()
+                    .addIcon(textureFontOff_Glow)
+                    .glow()
+                    .build() };
+        } else return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(1537) };
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        int built = 0;
+        built += survivialBuildPiece(YOTTANK_BOTTOM, stackSize, 2, 0, 0, elementBudget, env, false, true);
+        int height = stackSize.stackSize;
+        if (height > 15) height = 15;
+        built += survivialBuildPiece(YOTTANK_TOP, stackSize, 2, height + 2, 0, elementBudget - built, env, false, true);
+        while (height > 0) {
+            built += survivialBuildPiece(YOTTANK_MID, stackSize, 2, height, 0, elementBudget - built, env, false, true);
+            height--;
+        }
+        return built;
+    }
+
+    @Override
+    protected boolean shouldDisplayCheckRecipeResult() {
+        return false;
+    }
+
+    @Override
+    protected void drawTexts(DynamicPositionedColumn screenElements, SlotWidget inventorySlot) {
+        super.drawTexts(screenElements, inventorySlot);
+
+        screenElements
+            .widget(
+                new TextWidget().setStringSupplier(
+                    () -> StatCollector.translateToLocal("gui.YOTTank.0") + " " + numberFormat.format(mStorage) + " L")
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.BigIntegerSyncer(() -> mStorage, val -> mStorage = val))
+            .widget(
+                new TextWidget()
+                    .setStringSupplier(() -> StatCollector.translateToLocal("gui.YOTTank.1") + " " + getFluidName())
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.FluidStackSyncer(() -> mFluid, val -> mFluid = val))
+            .widget(
+                new TextWidget()
+                    .setStringSupplier(
+                        () -> StatCollector.translateToLocal("gui.YOTTank.2") + " "
+                            + numberFormat.format(mStorageCurrent)
+                            + " L")
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.BigIntegerSyncer(() -> mStorageCurrent, val -> mStorageCurrent = val))
+            .widget(
+                new TextWidget()
+                    .setStringSupplier(
+                        () -> StatCollector.translateToLocal("gui.YOTTank.3") + " " + getLockedFluidName())
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.FluidStackSyncer(() -> mLockedFluid, val -> mLockedFluid = val))
+            .widget(new FakeSyncWidget.BooleanSyncer(() -> isFluidLocked, val -> isFluidLocked = val))
+            .widget(new FakeSyncWidget.BooleanSyncer(() -> voidExcessEnabled, val -> voidExcessEnabled = val));
+    }
+
+    @Override
+    protected ButtonWidget createSafeVoidButton() {
+        return (ButtonWidget) new ButtonWidget().setOnClick((clickData, widget) -> {
+            TecTech.proxy.playSound(getBaseMetaTileEntity(), "fx_click");
+            voidExcessEnabled = !voidExcessEnabled;
+        })
+            .setPlayClickSound(false)
+            .setBackground(() -> {
+                List<UITexture> ret = new ArrayList<>();
+                ret.add(TecTechUITextures.BUTTON_STANDARD_16x16);
+                ret.add(
+                    voidExcessEnabled ? TecTechUITextures.OVERLAY_BUTTON_SAFE_VOID_ON
+                        : TecTechUITextures.OVERLAY_BUTTON_SAFE_VOID_OFF);
+                return ret.toArray(new IDrawable[0]);
+            })
+            .setPos(174, doesBindPlayerInventory() ? 132 : 156)
+            .setSize(16, 16)
+            .addTooltip(StatCollector.translateToLocal("gui.YOTTank.button.void"))
+            .setTooltipShowUpDelay(TOOLTIP_DELAY);
+    }
+
+    @Override
+    protected ButtonWidget createPowerPassButton() {
+        return (ButtonWidget) new ButtonWidget().setOnClick((clickData, widget) -> {
+            TecTech.proxy.playSound(getBaseMetaTileEntity(), "fx_click");
+            isFluidLocked = !isFluidLocked;
+            if (!widget.getContext()
+                .isClient()) mLockedFluid = isFluidLocked ? mFluid : null;
+        })
+            .setPlayClickSound(false)
+            .setBackground(() -> {
+                List<UITexture> ret = new ArrayList<>();
+                ret.add(TecTechUITextures.BUTTON_STANDARD_16x16);
+                ret.add(isFluidLocked ? GG_UITextures.OVERLAY_BUTTON_LOCK_ON : GG_UITextures.OVERLAY_BUTTON_LOCK_OFF);
+                return ret.toArray(new IDrawable[0]);
+            })
+            .setPos(174, doesBindPlayerInventory() ? 116 : 140)
+            .setSize(16, 16)
+            .addTooltip(StatCollector.translateToLocal("gui.YOTTank.button.locking"))
+            .setTooltipShowUpDelay(TOOLTIP_DELAY);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
new file mode 100644
index 0000000000..3df71aa25a
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
@@ -0,0 +1,345 @@
+// copied from gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine
+// The origin one in gt made the abstract method private so i can't imp it.
+package goodgenerator.blocks.tileEntity.base;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.GT_HatchElement.*;
+import static gregtech.api.util.GT_StructureUtility.*;
+import static gregtech.api.util.GT_Utility.filterValidMTEs;
+
+import java.util.ArrayList;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.IStructureElementCheckOnly;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+
+public abstract class GT_MetaTileEntity_LargeTurbineBase extends
+    GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_LargeTurbineBase> implements ISurvivalConstructable {
+
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>>() {
+
+        @Override
+        protected IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> computeValue(Class<?> type) {
+            return StructureDefinition.<GT_MetaTileEntity_LargeTurbineBase>builder()
+                .addShape(
+                    STRUCTURE_PIECE_MAIN,
+                    transpose(
+                        new String[][] { { "     ", "xxxxx", "xxxxx", "xxxxx", "xxxxx", },
+                            { " --- ", "xcccx", "xchcx", "xchcx", "xcccx", },
+                            { " --- ", "xc~cx", "xh-hx", "xh-hx", "xcdcx", },
+                            { " --- ", "xcccx", "xchcx", "xchcx", "xcccx", },
+                            { "     ", "xxxxx", "xxxxx", "xxxxx", "xxxxx", }, }))
+                .addElement('c', lazy(t -> ofBlock(t.getCasingBlock(), t.getCasingMeta())))
+                .addElement('d', lazy(t -> Dynamo.newAny(t.getCasingTextureIndex(), 1)))
+                .addElement(
+                    'h',
+                    lazy(
+                        t -> buildHatchAdder(GT_MetaTileEntity_LargeTurbineBase.class)
+                            .atLeast(Maintenance, InputHatch, OutputHatch, OutputBus, InputBus, Muffler)
+                            .casingIndex(t.getCasingTextureIndex())
+                            .dot(2)
+                            .buildAndChain(t.getCasingBlock(), t.getCasingMeta())))
+                .addElement(
+                    'x',
+                    (IStructureElementCheckOnly<GT_MetaTileEntity_LargeTurbineBase>) (aContext, aWorld, aX, aY, aZ) -> {
+                        TileEntity tTile = aWorld.getTileEntity(aX, aY, aZ);
+                        return !(tTile instanceof IGregTechTileEntity) || !(((IGregTechTileEntity) tTile)
+                            .getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase);
+                    })
+                .build();
+        }
+    };
+
+    protected int baseEff = 0;
+    protected int optFlow = 0;
+    protected double realOptFlow = 0;
+    protected int storedFluid = 0;
+    protected int counter = 0;
+    protected boolean looseFit = false;
+    protected long maxPower = 0;
+
+    public GT_MetaTileEntity_LargeTurbineBase(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_LargeTurbineBase(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return getMaxEfficiency(aStack) > 0;
+    }
+
+    @Override
+    public IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> getStructureDefinition() {
+        return STRUCTURE_DEFINITION.get(getClass());
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        maxPower = 0;
+        if (checkPiece(STRUCTURE_PIECE_MAIN, 2, 2, 1) && mMaintenanceHatches.size() == 1
+            && mMufflerHatches.isEmpty() == (getPollutionPerTick(null) == 0)) {
+            maxPower = getMaximumOutput();
+            return true;
+        }
+        return false;
+    }
+
+    public abstract Block getCasingBlock();
+
+    public abstract int getCasingMeta();
+
+    public abstract int getCasingTextureIndex();
+
+    @Override
+    public boolean addToMachineList(IGregTechTileEntity tTileEntity, int aBaseCasingIndex) {
+        return addMaintenanceToMachineList(tTileEntity, getCasingTextureIndex())
+            || addInputToMachineList(tTileEntity, getCasingTextureIndex())
+            || addOutputToMachineList(tTileEntity, getCasingTextureIndex())
+            || addMufflerToMachineList(tTileEntity, getCasingTextureIndex());
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing() {
+        ItemStack controllerSlot = getControllerSlot();
+        if ((counter & 7) == 0
+            && (controllerSlot == null || !(controllerSlot.getItem() instanceof GT_MetaGenerated_Tool)
+                || controllerSlot.getItemDamage() < 170
+                || controllerSlot.getItemDamage() > 179)) {
+            stopMachine();
+            return CheckRecipeResultRegistry.NO_TURBINE_FOUND;
+        }
+        ArrayList<FluidStack> tFluids = getStoredFluids();
+        if (tFluids.size() > 0) {
+            if (baseEff == 0 || optFlow == 0
+                || counter >= 512
+                || this.getBaseMetaTileEntity()
+                    .hasWorkJustBeenEnabled()
+                || this.getBaseMetaTileEntity()
+                    .hasInventoryBeenModified()) {
+                counter = 0;
+                baseEff = GT_Utility.safeInt(
+                    (long) ((5F
+                        + ((GT_MetaGenerated_Tool) controllerSlot.getItem()).getToolCombatDamage(controllerSlot))
+                        * 1000F));
+                optFlow = GT_Utility.safeInt(
+                    (long) Math.max(
+                        Float.MIN_NORMAL,
+                        ((GT_MetaGenerated_Tool) controllerSlot.getItem()).getToolStats(controllerSlot)
+                            .getSpeedMultiplier() * GT_MetaGenerated_Tool.getPrimaryMaterial(controllerSlot).mToolSpeed
+                            * 50));
+                if (optFlow <= 0 || baseEff <= 0) {
+                    stopMachine(); // in case the turbine got removed
+                    return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+                }
+            } else {
+                counter++;
+            }
+        }
+
+        int newPower = fluidIntoPower(tFluids, optFlow, baseEff); // How much the turbine should be producing with this
+                                                                  // flow
+        int difference = newPower - this.mEUt; // difference between current output and new output
+
+        // Magic numbers: can always change by at least 10 eu/t, but otherwise by at most 1 percent of the difference in
+        // power level (per tick)
+        // This is how much the turbine can actually change during this tick
+        int maxChangeAllowed = Math.max(10, GT_Utility.safeInt((long) Math.abs(difference) / 100));
+
+        if (Math.abs(difference) > maxChangeAllowed) { // If this difference is too big, use the maximum allowed change
+            int change = maxChangeAllowed * (difference > 0 ? 1 : -1); // Make the change positive or negative.
+            this.mEUt += change; // Apply the change
+        } else this.mEUt = newPower;
+
+        if (this.mEUt <= 0) {
+            // stopMachine();
+            this.mEUt = 0;
+            this.mEfficiency = 0;
+            return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+        } else {
+            this.mMaxProgresstime = 1;
+            this.mEfficiencyIncrease = 10;
+            // Overvoltage is handled inside the MultiBlockBase when pushing out to dynamos. no need to do it here.
+            return CheckRecipeResultRegistry.GENERATING;
+        }
+    }
+
+    public abstract int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff);
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 1;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack)) {
+            return 0;
+        }
+        if (aStack.getItem() instanceof GT_MetaGenerated_Tool_01) {
+            return 10000;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return true;
+    }
+
+    public long getMaximumOutput() {
+        long aTotal = 0;
+        for (GT_MetaTileEntity_Hatch_Dynamo aDynamo : filterValidMTEs(mDynamoHatches)) {
+            long aVoltage = aDynamo.maxEUOutput();
+            aTotal = aDynamo.maxAmperesOut() * aVoltage;
+            break;
+        }
+        return aTotal;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        int mPollutionReduction = 0;
+        for (GT_MetaTileEntity_Hatch_Muffler tHatch : filterValidMTEs(mMufflerHatches)) {
+            mPollutionReduction = Math.max(tHatch.calculatePollutionReduction(100), mPollutionReduction);
+        }
+
+        String tRunning = mMaxProgresstime > 0
+            ? EnumChatFormatting.GREEN + StatCollector.translateToLocal("GT5U.turbine.running.true")
+                + EnumChatFormatting.RESET
+            : EnumChatFormatting.RED + StatCollector.translateToLocal("GT5U.turbine.running.false")
+                + EnumChatFormatting.RESET;
+        String tMaintainance = getIdealStatus() == getRepairStatus()
+            ? EnumChatFormatting.GREEN + StatCollector.translateToLocal("GT5U.turbine.maintenance.false")
+                + EnumChatFormatting.RESET
+            : EnumChatFormatting.RED + StatCollector.translateToLocal("GT5U.turbine.maintenance.true")
+                + EnumChatFormatting.RESET;
+        int tDura = 0;
+
+        if (mInventory[1] != null && mInventory[1].getItem() instanceof GT_MetaGenerated_Tool_01) {
+            tDura = GT_Utility.safeInt(
+                (long) (100.0f / GT_MetaGenerated_Tool.getToolMaxDamage(mInventory[1])
+                    * (GT_MetaGenerated_Tool.getToolDamage(mInventory[1])) + 1));
+        }
+
+        long storedEnergy = 0;
+        long maxEnergy = 0;
+        for (GT_MetaTileEntity_Hatch_Dynamo tHatch : filterValidMTEs(mDynamoHatches)) {
+            storedEnergy += tHatch.getBaseMetaTileEntity()
+                .getStoredEU();
+            maxEnergy += tHatch.getBaseMetaTileEntity()
+                .getEUCapacity();
+        }
+        String[] ret = new String[] {
+            // 8 Lines available for information panels
+            tRunning + ": "
+                + EnumChatFormatting.RED
+                + GT_Utility.formatNumbers(mEUt)
+                + EnumChatFormatting.RESET
+                + " EU/t", /* 1 */
+            tMaintainance, /* 2 */
+            StatCollector.translateToLocal("GT5U.turbine.efficiency") + ": "
+                + EnumChatFormatting.YELLOW
+                + (mEfficiency / 100F)
+                + EnumChatFormatting.RESET
+                + "%", /* 2 */
+            StatCollector.translateToLocal("GT5U.multiblock.energy") + ": "
+                + EnumChatFormatting.GREEN
+                + GT_Utility.formatNumbers(storedEnergy)
+                + EnumChatFormatting.RESET
+                + " EU / "
+                + /* 3 */ EnumChatFormatting.YELLOW
+                + GT_Utility.formatNumbers(maxEnergy)
+                + EnumChatFormatting.RESET
+                + " EU",
+            StatCollector.translateToLocal("GT5U.turbine.flow") + ": "
+                + EnumChatFormatting.YELLOW
+                + GT_Utility.formatNumbers(GT_Utility.safeInt((long) realOptFlow))
+                + EnumChatFormatting.RESET
+                + " L/t"
+                + /* 4 */ EnumChatFormatting.YELLOW
+                + " ("
+                + (looseFit ? StatCollector.translateToLocal("GT5U.turbine.loose")
+                    : StatCollector.translateToLocal("GT5U.turbine.tight"))
+                + ")", /* 5 */
+            StatCollector.translateToLocal("GT5U.turbine.fuel") + ": "
+                + EnumChatFormatting.GOLD
+                + GT_Utility.formatNumbers(storedFluid)
+                + EnumChatFormatting.RESET
+                + "L", /* 6 */
+            StatCollector.translateToLocal(
+                "GT5U.turbine.dmg") + ": " + EnumChatFormatting.RED + tDura + EnumChatFormatting.RESET + "%", /* 7 */
+            StatCollector.translateToLocal("GT5U.multiblock.pollution") + ": "
+                + EnumChatFormatting.GREEN
+                + mPollutionReduction
+                + EnumChatFormatting.RESET
+                + " %" /* 8 */
+        };
+        if (!this.getClass()
+            .getName()
+            .contains("Steam"))
+            ret[4] = StatCollector.translateToLocal("GT5U.turbine.flow") + ": "
+                + EnumChatFormatting.YELLOW
+                + GT_Utility.safeInt((long) realOptFlow)
+                + EnumChatFormatting.RESET
+                + " L/t";
+        return ret;
+    }
+
+    public boolean hasTurbine() {
+        return this.getMaxEfficiency(mInventory[1]) > 0;
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 2, 1);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 2, 2, 1, elementBudget, env, false, true);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_TooltipMultiBlockBase_EM.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_TooltipMultiBlockBase_EM.java
new file mode 100644
index 0000000000..010dc1db88
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_TooltipMultiBlockBase_EM.java
@@ -0,0 +1,62 @@
+package goodgenerator.blocks.tileEntity.base;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import net.minecraft.item.ItemStack;
+
+import org.lwjgl.input.Keyboard;
+
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+
+import gregtech.api.interfaces.ISecondaryDescribable;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+
+public abstract class GT_MetaTileEntity_TooltipMultiBlockBase_EM extends GT_MetaTileEntity_MultiblockBase_EM
+    implements ISecondaryDescribable {
+
+    private static final Map<Integer, GT_Multiblock_Tooltip_Builder> tooltips = new ConcurrentHashMap<>();
+
+    protected GT_MetaTileEntity_TooltipMultiBlockBase_EM(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    protected GT_MetaTileEntity_TooltipMultiBlockBase_EM(String aName) {
+        super(aName);
+    }
+
+    protected GT_Multiblock_Tooltip_Builder getTooltip() {
+        int tId = getBaseMetaTileEntity().getMetaTileID();
+        GT_Multiblock_Tooltip_Builder tooltip = tooltips.get(tId);
+        if (tooltip == null) {
+            tooltip = createTooltip();
+            tooltips.put(tId, tooltip);
+        }
+        return tooltip;
+    }
+
+    protected abstract GT_Multiblock_Tooltip_Builder createTooltip();
+
+    @Override
+    public String[] getDescription() {
+        return getCurrentDescription();
+    }
+
+    @Override
+    public boolean isDisplaySecondaryDescription() {
+        return Keyboard.isKeyDown(Keyboard.KEY_LSHIFT);
+    }
+
+    public String[] getPrimaryDescription() {
+        return getTooltip().getInformation();
+    }
+
+    public String[] getSecondaryDescription() {
+        return getTooltip().getStructureInformation();
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack itemStack) {
+        return getPollutionPerSecond(itemStack) / 20;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java
new file mode 100644
index 0000000000..5608d19ae4
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java
@@ -0,0 +1,733 @@
+package goodgenerator.blocks.tileEntity.base;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.util.GT_StructureUtility.filterByMTETier;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
+import static gregtech.api.util.GT_Utility.filterValidMTEs;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.ChunkCoordIntPair;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizons.modularui.api.NumberFormatMUI;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.SoundResource;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.interfaces.tileentity.IOverclockDescriptionProvider;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.objects.GT_ChunkManager;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.objects.overclockdescriber.FusionOverclockDescriber;
+import gregtech.api.objects.overclockdescriber.OverclockDescriber;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_HatchElementBuilder;
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_ParallelHelper;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.IDualInputHatch;
+
+public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+    implements IConstructable, ISurvivalConstructable, IOverclockDescriptionProvider {
+
+    public static final String MAIN_NAME = "largeFusion";
+    public static final int M = 1_000_000;
+    private boolean isLoadedChunk;
+    public GT_Recipe mLastRecipe;
+    public int para;
+    protected OverclockDescriber overclockDescriber;
+    private static final ClassValue<IStructureDefinition<LargeFusionComputer>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<LargeFusionComputer>>() {
+
+        @Override
+        protected IStructureDefinition<LargeFusionComputer> computeValue(Class<?> type) {
+            return StructureDefinition.<LargeFusionComputer>builder()
+                .addShape(MAIN_NAME, transpose(new String[][] { L0, L1, L2, L3, L2, L1, L0 }))
+                .addElement('H', lazy(x -> ofBlock(x.getCoilBlock(), x.getCoilMeta())))
+                .addElement('C', lazy(x -> ofBlock(x.getCasingBlock(), x.getCasingMeta())))
+                .addElement('B', lazy(x -> ofBlock(x.getGlassBlock(), x.getGlassMeta())))
+                .addElement(
+                    'I',
+                    lazy(
+                        x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
+                            .atLeast(
+                                GT_HatchElement.InputHatch.or(GT_HatchElement.InputBus),
+                                GT_HatchElement.OutputHatch)
+                            .adder(LargeFusionComputer::addFluidIO)
+                            .casingIndex(x.textureIndex())
+                            .dot(1)
+                            .hatchItemFilterAnd(x2 -> filterByMTETier(x2.hatchTier(), Integer.MAX_VALUE))
+                            .buildAndChain(x.getGlassBlock(), x.getGlassMeta())))
+                .addElement(
+                    'E',
+                    lazy(
+                        x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
+                            .anyOf(HatchElement.EnergyMulti.or(GT_HatchElement.Energy))
+                            .adder(LargeFusionComputer::addEnergyInjector)
+                            .casingIndex(x.textureIndex())
+                            .hatchItemFilterAnd(x2 -> filterByMTETier(x2.hatchTier(), Integer.MAX_VALUE))
+                            .dot(2)
+                            .buildAndChain(x.getCasingBlock(), x.getCasingMeta())))
+                .addElement('F', lazy(x -> ofFrame(x.getFrameBox())))
+                .build();
+        }
+    };
+
+    static {
+        Textures.BlockIcons.setCasingTextureForId(
+            52,
+            TextureFactory.of(
+                TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build()));
+    }
+
+    public LargeFusionComputer(String name) {
+        super(name);
+        useLongPower = true;
+        this.overclockDescriber = createOverclockDescriber();
+    }
+
+    public LargeFusionComputer(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+        useLongPower = true;
+        this.overclockDescriber = createOverclockDescriber();
+    }
+
+    protected OverclockDescriber createOverclockDescriber() {
+        return new FusionOverclockDescriber((byte) tier(), capableStartupCanonical());
+    }
+
+    @Nullable
+    @Override
+    public OverclockDescriber getOverclockDescriber() {
+        return overclockDescriber;
+    }
+
+    public abstract int tier();
+
+    @Override
+    public long maxEUStore() {
+        return capableStartupCanonical() * (Math.min(32, this.mEnergyHatches.size() + this.eEnergyMulti.size())) / 32L;
+    }
+
+    /**
+     * Unlike {@link #maxEUStore()}, this provides theoretical limit of startup EU, without considering the amount of
+     * hatches nor the room for extra energy. Intended for simulation.
+     */
+    public abstract long capableStartupCanonical();
+
+    public abstract Block getCasingBlock();
+
+    public abstract int getCasingMeta();
+
+    public abstract Block getCoilBlock();
+
+    public abstract int getCoilMeta();
+
+    public abstract Block getGlassBlock();
+
+    public abstract int getGlassMeta();
+
+    public abstract int hatchTier();
+
+    public abstract Materials getFrameBox();
+
+    public abstract int getMaxPara();
+
+    public abstract int extraPara(int startEnergy);
+
+    public int textureIndex() {
+        return 53;
+    }
+
+    public abstract ITexture getTextureOverlay();
+
+    @Override
+    public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aStack) {
+        return side != getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        // Migration code
+        if (lEUt > 0) {
+            lEUt = -lEUt;
+        }
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        this.eEnergyMulti.clear();
+        if (structureCheck_EM(MAIN_NAME, 23, 3, 40) && mInputHatches.size() + mDualInputHatches.size() != 0
+            && !mOutputHatches.isEmpty()
+            && (mEnergyHatches.size() + eEnergyMulti.size()) != 0) {
+            fixAllIssue();
+            return true;
+        }
+        return false;
+    }
+
+    public void fixAllIssue() {
+        mWrench = true;
+        mScrewdriver = true;
+        mSoftHammer = true;
+        mHardHammer = true;
+        mSolderingTool = true;
+        mCrowbar = true;
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean b) {
+        structureBuild_EM(MAIN_NAME, 23, 3, 40, itemStack, b);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        int realBudget = elementBudget >= 200 ? elementBudget : Math.min(200, elementBudget * 5);
+        return survivialBuildPiece(MAIN_NAME, stackSize, 23, 3, 40, realBudget, env, false, true);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) {
+            // if machine has stopped, stop chunkloading
+            GT_ChunkManager.releaseTicket((TileEntity) aBaseMetaTileEntity);
+            this.isLoadedChunk = false;
+        } else if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && !this.isLoadedChunk) {
+            // load a 3x3 area when machine is running
+            GT_ChunkManager.releaseTicket((TileEntity) aBaseMetaTileEntity);
+            int offX = aBaseMetaTileEntity.getFrontFacing().offsetX;
+            int offZ = aBaseMetaTileEntity.getFrontFacing().offsetZ;
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + 1 + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() - 1 + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + 1 + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() - 1 + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + 1 + offZ));
+            GT_ChunkManager.requestChunkLoad(
+                (TileEntity) aBaseMetaTileEntity,
+                new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() - 1 + offZ));
+            this.isLoadedChunk = true;
+        }
+
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (aTick % 400 == 0) fixAllIssue();
+            if (mEfficiency < 0) mEfficiency = 0;
+            if (mRunningOnLoad && checkMachine(aBaseMetaTileEntity, mInventory[1])) {
+                checkRecipe();
+            }
+            if (mUpdated) {
+                mUpdate = 50;
+                mUpdated = false;
+            }
+            if (--mUpdate == 0 || --mStartUpCheck == 0
+                || cyclicUpdate_EM()
+                || aBaseMetaTileEntity.hasWorkJustBeenEnabled()) {
+                if (mUpdate <= -1000) {
+                    mUpdate = 5000;
+                }
+                checkStructure(true, aBaseMetaTileEntity);
+            }
+            if (mStartUpCheck < 0) {
+                if (mMachine) {
+                    if (aBaseMetaTileEntity.getStoredEU() <= 0 && mMaxProgresstime > 0) {
+                        criticalStopMachine();
+                    }
+
+                    long energyLimit = getSingleHatchPower();
+                    List<GT_MetaTileEntity_Hatch> hatches = getExoticAndNormalEnergyHatchList();
+                    for (GT_MetaTileEntity_Hatch hatch : filterValidMTEs(hatches)) {
+                        long consumableEnergy = Math.min(hatch.getEUVar(), energyLimit);
+                        long receivedEnergy = Math
+                            .min(consumableEnergy, maxEUStore() - aBaseMetaTileEntity.getStoredEU());
+                        if (receivedEnergy > 0) {
+                            hatch.getBaseMetaTileEntity()
+                                .decreaseStoredEnergyUnits(receivedEnergy, false);
+                            aBaseMetaTileEntity.increaseStoredEnergyUnits(receivedEnergy, true);
+                        }
+                    }
+
+                    if (mMaxProgresstime > 0) {
+                        this.getBaseMetaTileEntity()
+                            .decreaseStoredEnergyUnits(-lEUt, true);
+                        if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) {
+                            if (mOutputItems != null)
+                                for (ItemStack tStack : mOutputItems) if (tStack != null) addOutput(tStack);
+                            if (mOutputFluids != null)
+                                for (FluidStack tStack : mOutputFluids) if (tStack != null) addOutput(tStack);
+                            mEfficiency = Math
+                                .max(0, Math.min(mEfficiency + mEfficiencyIncrease, getMaxEfficiency(mInventory[1])));
+                            mOutputItems = null;
+                            mOutputFluids = null;
+                            mProgresstime = 0;
+                            mMaxProgresstime = 0;
+                            mEfficiencyIncrease = 0;
+                            para = 0;
+                            if (aBaseMetaTileEntity.isAllowedToWork()) checkRecipe();
+                        }
+                    } else {
+                        if (aTick % 100 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled()
+                            || aBaseMetaTileEntity.hasInventoryBeenModified()) {
+                            turnCasingActive(mMaxProgresstime > 0);
+                            if (aBaseMetaTileEntity.isAllowedToWork()) {
+                                if (checkRecipe()) {
+                                    if (aBaseMetaTileEntity.getStoredEU()
+                                        < this.mLastRecipe.mSpecialValue + this.lEUt) {
+                                        mMaxProgresstime = 0;
+                                        turnCasingActive(false);
+                                        criticalStopMachine();
+                                    }
+                                    getBaseMetaTileEntity()
+                                        .decreaseStoredEnergyUnits(this.mLastRecipe.mSpecialValue + this.lEUt, false);
+                                }
+                            }
+                            if (mMaxProgresstime <= 0) mEfficiency = Math.max(0, mEfficiency - 1000);
+                        }
+                    }
+                } else {
+                    turnCasingActive(false);
+                    this.mLastRecipe = null;
+                    stopMachine();
+                }
+            }
+            aBaseMetaTileEntity
+                .setErrorDisplayID((aBaseMetaTileEntity.getErrorDisplayID() & ~127) | (mMachine ? 0 : 64));
+            aBaseMetaTileEntity.setActive(mMaxProgresstime > 0);
+        } else {
+            soundMagic(getActivitySound());
+        }
+    }
+
+    /**
+     * @return The power one hatch can deliver to the reactor
+     */
+    protected long getSingleHatchPower() {
+        return GT_Values.V[tier()] * getMaxPara() * extraPara(100) / 32;
+    }
+
+    public boolean turnCasingActive(boolean status) {
+        if (this.mEnergyHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) {
+                hatch.updateTexture(status ? 52 : 53);
+            }
+        }
+        if (this.eEnergyMulti != null) {
+            for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) {
+                hatch.updateTexture(status ? 52 : 53);
+            }
+        }
+        if (this.mOutputHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) {
+                hatch.updateTexture(status ? 52 : 53);
+            }
+        }
+        if (this.mInputHatches != null) {
+            for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) {
+                hatch.updateTexture(status ? 52 : 53);
+            }
+        }
+        if (this.mDualInputHatches != null) {
+            for (IDualInputHatch hatch : this.mDualInputHatches) {
+                hatch.updateTexture(status ? 52 : 53);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) return new ITexture[] { TextureFactory.builder()
+            .addIcon(MACHINE_CASING_FUSION_GLASS)
+            .extFacing()
+            .build(), getTextureOverlay() };
+        if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(52) };
+        return new ITexture[] { TextureFactory.builder()
+            .addIcon(MACHINE_CASING_FUSION_GLASS)
+            .extFacing()
+            .build() };
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public void onMachineBlockUpdate() {
+        mUpdate = 100;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return RecipeMaps.fusionRecipes;
+    }
+
+    @Override
+    public int getRecipeCatalystPriority() {
+        return -2;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected GT_ParallelHelper createParallelHelper(@NotNull GT_Recipe recipe) {
+                // When the fusion first loads and is still processing, it does the recipe check without consuming.
+                return super.createParallelHelper(recipe).setConsumption(!mRunningOnLoad);
+            }
+
+            @NotNull
+            @Override
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return overclockDescriber.createCalculator(super.createOverclockCalculator(recipe), recipe);
+            }
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult validateRecipe(@NotNull GT_Recipe recipe) {
+                if (!mRunningOnLoad) {
+                    if (recipe.mSpecialValue > maxEUStore()) {
+                        return CheckRecipeResultRegistry.insufficientStartupPower(recipe.mSpecialValue);
+                    }
+                    if (recipe.mEUt > GT_Values.V[tier()]) {
+                        return CheckRecipeResultRegistry.insufficientPower(recipe.mEUt);
+                    }
+                }
+                maxParallel = getMaxPara() * extraPara(recipe.mSpecialValue);
+                return CheckRecipeResultRegistry.SUCCESSFUL;
+            }
+
+            @NotNull
+            @Override
+            public CheckRecipeResult process() {
+                CheckRecipeResult result = super.process();
+                if (mRunningOnLoad) mRunningOnLoad = false;
+                turnCasingActive(result.wasSuccessful());
+                if (result.wasSuccessful()) {
+                    mLastRecipe = lastRecipe;
+                } else {
+                    mLastRecipe = null;
+                }
+                para = getCurrentParallels();
+                return result;
+            }
+        };
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        logic.setAvailableVoltage(GT_Values.V[tier()]);
+        logic.setAvailableAmperage(getSingleHatchPower() * 32 / GT_Values.V[tier()]);
+    }
+
+    @Override
+    public void onRemoval() {
+        if (this.isLoadedChunk) GT_ChunkManager.releaseTicket((TileEntity) getBaseMetaTileEntity());
+        super.onRemoval();
+    }
+
+    public int getChunkX() {
+        return getBaseMetaTileEntity().getXCoord() >> 4;
+    }
+
+    public int getChunkZ() {
+        return getBaseMetaTileEntity().getZCoord() >> 4;
+    }
+
+    private boolean addEnergyInjector(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) {
+        IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy tHatch) {
+            if (tHatch.getTierForStructure() < hatchTier()) return false;
+            tHatch.updateTexture(aBaseCasingIndex);
+            return mEnergyHatches.add(tHatch);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti tHatch) {
+            if (tHatch.getTierForStructure() < hatchTier()) return false;
+            tHatch.updateTexture(aBaseCasingIndex);
+            return eEnergyMulti.add(tHatch);
+        }
+        return false;
+    }
+
+    private boolean addFluidIO(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) {
+        IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch hatch) {
+            hatch.updateTexture(aBaseCasingIndex);
+            hatch.updateCraftingIcon(this.getMachineCraftingIcon());
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input tInput) {
+            if (tInput.getTierForStructure() < hatchTier()) return false;
+            tInput.mRecipeMap = getRecipeMap();
+            return mInputHatches.add(tInput);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output tOutput) {
+            if (tOutput.getTierForStructure() < hatchTier()) return false;
+            return mOutputHatches.add(tOutput);
+        }
+        if (aMetaTileEntity instanceof IDualInputHatch tInput) {
+            tInput.updateCraftingIcon(this.getMachineCraftingIcon());
+            return mDualInputHatches.add(tInput);
+        }
+        return false;
+    }
+
+    @Override
+    public IStructureDefinition<LargeFusionComputer> getStructure_EM() {
+        return STRUCTURE_DEFINITION.get(getClass());
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    protected ResourceLocation getActivitySound() {
+        return SoundResource.GT_MACHINES_FUSION_LOOP.resourceLocation;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        IGregTechTileEntity baseMetaTileEntity = getBaseMetaTileEntity();
+        String tier = switch (tier()) {
+            case 6 -> EnumChatFormatting.RED + "I" + EnumChatFormatting.RESET;
+            case 7 -> EnumChatFormatting.RED + "II" + EnumChatFormatting.RESET;
+            case 8 -> EnumChatFormatting.RED + "III" + EnumChatFormatting.RESET;
+            case 9 -> EnumChatFormatting.RED + "IV" + EnumChatFormatting.RESET;
+            default -> EnumChatFormatting.GOLD + "V" + EnumChatFormatting.RESET;
+        };
+        double plasmaOut = 0;
+        if (mMaxProgresstime > 0) plasmaOut = (double) mOutputFluids[0].amount / mMaxProgresstime;
+
+        return new String[] { EnumChatFormatting.BLUE + "Fusion Reactor MK " + EnumChatFormatting.RESET + tier,
+            StatCollector.translateToLocal("scanner.info.UX.0") + ": "
+                + EnumChatFormatting.LIGHT_PURPLE
+                + GT_Utility.formatNumbers(this.para)
+                + EnumChatFormatting.RESET,
+            StatCollector.translateToLocal("GT5U.fusion.req") + ": "
+                + EnumChatFormatting.RED
+                + GT_Utility.formatNumbers(-lEUt)
+                + EnumChatFormatting.RESET
+                + "EU/t",
+            StatCollector.translateToLocal("GT5U.multiblock.energy") + ": "
+                + EnumChatFormatting.GREEN
+                + GT_Utility.formatNumbers(baseMetaTileEntity != null ? baseMetaTileEntity.getStoredEU() : 0)
+                + EnumChatFormatting.RESET
+                + " EU / "
+                + EnumChatFormatting.YELLOW
+                + GT_Utility.formatNumbers(maxEUStore())
+                + EnumChatFormatting.RESET
+                + " EU",
+            StatCollector.translateToLocal("GT5U.fusion.plasma") + ": "
+                + EnumChatFormatting.YELLOW
+                + GT_Utility.formatNumbers(plasmaOut)
+                + EnumChatFormatting.RESET
+                + "L/t" };
+    }
+
+    protected long energyStorageCache;
+    protected static final NumberFormatMUI numberFormat = new NumberFormatMUI();
+
+    @Override
+    protected void drawTexts(DynamicPositionedColumn screenElements, SlotWidget inventorySlot) {
+        super.drawTexts(screenElements, inventorySlot);
+
+        screenElements
+            .widget(
+                new TextWidget()
+                    .setStringSupplier(
+                        () -> StatCollector.translateToLocal("gui.LargeFusion.0") + " "
+                            + numberFormat.format(energyStorageCache)
+                            + " EU")
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.LongSyncer(this::maxEUStore, val -> energyStorageCache = val))
+            .widget(
+                new TextWidget()
+                    .setStringSupplier(
+                        () -> StatCollector.translateToLocal("gui.LargeFusion.1") + " "
+                            + numberFormat.format(getEUVar())
+                            + " EU")
+                    .setDefaultColor(COLOR_TEXT_WHITE.get())
+                    .setEnabled(widget -> getBaseMetaTileEntity().getErrorDisplayID() == 0))
+            .widget(new FakeSyncWidget.LongSyncer(this::getEUVar, this::setEUVar));
+    }
+
+    public static final String[] L0 = { "                                               ",
+        "                                               ", "                    FCCCCCF                    ",
+        "                    FCIBICF                    ", "                    FCCCCCF                    ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "  FFF                                     FFF  ",
+        "  CCC                                     CCC  ", "  CIC                                     CIC  ",
+        "  CBC                                     CBC  ", "  CIC                                     CIC  ",
+        "  CCC                                     CCC  ", "  FFF                                     FFF  ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                                               ",
+        "                                               ", "                    FCCCCCF                    ",
+        "                    FCIBICF                    ", "                    FCCCCCF                    ",
+        "                                               ", "                                               ", };
+
+    public static final String[] L1 = { "                                               ",
+        "                    FCBBBCF                    ", "                   CC     CC                   ",
+        "                CCCCC     CCCCC                ", "              CCCCCCC     CCCCCCC              ",
+        "            CCCCCCC FCBBBCF CCCCCCC            ", "           CCCCC               CCCCC           ",
+        "          CCCC                   CCCC          ", "         CCC                       CCC         ",
+        "        CCC                         CCC        ", "       CCC                           CCC       ",
+        "      CCC                             CCC      ", "     CCC                               CCC     ",
+        "     CCC                               CCC     ", "    CCC                                 CCC    ",
+        "    CCC                                 CCC    ", "   CCC                                   CCC   ",
+        "   CCC                                   CCC   ", "   CCC                                   CCC   ",
+        "  CCC                                     CCC  ", " FCCCF                                   FCCCF ",
+        " C   C                                   C   C ", " B   B                                   B   B ",
+        " B   B                                   B   B ", " B   B                                   B   B ",
+        " C   C                                   C   C ", " FCCCF                                   FCCCF ",
+        "  CCC                                     CCC  ", "   CCC                                   CCC   ",
+        "   CCC                                   CCC   ", "   CCC                                   CCC   ",
+        "    CCC                                 CCC    ", "    CCC                                 CCC    ",
+        "     CCC                               CCC     ", "     CCC                               CCC     ",
+        "      CCC                             CCC      ", "       CCC                           CCC       ",
+        "        CCC                         CCC        ", "         CCC                       CCC         ",
+        "          CCCC                   CCCC          ", "           CCCCC               CCCCC           ",
+        "            CCCCCCC FCBBBCF CCCCCCC            ", "              CCCCCCC     CCCCCCC              ",
+        "                CCCCC     CCCCC                ", "                   CC     CC                   ",
+        "                    FCBBBCF                    ", "                                               ", };
+
+    public static final String[] L2 = { "                    FCCCCCF                    ",
+        "                   CC     CC                   ", "                CCCCC     CCCCC                ",
+        "              CCCCCHHHHHHHHHCCCCC              ", "            CCCCHHHCC     CCHHHCCCC            ",
+        "           CCCHHCCCCC     CCCCCHHCCC           ", "          ECHHCCCCC FCCCCCF CCCCCHHCE          ",
+        "         CCHCCCC               CCCCHCC         ", "        CCHCCC                   CCCHCC        ",
+        "       CCHCE                       ECHCC       ", "      ECHCC                         CCHCE      ",
+        "     CCHCE                           ECHCC     ", "    CCHCC                             CCHCC    ",
+        "    CCHCC                             CCHCC    ", "   CCHCC                               CCHCC   ",
+        "   CCHCC                               CCHCC   ", "  CCHCC                                 CCHCC  ",
+        "  CCHCC                                 CCHCC  ", "  CCHCC                                 CCHCC  ",
+        " CCHCC                                   CCHCC ", "FCCHCCF                                 FCCHCCF",
+        "C  H  C                                 C  H  C", "C  H  C                                 C  H  C",
+        "C  H  C                                 C  H  C", "C  H  C                                 C  H  C",
+        "C  H  C                                 C  H  C", "FCCHCCF                                 FCCHCCF",
+        " CCHCC                                   CCHCC ", "  CCHCC                                 CCHCC  ",
+        "  CCHCC                                 CCHCC  ", "  CCHCC                                 CCHCC  ",
+        "   CCHCC                               CCHCC   ", "   CCHCC                               CCHCC   ",
+        "    CCHCC                             CCHCC    ", "    CCHCC                             CCHCC    ",
+        "     CCHCE                           ECHCC     ", "      ECHCC                         CCHCE      ",
+        "       CCHCE                       ECHCC       ", "        CCHCCC                   CCCHCC        ",
+        "         CCHCCCC               CCCCHCC         ", "          ECHHCCCCC FCCCCCF CCCCCHHCE          ",
+        "           CCCHHCCCCC     CCCCCHHCCC           ", "            CCCCHHHCC     CCHHHCCCC            ",
+        "              CCCCCHHHHHHHHHCCCCC              ", "                CCCCC     CCCCC                ",
+        "                   CC     CC                   ", "                    FCCCCCF                    ", };
+
+    public static final String[] L3 = { "                    FCIBICF                    ",
+        "                   CC     CC                   ", "                CCCHHHHHHHHHCCC                ",
+        "              CCHHHHHHHHHHHHHHHCC              ", "            CCHHHHHHHHHHHHHHHHHHHCC            ",
+        "           CHHHHHHHCC     CCHHHHHHHC           ", "          CHHHHHCCC FCIBICF CCCHHHHHC          ",
+        "         CHHHHCC               CCHHHHC         ", "        CHHHCC                   CCHHHC        ",
+        "       CHHHC                       CHHHC       ", "      CHHHC                         CHHHC      ",
+        "     CHHHC                           CHHHC     ", "    CHHHC                             CHHHC    ",
+        "    CHHHC                             CHHHC    ", "   CHHHC                               CHHHC   ",
+        "   CHHHC                               CHHHC   ", "  CHHHC                                 CHHHC  ",
+        "  CHHHC                                 CHHHC  ", "  CHHHC                                 CHHHC  ",
+        " CHHHC                                   CHHHC ", "FCHHHCF                                 FCHHHCF",
+        "C HHH C                                 C HHH C", "I HHH I                                 I HHH I",
+        "B HHH B                                 B HHH B", "I HHH I                                 I HHH I",
+        "C HHH C                                 C HHH C", "FCHHHCF                                 FCHHHCF",
+        " CHHHC                                   CHHHC ", "  CHHHC                                 CHHHC  ",
+        "  CHHHC                                 CHHHC  ", "  CHHHC                                 CHHHC  ",
+        "   CHHHC                               CHHHC   ", "   CHHHC                               CHHHC   ",
+        "    CHHHC                             CHHHC    ", "    CHHHC                             CHHHC    ",
+        "     CHHHC                           CHHHC     ", "      CHHHC                         CHHHC      ",
+        "       CHHHC                       CHHHC       ", "        CHHHCC                   CCHHHC        ",
+        "         CHHHHCC               CCHHHHC         ", "          CHHHHHCCC FCI~ICF CCCHHHHHC          ",
+        "           CHHHHHHHCC     CCHHHHHHHC           ", "            CCHHHHHHHHHHHHHHHHHHHCC            ",
+        "              CCHHHHHHHHHHHHHHHCC              ", "                CCCHHHHHHHHHCCC                ",
+        "                   CC     CC                   ", "                    FCIBICF                    ", };
+}
diff --git a/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java
new file mode 100644
index 0000000000..7d87e6fdd1
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java
@@ -0,0 +1,53 @@
+package goodgenerator.blocks.tileEntity.base;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.INameFunction;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.IStatusFunction;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.LedStatus;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.Parameters;
+
+import gregtech.api.objects.overclockdescriber.OverclockDescriber;
+import gregtech.api.util.AdvancedFusionOverclockDescriber;
+
+public abstract class LargeFusionComputerPP extends LargeFusionComputer {
+
+    protected Parameters.Group.ParameterIn batchSetting;
+
+    /** Name of the batch setting */
+    private static final INameFunction<LargeFusionComputerPP> BATCH_SETTING_NAME = (base,
+        p) -> translateToLocal("gt.blockmachines.LargeFusionComputerPP.cfgi.0"); // Batch size
+    /** Status of the batch setting */
+    private static final IStatusFunction<LargeFusionComputerPP> BATCH_STATUS = (base, p) -> LedStatus
+        .fromLimitsInclusiveOuterBoundary(p.get(), 1, 0, 32, 128);
+
+    public LargeFusionComputerPP(String name) {
+        super(name);
+    }
+
+    public LargeFusionComputerPP(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    protected OverclockDescriber createOverclockDescriber() {
+        return new AdvancedFusionOverclockDescriber((byte) tier(), capableStartupCanonical());
+    }
+
+    @Override
+    protected void parametersInstantiation_EM() {
+        batchSetting = parametrization.getGroup(9, false)
+            .makeInParameter(1, 1, BATCH_SETTING_NAME, BATCH_STATUS);
+    }
+
+    @Override
+    protected int getMaxBatchSize() {
+        // Batch size 1~128
+        return (int) Math.min(Math.max(batchSetting.get(), 1.0D), 128.0D);
+    }
+
+    @Override
+    public boolean getDefaultBatchMode() {
+        return true;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/client/ClientProxy.java b/goodgen/src/main/java/goodgenerator/client/ClientProxy.java
new file mode 100644
index 0000000000..b8a885cab6
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/client/ClientProxy.java
@@ -0,0 +1,24 @@
+package goodgenerator.client;
+
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import goodgenerator.common.CommonProxy;
+
+public class ClientProxy extends CommonProxy {
+
+    @Override
+    public void preInit(FMLPreInitializationEvent event) {
+        super.preInit(event);
+    }
+
+    @Override
+    public void init(FMLInitializationEvent event) {
+        super.init(event);
+    }
+
+    @Override
+    public void postInit(FMLPostInitializationEvent event) {
+        super.postInit(event);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/client/GUI/GG_UITextures.java b/goodgen/src/main/java/goodgenerator/client/GUI/GG_UITextures.java
new file mode 100644
index 0000000000..2b9bc8df84
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/client/GUI/GG_UITextures.java
@@ -0,0 +1,22 @@
+package goodgenerator.client.GUI;
+
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+
+public class GG_UITextures {
+
+    private static final String MODID = "goodgenerator";
+
+    public static final UITexture PICTURE_NAQUADAH_REACTOR = UITexture.fullImage(MODID, "gui/picture/naquadah_reactor");
+    public static final UITexture PICTURE_NEUTRON_ACTIVATOR = UITexture
+        .fullImage(MODID, "gui/picture/neutron_activator");
+    public static final UITexture PICTURE_EXTREME_HEAT_EXCHANGER = UITexture
+        .fullImage(MODID, "gui/picture/extreme_heat_exchanger");
+    public static final UITexture PICTURE_COMPONENT_ASSLINE = UITexture
+        .fullImage(MODID, "gui/picture/component_assline");
+    public static final UITexture OVERLAY_BUTTON_LOCK_OFF = UITexture.fullImage(MODID, "gui/overlay_button/lock_off");
+    public static final UITexture OVERLAY_BUTTON_LOCK_ON = UITexture.fullImage(MODID, "gui/overlay_button/lock_on");
+    public static final UITexture OVERLAY_BUTTON_ASSEMBLER_MODE = UITexture
+        .fullImage(MODID, "gui/overlay_button/assembler_mode");
+    public static final UITexture OVERLAY_BUTTON_PRECISE_MODE = UITexture
+        .fullImage(MODID, "gui/overlay_button/precise_mode");
+}
diff --git a/goodgen/src/main/java/goodgenerator/client/render/BlockRenderHandler.java b/goodgen/src/main/java/goodgenerator/client/render/BlockRenderHandler.java
new file mode 100644
index 0000000000..01893339f5
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/client/render/BlockRenderHandler.java
@@ -0,0 +1,135 @@
+package goodgenerator.client.render;
+
+import static gregtech.common.render.GT_Renderer_Block.*;
+import static net.minecraftforge.common.util.ForgeDirection.*;
+import static net.minecraftforge.common.util.ForgeDirection.EAST;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.world.IBlockAccess;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import goodgenerator.blocks.regularBlock.ITextureBlock;
+import gregtech.GT_Mod;
+
+public class BlockRenderHandler implements ISimpleBlockRenderingHandler {
+
+    public static final float blockMin = 0.0F;
+    public static final float blockMax = 1.0F;
+    public static BlockRenderHandler INSTANCE;
+    public final int mRenderID;
+
+    public BlockRenderHandler() {
+        this.mRenderID = RenderingRegistry.getNextAvailableRenderId();
+        INSTANCE = this;
+        RenderingRegistry.registerBlockHandler(this);
+    }
+
+    @Override
+    public void renderInventoryBlock(Block aBlock, int metadata, int modelId, RenderBlocks aRenderer) {
+        aRenderer.enableAO = false;
+        aRenderer.useInventoryTint = true;
+
+        GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+
+        if (aBlock instanceof ITextureBlock) {
+            ITextureBlock tc = (ITextureBlock) aBlock;
+            aBlock.setBlockBoundsForItemRender();
+            aRenderer.setRenderBoundsFromBlock(aBlock);
+            renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, metadata, DOWN), true);
+            renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, metadata, UP), true);
+            renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, metadata, NORTH), true);
+            renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, metadata, SOUTH), true);
+            renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, metadata, WEST), true);
+            renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, metadata, EAST), true);
+        }
+
+        aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax);
+        aRenderer.setRenderBoundsFromBlock(aBlock);
+
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+        aRenderer.useInventoryTint = false;
+    }
+
+    @Override
+    public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID,
+        RenderBlocks aRenderer) {
+        aRenderer.enableAO = Minecraft.isAmbientOcclusionEnabled() && GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion;
+        aRenderer.useInventoryTint = false;
+        if (aBlock instanceof ITextureBlock) {
+            aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax);
+            aRenderer.setRenderBoundsFromBlock(aBlock);
+            ITextureBlock tc = (ITextureBlock) aBlock;
+            renderNegativeYFacing(
+                aWorld,
+                aRenderer,
+                aBlock,
+                aX,
+                aY,
+                aZ,
+                tc.getTexture(aBlock, DOWN, aWorld, aX, aY, aZ),
+                true);
+            renderPositiveYFacing(
+                aWorld,
+                aRenderer,
+                aBlock,
+                aX,
+                aY,
+                aZ,
+                tc.getTexture(aBlock, UP, aWorld, aX, aY, aZ),
+                true);
+            renderNegativeZFacing(
+                aWorld,
+                aRenderer,
+                aBlock,
+                aX,
+                aY,
+                aZ,
+                tc.getTexture(aBlock, NORTH, aWorld, aX, aY, aZ),
+                true);
+            renderPositiveZFacing(
+                aWorld,
+                aRenderer,
+                aBlock,
+                aX,
+                aY,
+                aZ,
+                tc.getTexture(aBlock, SOUTH, aWorld, aX, aY, aZ),
+                true);
+            renderNegativeXFacing(
+                aWorld,
+                aRenderer,
+                aBlock,
+                aX,
+                aY,
+                aZ,
+                tc.getTexture(aBlock, WEST, aWorld, aX, aY, aZ),
+                true);
+            renderPositiveXFacing(
+                aWorld,
+                aRenderer,
+                aBlock,
+                aX,
+                aY,
+                aZ,
+                tc.getTexture(aBlock, EAST, aWorld, aX, aY, aZ),
+                true);
+        }
+        return false;
+    }
+
+    @Override
+    public boolean shouldRender3DInInventory(int modelId) {
+        return true;
+    }
+
+    @Override
+    public int getRenderId() {
+        return this.mRenderID;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/common/CommonProxy.java b/goodgen/src/main/java/goodgenerator/common/CommonProxy.java
new file mode 100644
index 0000000000..05bf053bb7
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/common/CommonProxy.java
@@ -0,0 +1,14 @@
+package goodgenerator.common;
+
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+
+public class CommonProxy {
+
+    public void preInit(FMLPreInitializationEvent event) {}
+
+    public void init(FMLInitializationEvent event) {}
+
+    public void postInit(FMLPostInitializationEvent event) {}
+}
diff --git a/goodgen/src/main/java/goodgenerator/crossmod/ic2/CropsLoader.java b/goodgen/src/main/java/goodgenerator/crossmod/ic2/CropsLoader.java
new file mode 100644
index 0000000000..0c94742ddb
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/crossmod/ic2/CropsLoader.java
@@ -0,0 +1,10 @@
+package goodgenerator.crossmod.ic2;
+
+import ic2.api.crops.Crops;
+
+public class CropsLoader {
+
+    public static void registerCrops() {
+        Crops.instance.registerCrop(new GGCropsSaltyRoot("saltroot"));
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/crossmod/ic2/GGCropsSaltyRoot.java b/goodgen/src/main/java/goodgenerator/crossmod/ic2/GGCropsSaltyRoot.java
new file mode 100644
index 0000000000..b17959b44a
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/crossmod/ic2/GGCropsSaltyRoot.java
@@ -0,0 +1,129 @@
+package goodgenerator.crossmod.ic2;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.StatCollector;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.main.GoodGenerator;
+import goodgenerator.util.ItemRefer;
+import ic2.api.crops.CropCard;
+import ic2.api.crops.ICropTile;
+import speiger.src.crops.api.ICropCardInfo;
+
+public class GGCropsSaltyRoot extends CropCard implements ICropCardInfo {
+
+    private final String cropName;
+
+    public GGCropsSaltyRoot(String name) {
+        this.cropName = name;
+    }
+
+    @Override
+    public String name() {
+        return cropName;
+    }
+
+    @Override
+    public int tier() {
+        return 4;
+    }
+
+    @Override
+    public int stat(int n) {
+        return 0;
+    }
+
+    @Override
+    public String[] attributes() {
+        return new String[] { "Salt", "Gray", "Root", "Hydrophobic" };
+    }
+
+    @Override
+    public int maxSize() {
+        return 3;
+    }
+
+    @Override
+    public boolean canGrow(ICropTile crop) {
+        return crop.getSize() < maxSize();
+    }
+
+    @Override
+    public int getOptimalHavestSize(ICropTile crop) {
+        return 3;
+    }
+
+    @Override
+    public boolean canBeHarvested(ICropTile crop) {
+        return crop.getSize() == 3;
+    }
+
+    @Override
+    public ItemStack getGain(ICropTile crop) {
+        return ItemRefer.Salty_Root.get(1);
+    }
+
+    @Override
+    public String discoveredBy() {
+        return "GlodBlock";
+    }
+
+    @Override
+    public String owner() {
+        return GoodGenerator.MOD_ID;
+    }
+
+    @Override
+    public String displayName() {
+        return StatCollector.translateToLocal(
+            "crops." + cropName.toLowerCase()
+                .replace(" ", ""));
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerSprites(IIconRegister iconRegister) {
+        textures = new IIcon[maxSize()];
+        for (int i = 1; i <= textures.length; i++) {
+            textures[i - 1] = iconRegister.registerIcon(GoodGenerator.MOD_ID + ":crops/" + name() + "." + i);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getSprite(ICropTile crop) {
+        if (crop.getSize() <= 0 || crop.getSize() > textures.length) return null;
+        return textures[crop.getSize() - 1];
+    }
+
+    @Override
+    public boolean canCross(ICropTile crop) {
+        return crop.getSize() > 1;
+    }
+
+    @Override
+    public float dropGainChance() {
+        return 4.0F;
+    }
+
+    @Override
+    public int weightInfluences(ICropTile crop, float humidity, float nutrients, float air) {
+        return (int) (-humidity + nutrients * 2 + air);
+    }
+
+    @Override
+    public List<String> getCropInformation() {
+        return Arrays.asList("It prefers dry environment.", "Inedible.");
+    }
+
+    @Override
+    public ItemStack getDisplayItem() {
+        return ItemRefer.Salty_Root.get(1);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java b/goodgen/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java
new file mode 100644
index 0000000000..e28f09885e
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java
@@ -0,0 +1,38 @@
+package goodgenerator.crossmod.nei;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import codechicken.nei.api.API;
+import codechicken.nei.api.IConfigureNEI;
+import goodgenerator.main.GoodGenerator;
+
+public class NEI_Config implements IConfigureNEI {
+
+    public static boolean isAdded = true;
+
+    @Override
+    public void loadConfig() {
+        NEI_Config.isAdded = false;
+        NEI_Config.isAdded = true;
+    }
+
+    public static void hide(Block aBlock) {
+        API.hideItem(new ItemStack(aBlock, 1));
+    }
+
+    public static void hide(Item aItem) {
+        API.hideItem(new ItemStack(aItem, 1));
+    }
+
+    @Override
+    public String getName() {
+        return "Good Generator NEI Plugin";
+    }
+
+    @Override
+    public String getVersion() {
+        return GoodGenerator.VERSION;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/crossmod/thaumcraft/LargeEssentiaEnergyData.java b/goodgen/src/main/java/goodgenerator/crossmod/thaumcraft/LargeEssentiaEnergyData.java
new file mode 100644
index 0000000000..6d3249501e
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/crossmod/thaumcraft/LargeEssentiaEnergyData.java
@@ -0,0 +1,146 @@
+package goodgenerator.crossmod.thaumcraft;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import thaumcraft.api.aspects.Aspect;
+
+public class LargeEssentiaEnergyData {
+
+    public static final HashMap<Aspect, FuelData> ASPECT_FUEL_DATA = new HashMap<>();
+
+    public static String readJsonFile() {
+        try {
+            URL url = Thread.currentThread()
+                .getContextClassLoader()
+                .getResource("assets/goodgenerator/data/essentia.json");
+            assert url != null;
+            BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8));
+            String s;
+            StringBuilder sb = new StringBuilder();
+            while ((s = in.readLine()) != null) {
+                sb.append(s);
+            }
+            in.close();
+            return sb.toString();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static void processEssentiaData() {
+        String data = readJsonFile();
+        if (data == null) {
+            return;
+        }
+        JsonParser jsonParser = new JsonParser();
+        JsonObject jsonObject = (JsonObject) jsonParser.parse(data);
+        JsonArray jsonArray = jsonObject.get("Essentia")
+            .getAsJsonArray();
+        for (JsonElement elm : jsonArray) {
+            JsonObject essData = elm.getAsJsonObject();
+            String aspectName = essData.get("name")
+                .getAsString();
+            Aspect aspect = Aspect.getAspect(aspectName.toLowerCase());
+            if (aspect != null) {
+                int fuel = essData.get("fuelValue")
+                    .getAsInt();
+                String cate = essData.get("category")
+                    .getAsString();
+                float ceo = essData.get("consumeCeo")
+                    .getAsFloat();
+                ASPECT_FUEL_DATA.put(aspect, new FuelData(fuel, cate, ceo));
+            }
+        }
+    }
+
+    public static int getAspectTypeIndex(Aspect aspect) {
+        if (ASPECT_FUEL_DATA.containsKey(aspect)) {
+            return ASPECT_FUEL_DATA.get(aspect)
+                .getCategoryIndex();
+        } else return -1;
+    }
+
+    public static String getAspectType(Aspect aspect) {
+        if (ASPECT_FUEL_DATA.containsKey(aspect)) {
+            return ASPECT_FUEL_DATA.get(aspect)
+                .getCategory();
+        } else return null;
+    }
+
+    public static int getAspectFuelValue(Aspect aspect) {
+        if (ASPECT_FUEL_DATA.containsKey(aspect)) {
+            return ASPECT_FUEL_DATA.get(aspect)
+                .getFuelValue();
+        } else return 0;
+    }
+
+    public static float getAspectCeo(Aspect aspect) {
+        if (ASPECT_FUEL_DATA.containsKey(aspect)) {
+            return ASPECT_FUEL_DATA.get(aspect)
+                .getConsumeSpeed();
+        } else return 0;
+    }
+}
+
+class FuelData {
+
+    private final int fuelValue;
+    private final String category;
+    private final float consumeSpeed;
+
+    FuelData(int basicValue, String cate, float ceo) {
+        fuelValue = basicValue;
+        category = cate;
+        consumeSpeed = ceo;
+    }
+
+    public int getFuelValue() {
+        return fuelValue;
+    }
+
+    public float getConsumeSpeed() {
+        return consumeSpeed;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public int getCategoryIndex() {
+        switch (category) {
+            case "NORMAL":
+                return 0;
+            case "AIR":
+                return 1;
+            case "THERMAL":
+                return 2;
+            case "UNSTABLE":
+                return 3;
+            case "VICTUS":
+                return 4;
+            case "TAINTED":
+                return 5;
+            case "MECHANICS":
+                return 6;
+            case "SPRITE":
+                return 7;
+            case "RADIATION":
+                return 8;
+            case "ELECTRIC":
+                return 9;
+            default:
+                return -1;
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/crossmod/thaumcraft/Research.java b/goodgen/src/main/java/goodgenerator/crossmod/thaumcraft/Research.java
new file mode 100644
index 0000000000..5f18c20ae1
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/crossmod/thaumcraft/Research.java
@@ -0,0 +1,673 @@
+package goodgenerator.crossmod.thaumcraft;
+
+import static gregtech.api.enums.Mods.Automagy;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.enums.Mods.ThaumicBases;
+import static gregtech.api.enums.Mods.ThaumicEnergistics;
+import static gregtech.api.enums.Mods.ThaumicTinkerer;
+import static gregtech.api.enums.Mods.WitchingGadgets;
+import static thaumcraft.api.ThaumcraftApi.addArcaneCraftingRecipe;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+
+import goodgenerator.util.DescTextLocalization;
+import goodgenerator.util.ItemRefer;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TC_Aspects;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import ic2.core.Ic2Items;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.common.config.ConfigBlocks;
+import thaumcraft.common.config.ConfigItems;
+
+public class Research {
+
+    public static void addResearch() {
+        DescTextLocalization.addText("research.ESSENTIA_GENERATOR.page", 4);
+        DescTextLocalization.addText("research.ESSENTIA_CELL.page", 1);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_BLANK.page", 1);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_AIR.page", 2);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_THERMAL.page", 3);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_UNSTABLE.page", 3);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_VICTUS.page", 3);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_TAINTED.page", 4);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_MECHANICS.page", 3);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_SPRITE.page", 3);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_RADIATION.page", 3);
+        DescTextLocalization.addText("research.ESSENTIA_UPGRADE_ELECTRIC.page", 2);
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_GENERATOR",
+            "Combustion Engine in Magic World",
+            "Will it cause Flux pollution?",
+            new String[] { "INFUSION" },
+            "ARTIFICE",
+            ItemRefer.Large_Essentia_Generator.get(1),
+            3,
+            0,
+            -9,
+            3,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PRAECANTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_GENERATOR.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_GENERATOR",
+                    ItemList.Hull_HV.get(1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Advanced, 1L),
+                        new ItemStack(ConfigBlocks.blockJar, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Thaumium, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Emerald, 1L),
+                        new ItemStack(ConfigBlocks.blockWoodenDevice, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.spring, Materials.Manyullyn, 1L), Ic2Items.teslaCoil,
+                        ItemList.Sensor_MV.get(1) },
+                    ItemRefer.Large_Essentia_Generator.get(1),
+                    6,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PRAECANTATIO, 32),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 32))),
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_GENERATOR",
+                    ItemList.Hatch_Input_HV.get(1),
+                    new ItemStack[] { new ItemStack(ConfigBlocks.blockJar, 1), ItemRefer.Magic_Casing.get(1),
+                        new ItemStack(ConfigBlocks.blockTube, 1), ItemList.Electric_Pump_MV.get(1L) },
+                    ItemRefer.Essentia_Hatch.get(1),
+                    6,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 64),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 32),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 32))),
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_GENERATOR",
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Thaumium, 1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.pipeTiny, Materials.Titanium, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ElectricalSteel, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ElectricalSteel, 1),
+                        ItemList.Electric_Pump_EV.get(1L), new ItemStack(ConfigBlocks.blockTube, 1, 4),
+                        new ItemStack(ConfigBlocks.blockCosmeticOpaque, 1, 2), },
+                    ItemRefer.Essentia_Cell_T1.get(1),
+                    4,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 32),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 32),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 16))),
+                addArcaneCraftingRecipe(
+                    "ESSENTIA_GENERATOR",
+                    ItemRefer.Magic_Casing.get(1),
+                    new AspectList().add(Aspect.AIR, 50)
+                        .add(Aspect.FIRE, 50)
+                        .add(Aspect.ORDER, 50),
+                    "SCS",
+                    "GAG",
+                    "SCS",
+                    'S',
+                    new ItemStack(ConfigItems.itemResource, 1, 14),
+                    'C',
+                    GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Thaumium, 1),
+                    'G',
+                    Ic2Items.reinforcedGlass,
+                    'A',
+                    Ic2Items.advancedMachine),
+                "research.ESSENTIA_GENERATOR.page.1", "research.ESSENTIA_GENERATOR.page.2",
+                "research.ESSENTIA_GENERATOR.page.3" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_CELL",
+            "Better Cells",
+            "And higher efficiency.",
+            new String[] { "ESSENTIA_GENERATOR" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Cell_T4.get(1),
+            2,
+            0,
+            -10,
+            3,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PRAECANTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_CELL.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_CELL",
+                    ItemRefer.Essentia_Cell_T1.get(1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 1),
+                        ItemList.Electric_Pump_IV.get(1L), ItemList.QuantumStar.get(1L),
+                        new ItemStack(ConfigBlocks.blockMetalDevice, 1, 3), ItemList.Reactor_Coolant_Sp_1.get(1L),
+                        GT_OreDictUnificator.get(OrePrefixes.bolt, Materials.Plutonium241, 1), },
+                    ItemRefer.Essentia_Cell_T2.get(1),
+                    6,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 64),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 64),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 32))),
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_CELL",
+                    ItemRefer.Essentia_Cell_T2.get(1),
+                    new ItemStack[] { ItemList.Field_Generator_IV.get(1L), ItemList.Electric_Pump_LuV.get(1L),
+                        new ItemStack(ConfigItems.itemResource, 1, 14), Ic2Items.fluidregulator,
+                        new ItemStack(ConfigBlocks.blockJar, 1, 0),
+                        GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Ichorium, 1) },
+                    ItemRefer.Essentia_Cell_T3.get(1),
+                    8,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 64))),
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_CELL",
+                    ItemRefer.Essentia_Cell_T3.get(1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Europium, 1),
+                        ItemList.Emitter_LuV.get(1L), new ItemStack(ItemRegistry.bw_realglas, 1, 4),
+                        GT_OreDictUnificator.get(OrePrefixes.plate, Materials.StellarAlloy, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.cellPlasma, Materials.Helium, 1),
+                        new ItemStack(ConfigItems.itemShard, 1, 6), },
+                    ItemRefer.Essentia_Cell_T4.get(1),
+                    10,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 256),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 256),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 128))) });
+        ItemStack broad = new ItemStack(ConfigBlocks.blockCosmeticSolid, 1, 6);
+        if (NewHorizonsCoreMod.isModLoaded()) broad = GT_ModHandler.getModItem("dreamcraft", "item.ArcaneSlate", 1);
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_BLANK",
+            "Upgrade your generator",
+            "Let's try some more dangerous essentia.",
+            new String[] { "ESSENTIA_GENERATOR" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Empty.get(1),
+            2,
+            0,
+            -9,
+            4,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_BLANK.page.0",
+                addArcaneCraftingRecipe(
+                    "ESSENTIA_UPGRADE_BLANK",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new AspectList().add(Aspect.AIR, 80)
+                        .add(Aspect.ENTROPY, 50)
+                        .add(Aspect.ORDER, 50)
+                        .add(Aspect.WATER, 80),
+                    "AMB",
+                    "CZD",
+                    "EIF",
+                    'A',
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.InfusedAir, 1),
+                    'B',
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.InfusedEarth, 1),
+                    'C',
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.InfusedFire, 1),
+                    'D',
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.InfusedWater, 1),
+                    'E',
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.InfusedOrder, 1),
+                    'F',
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.InfusedEntropy, 1),
+                    'M',
+                    new ItemStack(ConfigItems.itemResource, 1, 10),
+                    'Z',
+                    broad,
+                    'I',
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.PulsatingIron, 1)), });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_AIR",
+            "Essentia: AIR",
+            "I can feel it on the wind.",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Air.get(1),
+            1,
+            0,
+            -9,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.AER, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_AIR.page.0", GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                "ESSENTIA_UPGRADE_AIR",
+                ItemRefer.Essentia_Upgrade_Empty.get(1),
+                new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.cell, Materials.LiquidAir, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Hydrogen, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Helium, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Argon, 1),
+                    WerkstoffLoader.Neon.get(OrePrefixes.cell, 1), WerkstoffLoader.Krypton.get(OrePrefixes.cell, 1), },
+                ItemRefer.Essentia_Upgrade_Air.get(1),
+                5,
+                Arrays.asList(
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.AER, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.VOLATUS, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 128))),
+                "research.ESSENTIA_UPGRADE_AIR.page.1" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_THERMAL",
+            "Essentia: THERMAL",
+            "Melting down.",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Thermal.get(1),
+            1,
+            0,
+            -10,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_THERMAL.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_THERMAL",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.lens, Materials.Firestone, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Netherrack, 1),
+                        Ic2Items.reactorPlatingHeat, ItemList.Casing_Coil_Nichrome.get(1),
+                        new ItemStack(ConfigItems.itemResource, 1, 1), new ItemStack(ConfigItems.itemResource, 1, 0), },
+                    ItemRefer.Essentia_Upgrade_Thermal.get(1),
+                    5,
+                    Collections.singletonList(new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1024))),
+                "research.ESSENTIA_UPGRADE_THERMAL.page.1", "research.ESSENTIA_UPGRADE_THERMAL.page.2" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_UNSTABLE",
+            "Essentia: UNSTABLE",
+            "Heart of chaos.",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Unstable.get(1),
+            1,
+            0,
+            -11,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_UNSTABLE.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_UNSTABLE",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.cell, Materials.GasolinePremium, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Unstable, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Void, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.gem, Materials.InfusedEntropy, 1), Ic2Items.industrialTnt,
+                        new ItemStack(ItemRegistry.DESTRUCTOPACK) },
+                    ItemRefer.Essentia_Upgrade_Unstable.get(1),
+                    6,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 128))),
+                "research.ESSENTIA_UPGRADE_UNSTABLE.page.1", "research.ESSENTIA_UPGRADE_UNSTABLE.page.2" });
+        ItemStack meatDust = GT_OreDictUnificator.get(OrePrefixes.dust, Materials.MeatRaw, 1);
+        if (NewHorizonsCoreMod.isModLoaded()) meatDust = GT_ModHandler.getModItem("dreamcraft", "GTNHBioItems", 1, 2);
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_VICTUS",
+            "Essentia: VICTUS",
+            "Will it bleed?",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Victus.get(1),
+            1,
+            0,
+            -12,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.VICTUS, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_VICTUS.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_VICTUS",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { meatDust, ItemList.Food_Dough_Sugar.get(1),
+                        GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Calcium, 1),
+                        new ItemStack(Item.getItemById(367), 1), new ItemStack(ConfigItems.itemResource, 1, 4),
+                        new ItemStack(ConfigBlocks.blockMetalDevice, 1, 8), },
+                    ItemRefer.Essentia_Upgrade_Victus.get(1),
+                    5,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VICTUS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.SPIRITUS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.HUMANUS, 128))),
+                "research.ESSENTIA_UPGRADE_VICTUS.page.1", "research.ESSENTIA_UPGRADE_VICTUS.page.2" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_TAINTED",
+            "Essentia: TAINTED",
+            "Dirty Deeds Done Dirt Cheap",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Tainted.get(1),
+            1,
+            0,
+            -13,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MORTUUS, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_TAINTED.page.0", "research.ESSENTIA_UPGRADE_TAINTED.page.1",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_TAINTED",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { new ItemStack(ConfigBlocks.blockTaintFibres, 1, 0),
+                        new ItemStack(ConfigBlocks.blockTaintFibres, 1, 2),
+                        new ItemStack(ConfigItems.itemResource, 1, 11),
+                        GT_OreDictUnificator.get(OrePrefixes.spring, Materials.NaquadahEnriched, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.EndSteel, 1),
+                        new ItemStack(Block.getBlockById(138), 1), },
+                    ItemRefer.Essentia_Upgrade_Tainted.get(1),
+                    7,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.MORTUUS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.ALIENIS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.EXANIMIS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.VITIUM, 128))),
+                "research.ESSENTIA_UPGRADE_TAINTED.page.2", "research.ESSENTIA_UPGRADE_TAINTED.page.3" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_MECHANICS",
+            "Essentia: MECHANICS",
+            "Driven by Ether.",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Mechanics.get(1),
+            1,
+            0,
+            -14,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_MECHANICS.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_MECHANICS",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { new ItemStack(ConfigBlocks.blockTube, 1, 4),
+                        new ItemStack(ConfigBlocks.blockTube, 1, 2),
+                        GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.VividAlloy, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Polybenzimidazole, 1),
+                        ItemList.Electric_Motor_IV.get(1), ItemList.Electric_Pump_IV.get(1), },
+                    ItemRefer.Essentia_Upgrade_Mechanics.get(1),
+                    5,
+                    Arrays.asList(
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.LIMUS, 128),
+                        new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128))),
+                "research.ESSENTIA_UPGRADE_MECHANICS.page.1", "research.ESSENTIA_UPGRADE_MECHANICS.page.2" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_SPRITE",
+            "Essentia: SPRITE",
+            "Brain in a Machine.",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Spirit.get(1),
+            1,
+            0,
+            -15,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_SPRITE.page.0", GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                "ESSENTIA_UPGRADE_SPRITE",
+                ItemRefer.Essentia_Upgrade_Empty.get(1),
+                new ItemStack[] { new ItemStack(ConfigBlocks.blockJar, 1, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.food, Materials.Cheese, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Shadow, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.spring, Materials.FierySteel, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Milk, 1), ItemList.Machine_EV_Scanner.get(1) },
+                ItemRefer.Essentia_Upgrade_Spirit.get(1),
+                5,
+                Arrays.asList(
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.STRONTIO, 128),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 128))),
+                "research.ESSENTIA_UPGRADE_SPRITE.page.1", "research.ESSENTIA_UPGRADE_SPRITE.page.2" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_RADIATION",
+            "Essentia: RADIATION",
+            "Atomic Heart",
+            new String[] { "ESSENTIA_UPGRADE_BLANK" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Radiation.get(1),
+            1,
+            0,
+            -16,
+            5,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.RADIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_RADIATION.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_RADIATION",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { ItemRefer.High_Density_Plutonium.get(1), ItemRefer.High_Density_Uranium.get(1),
+                        ItemRefer.High_Density_Thorium.get(1), Ic2Items.UranFuel, Ic2Items.MOXFuel,
+                        WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1) },
+                    ItemRefer.Essentia_Upgrade_Radiation.get(1),
+                    8,
+                    Collections.singletonList(new TC_Aspects.TC_AspectStack(TC_Aspects.RADIO, 1024))),
+                "research.ESSENTIA_UPGRADE_RADIATION.page.1", "research.ESSENTIA_UPGRADE_RADIATION.page.2" });
+        GregTech_API.sThaumcraftCompat.addResearch(
+            "ESSENTIA_UPGRADE_ELECTRIC",
+            "Essentia: ELECTRIC",
+            "Get electricity from... electricity?",
+            new String[] { "ESSENTIA_UPGRADE_AIR", "ESSENTIA_UPGRADE_THERMAL", "ESSENTIA_UPGRADE_UNSTABLE",
+                "ESSENTIA_UPGRADE_VICTUS", "ESSENTIA_UPGRADE_TAINTED", "ESSENTIA_UPGRADE_MECHANICS",
+                "ESSENTIA_UPGRADE_SPRITE", "ESSENTIA_UPGRADE_RADIATION" },
+            "ARTIFICE",
+            ItemRefer.Essentia_Upgrade_Electric.get(1),
+            1,
+            0,
+            -12,
+            7,
+            Arrays.asList(
+                new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 10L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L)),
+            null,
+            new Object[] { "research.ESSENTIA_UPGRADE_ELECTRIC.page.0",
+                GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                    "ESSENTIA_UPGRADE_RADIATION",
+                    ItemRefer.Essentia_Upgrade_Empty.get(1),
+                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorMV, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorHV, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorEV, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorIV, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorLuV, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorZPM, 1) },
+                    ItemRefer.Essentia_Upgrade_Electric.get(1),
+                    10,
+                    Collections.singletonList(new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32768))),
+                "research.ESSENTIA_UPGRADE_ELECTRIC.page.1" });
+
+        ItemStack nodeLinkDevice = ThaumicBases.isModLoaded()
+            ? GT_ModHandler.getModItem("thaumicbases", "nodeLinker", 1, 0)
+            : new ItemStack(ConfigBlocks.blockStoneDevice, 1, 11);
+        ItemStack alchemicalFurnace = ThaumicBases.isModLoaded()
+            ? GT_ModHandler.getModItem("thaumicbases", "advAlchFurnace", 1, 0)
+            : new ItemStack(ConfigBlocks.blockStoneDevice, 1, 0);
+        ItemStack nitor = ThaumicTinkerer.isModLoaded()
+            ? GT_ModHandler.getModItem("ThaumicTinkerer", "brightNitor", 1, 0)
+            : new ItemStack(ConfigItems.itemResource, 1, 1);
+        ItemStack alchemicalBoiler = Automagy.isModLoaded() ? GT_ModHandler.getModItem("Automagy", "blockBoiler", 1, 0)
+            : new ItemStack(ConfigBlocks.blockStoneDevice, 1, 1);
+        ItemStack essentiaLocus = Automagy.isModLoaded()
+            ? GT_ModHandler.getModItem("Automagy", "blockEssentiaLocus", 1, 0)
+            : new ItemStack(ConfigBlocks.blockJar, 1, 1);
+        ItemStack thauminiteBlock = ThaumicBases.isModLoaded()
+            ? GT_ModHandler.getModItem("thaumicbases", "thauminiteBlock", 1, 0)
+            : new ItemStack(ConfigBlocks.blockCosmeticSolid, 1, 4);
+        GregTech_API.sThaumcraftCompat
+            .addResearch(
+                "ESSENTIA_SMELTERY",
+                "Large Essentia Smeltery",
+                "You need a bigger boat.",
+                new String[] { "INFUSION" },
+                "ARTIFICE",
+                ItemRefer.Large_Essentia_Smeltery.get(1),
+                4,
+                0,
+                -16,
+                3,
+                Arrays.asList(
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.LIMUS, 10)),
+                null,
+                new Object[] { "research.ESSENTIA_SMELTERY.page.0",
+                    GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                        "ESSENTIA_SMELTERY",
+                        ItemList.Casing_Firebox_TungstenSteel.get(1),
+                        new ItemStack[] { nodeLinkDevice, nitor, alchemicalFurnace, essentiaLocus, alchemicalBoiler,
+                            new ItemStack(ConfigBlocks.blockCrystal, 1, 1),
+                            new ItemStack(ConfigBlocks.blockMetalDevice, 1, 3), ItemList.Electric_Piston_IV.get(1),
+                            GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.FierySteel, 1L),
+                            GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Elite, 1L),
+                            GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Elite, 1L),
+                            GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Elite, 1L),
+                            GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Elite, 1L) },
+                        ItemRefer.Large_Essentia_Smeltery.get(1),
+                        16,
+                        Arrays.asList(
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256))),
+                    "research.ESSENTIA_SMELTERY.page.1",
+                    GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                        "ESSENTIA_GENERATOR",
+                        ItemList.Hatch_Output_HV.get(1),
+                        new ItemStack[] { new ItemStack(ConfigBlocks.blockJar, 1), ItemRefer.Magic_Casing.get(1),
+                            new ItemStack(ConfigBlocks.blockTube, 1), ItemList.Electric_Pump_MV.get(1L) },
+                        ItemRefer.Essentia_Output_Hatch.get(1),
+                        6,
+                        Arrays.asList(
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 128),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 64),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 32),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 32))),
+                    "research.ESSENTIA_SMELTERY.page.2",
+                    addArcaneCraftingRecipe(
+                        "ESSENTIA_SMELTERY",
+                        ItemRefer.Essentia_Filter_Casing.get(1),
+                        new AspectList().add(Aspect.AIR, 70)
+                            .add(Aspect.EARTH, 70)
+                            .add(Aspect.FIRE, 70)
+                            .add(Aspect.WATER, 70)
+                            .add(Aspect.ORDER, 70)
+                            .add(Aspect.ENTROPY, 70),
+                        "ABA",
+                        "CDC",
+                        "EFE",
+                        'A',
+                        new ItemStack(ConfigBlocks.blockTube, 1, 3),
+                        'B',
+                        new ItemStack(ConfigBlocks.blockStoneDevice, 1, 14),
+                        'C',
+                        GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Void, 1),
+                        'D',
+                        new ItemStack(GregTech_API.sBlockCasings3, 1, 11),
+                        'E',
+                        GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.NetherStar, 1),
+                        'F',
+                        thauminiteBlock) });
+
+        if (ThaumicEnergistics.isModLoaded()) {
+            ItemStack essentiaPump = WitchingGadgets.isModLoaded()
+                ? GT_ModHandler.getModItem("WitchingGadgets", "WG_MetalDevice", 1, 0)
+                : new ItemStack(ConfigBlocks.blockTube, 1, 4);
+            ItemStack inter = ThaumicTinkerer.isModLoaded()
+                ? GT_ModHandler.getModItem("ThaumicTinkerer", "interface", 1, 0)
+                : new ItemStack(ConfigItems.itemResource, 1, 15);
+            GregTech_API.sThaumcraftCompat.addResearch(
+                "ESSENTIA_OUTPUT_HATCH_ME",
+                "Essentia Output Hatch (ME)",
+                "It must exist.",
+                new String[] { "INFUSION" },
+                "ARTIFICE",
+                ItemRefer.Essentia_Output_Hatch_ME.get(1),
+                3,
+                0,
+                -15,
+                3,
+                Arrays.asList(
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.ALIENIS, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.VINCULUM, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.STRONTIO, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 10),
+                    new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 10)),
+                null,
+                new Object[] { "research.ESSENTIA_OUTPUT_HATCH_ME.page.0",
+                    GregTech_API.sThaumcraftCompat.addInfusionRecipe(
+                        "ESSENTIA_OUTPUT_HATCH_ME",
+                        ItemRefer.Essentia_Output_Hatch.get(1),
+                        new ItemStack[] {
+                            GT_ModHandler
+                                .getModItem("thaumicenergistics", "thaumicenergistics.block.essentia.provider", 1),
+                            new ItemStack(ConfigBlocks.blockEssentiaReservoir, 1, 0), essentiaPump, inter, },
+                        ItemRefer.Essentia_Output_Hatch_ME.get(1),
+                        8,
+                        Arrays.asList(
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.ALIENIS, 256),
+                            new TC_Aspects.TC_AspectStack(TC_Aspects.STRONTIO, 256))) });
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/DepletedFuelRod.java b/goodgen/src/main/java/goodgenerator/items/DepletedFuelRod.java
new file mode 100644
index 0000000000..308f149933
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/DepletedFuelRod.java
@@ -0,0 +1,54 @@
+package goodgenerator.items;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.ItemStack;
+
+import ic2.api.item.IBoxable;
+import ic2.api.reactor.IReactor;
+import ic2.api.reactor.IReactorComponent;
+
+public class DepletedFuelRod extends RadioactiveItem implements IReactorComponent, IBoxable {
+
+    public DepletedFuelRod(String name, String[] tooltip, CreativeTabs Tab, int Rad) {
+        super(name, tooltip, Tab, Rad);
+    }
+
+    @Override
+    public boolean canBeStoredInToolbox(ItemStack itemStack) {
+        return true;
+    }
+
+    @Override
+    public void processChamber(IReactor iReactor, ItemStack itemStack, int i, int i1, boolean b) {}
+
+    @Override
+    public boolean acceptUraniumPulse(IReactor iReactor, ItemStack itemStack, ItemStack itemStack1, int i, int i1,
+        int i2, int i3, boolean b) {
+        return false;
+    }
+
+    @Override
+    public boolean canStoreHeat(IReactor iReactor, ItemStack itemStack, int i, int i1) {
+        return false;
+    }
+
+    @Override
+    public int getMaxHeat(IReactor iReactor, ItemStack itemStack, int i, int i1) {
+        return 0;
+    }
+
+    @Override
+    public int getCurrentHeat(IReactor iReactor, ItemStack itemStack, int i, int i1) {
+        return 0;
+    }
+
+    @Override
+    public int alterHeat(IReactor iReactor, ItemStack itemStack, int i, int i1, int i2) {
+        return 0;
+    }
+
+    @Override
+    public float influenceExplosion(IReactor iReactor, ItemStack itemStack) {
+        return 0;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/FuelRod.java b/goodgen/src/main/java/goodgenerator/items/FuelRod.java
new file mode 100644
index 0000000000..00ca8b3491
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/FuelRod.java
@@ -0,0 +1,215 @@
+package goodgenerator.items;
+
+import static goodgenerator.util.DescTextLocalization.addText;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.util.GT_Utility;
+import ic2.api.item.IBoxable;
+import ic2.api.reactor.IReactor;
+import ic2.api.reactor.IReactorComponent;
+import ic2.core.util.StackUtil;
+import ic2.core.util.Util;
+
+public class FuelRod extends RadioactiveItem implements IReactorComponent, IBoxable {
+
+    private final int numberOfCells;
+    private final int maxDmg;
+    private final float Power;
+    private final int Heat;
+    private float HeatBonus = 0;
+    private final ItemStack result;
+
+    public FuelRod(String aName, int aCells, int aEUt, int aHeat, int aRads, int aDuration, ItemStack aResult,
+        CreativeTabs Tab) {
+        super(aName, Tab, aRads);
+        this.setMaxStackSize(64);
+        this.numberOfCells = aCells;
+        this.maxDmg = aDuration;
+        this.Power = (float) aEUt / 25.0F;
+        this.result = aResult;
+        this.Heat = aHeat;
+        setMaxDamage(100);
+    }
+
+    public FuelRod(String aName, int aCells, int aEUt, int aHeat, int aRads, int aDuration, float aHeatBonus,
+        ItemStack aResult, CreativeTabs Tab) {
+        super(aName, Tab, aRads);
+        this.setMaxStackSize(64);
+        this.numberOfCells = aCells;
+        this.maxDmg = aDuration;
+        this.Power = (float) aEUt / 25.0F;
+        this.result = aResult;
+        this.Heat = aHeat;
+        this.HeatBonus = aHeatBonus;
+        setMaxDamage(100);
+    }
+
+    public void processChamber(IReactor reactor, ItemStack stack, int x, int y, boolean heatRun) {
+        if (reactor.produceEnergy()) {
+            for (int iteration = 0; iteration < this.numberOfCells; ++iteration) {
+                int pulses = 1 + this.numberOfCells / 2;
+                int heat;
+                if (!heatRun) {
+                    for (heat = 0; heat < pulses; ++heat) {
+                        this.acceptUraniumPulse(reactor, stack, stack, x, y, x, y, heatRun);
+                    }
+                    checkPulseable(reactor, x - 1, y, stack, x, y, heatRun);
+                    checkPulseable(reactor, x + 1, y, stack, x, y, heatRun);
+                    checkPulseable(reactor, x, y - 1, stack, x, y, heatRun);
+                    checkPulseable(reactor, x, y + 1, stack, x, y, heatRun);
+                } else {
+                    pulses += checkPulseable(reactor, x - 1, y, stack, x, y, heatRun)
+                        + checkPulseable(reactor, x + 1, y, stack, x, y, heatRun)
+                        + checkPulseable(reactor, x, y - 1, stack, x, y, heatRun)
+                        + checkPulseable(reactor, x, y + 1, stack, x, y, heatRun);
+                    heat = sumUp(pulses) * this.Heat;
+                    ArrayList<FuelRod.ItemStackCoord> heatAcceptors = new ArrayList<>();
+                    this.checkHeatAcceptor(reactor, x - 1, y, heatAcceptors);
+                    this.checkHeatAcceptor(reactor, x + 1, y, heatAcceptors);
+                    this.checkHeatAcceptor(reactor, x, y - 1, heatAcceptors);
+                    this.checkHeatAcceptor(reactor, x, y + 1, heatAcceptors);
+
+                    while (heatAcceptors.size() > 0 && heat > 0) {
+                        int dheat = heat / heatAcceptors.size();
+                        heat -= dheat;
+                        dheat = ((IReactorComponent) heatAcceptors.get(0).stack.getItem()).alterHeat(
+                            reactor,
+                            heatAcceptors.get(0).stack,
+                            heatAcceptors.get(0).x,
+                            heatAcceptors.get(0).y,
+                            dheat);
+                        heat += dheat;
+                        heatAcceptors.remove(0);
+                    }
+
+                    if (heat > 0) {
+                        reactor.addHeat(heat);
+                    }
+                }
+            }
+            if (this.getCustomDamage(stack) >= this.getMaxCustomDamage(stack) - 1) {
+                reactor.setItemAt(x, y, GT_Utility.copyAmount(1, result));
+            } else if (heatRun) {
+                this.applyCustomDamage(stack, 1, null);
+            }
+        }
+    }
+
+    private static int checkPulseable(IReactor reactor, int x, int y, ItemStack me, int mex, int mey, boolean heatrun) {
+        ItemStack other = reactor.getItemAt(x, y);
+        return other != null && other.getItem() instanceof IReactorComponent
+            && ((IReactorComponent) other.getItem()).acceptUraniumPulse(reactor, other, me, x, y, mex, mey, heatrun) ? 1
+                : 0;
+    }
+
+    private static int sumUp(int x) {
+        return (x * x + x) / 2;
+    }
+
+    private void checkHeatAcceptor(IReactor reactor, int x, int y, ArrayList<FuelRod.ItemStackCoord> heatAcceptors) {
+        ItemStack thing = reactor.getItemAt(x, y);
+        if (thing != null && thing.getItem() instanceof IReactorComponent
+            && ((IReactorComponent) thing.getItem()).canStoreHeat(reactor, thing, x, y)) {
+            heatAcceptors.add(new ItemStackCoord(thing, x, y));
+        }
+    }
+
+    public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY,
+        int pulseX, int pulseY, boolean heatrun) {
+        if (!heatrun) {
+            reactor.addOutput(Power * (1 + HeatBonus * ((float) reactor.getHeat() / (float) reactor.getMaxHeat())));
+        }
+        return true;
+    }
+
+    public boolean canStoreHeat(IReactor reactor, ItemStack yourStack, int x, int y) {
+        return false;
+    }
+
+    public int getMaxHeat(IReactor reactor, ItemStack yourStack, int x, int y) {
+        return 0;
+    }
+
+    public int getCurrentHeat(IReactor reactor, ItemStack yourStack, int x, int y) {
+        return 0;
+    }
+
+    public int alterHeat(IReactor reactor, ItemStack yourStack, int x, int y, int heat) {
+        return heat;
+    }
+
+    public float influenceExplosion(IReactor reactor, ItemStack yourStack) {
+        return (float) (2 * this.numberOfCells);
+    }
+
+    @Override
+    public boolean canBeStoredInToolbox(ItemStack itemStack) {
+        return true;
+    }
+
+    private static class ItemStackCoord {
+
+        public ItemStack stack;
+        public int x;
+        public int y;
+
+        public ItemStackCoord(ItemStack stack1, int x1, int y1) {
+            this.stack = stack1;
+            this.x = x1;
+            this.y = y1;
+        }
+    }
+
+    public int getCustomDamage(ItemStack stack) {
+        NBTTagCompound nbt = StackUtil.getOrCreateNbtData(stack);
+        return nbt.getInteger("advDmg");
+    }
+
+    public int getMaxCustomDamage(ItemStack stack) {
+        return this.maxDmg;
+    }
+
+    public void setCustomDamage(ItemStack stack, int damage) {
+        NBTTagCompound nbt = StackUtil.getOrCreateNbtData(stack);
+        nbt.setInteger("advDmg", damage);
+        int maxStackDamage = stack.getMaxDamage();
+        if (maxStackDamage > 2) {
+            stack.setItemDamage(1 + (int) Util.map(damage, this.maxDmg, maxStackDamage - 2));
+        }
+    }
+
+    public boolean applyCustomDamage(ItemStack stack, int damage, EntityLivingBase src) {
+        this.setCustomDamage(stack, this.getCustomDamage(stack) + damage);
+        return true;
+    }
+
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    @Override
+    public void addInformation(ItemStack item, EntityPlayer player, List tooltip, boolean p_77624_4_) {
+        super.addInformation(item, player, tooltip, p_77624_4_);
+        tooltip.add(
+            String.format(
+                addText("fuelrod.tooltip", 1)[0],
+                getMaxCustomDamage(item) - getCustomDamage(item),
+                getMaxCustomDamage(item)));
+        double tMut = this.Heat / 4.0;
+        if (this.Heat == 4) {
+            tooltip.add(StatCollector.translateToLocal("fuelrodheat.tooltip.0"));
+        } else {
+            tooltip.add(String.format(StatCollector.translateToLocal("fuelrodheat.tooltip.1"), tMut));
+        }
+        if (this.HeatBonus != 0) tooltip.add(StatCollector.translateToLocal("fuelrodheat.tooltip.2"));
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/MyItemBlocks.java b/goodgen/src/main/java/goodgenerator/items/MyItemBlocks.java
new file mode 100644
index 0000000000..3ee7347e97
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/MyItemBlocks.java
@@ -0,0 +1,105 @@
+package goodgenerator.items;
+
+import static goodgenerator.loader.Loaders.essentiaCell;
+import static goodgenerator.loader.Loaders.yottaFluidTankCell;
+import static goodgenerator.util.CharExchanger.tierName;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.StatCollector;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.blocks.regularBlock.TEBlock;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch;
+import goodgenerator.main.GoodGenerator;
+import goodgenerator.util.CharExchanger;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.util.GT_LanguageManager;
+
+public class MyItemBlocks extends ItemBlock {
+
+    private final String mNoMobsToolTip = GT_LanguageManager
+        .addStringLocalization("gt.nomobspawnsonthisblock", "Mobs cannot Spawn on this Block");
+    private final String mNoTileEntityToolTip = GT_LanguageManager
+        .addStringLocalization("gt.notileentityinthisblock", "This is NOT a TileEntity!");
+
+    public MyItemBlocks(Block block) {
+        super(block);
+        this.setMaxDamage(0);
+        this.setHasSubtypes(true);
+        this.setCreativeTab(GoodGenerator.GG);
+    }
+
+    @Override
+    public int getMetadata(int aMeta) {
+        return aMeta;
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack aStack) {
+        return this.field_150939_a.getUnlocalizedName() + "." + this.getDamage(aStack);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(ItemStack stack, int pass) {
+        return this.field_150939_a.getIcon(0, stack.getItemDamage());
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) {
+        return this.getIcon(stack, renderPass);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIconFromDamageForRenderPass(int p_77618_1_, int p_77618_2_) {
+        return this.field_150939_a.getIcon(0, p_77618_2_);
+    }
+
+    @Override
+    @SuppressWarnings({ "unchecked" })
+    @SideOnly(Side.CLIENT)
+    public void addInformation(ItemStack stack, EntityPlayer playerIn, List tooltip, boolean advanced) {
+        if (stack == null) return;
+        tooltip.add(mNoMobsToolTip);
+        if (Block.getBlockFromItem(stack.getItem()) instanceof TEBlock) {
+            TEBlock tile = (TEBlock) Block.getBlockFromItem(stack.getItem());
+            if (tile.getIndex() == 1)
+                tooltip.addAll(Arrays.asList(DescTextLocalization.addText("EssentiaHatch.tooltip", 2)));
+            if (tile.getIndex() == 2) {
+                tooltip.add(StatCollector.translateToLocal("EssentiaOutputHatch.tooltip.0"));
+                tooltip.add(
+                    StatCollector.translateToLocal("EssentiaOutputHatch.tooltip.1") + " "
+                        + EssentiaOutputHatch.CAPACITY);
+            }
+        } else {
+            tooltip.add(mNoTileEntityToolTip);
+        }
+
+        if (Block.getBlockFromItem(stack.getItem())
+            .equals(yottaFluidTankCell)) {
+            StringBuilder cap = new StringBuilder();
+            cap.append(" 1000000");
+            for (int i = 0; i < stack.getItemDamage(); i++) cap.append("00");
+            cap.append(" L");
+            tooltip.add(
+                StatCollector.translateToLocal("YOTTankCell.tooltip.0") + CharExchanger.formatNumber(cap.toString()));
+            tooltip.add(StatCollector.translateToLocal("YOTTankCell.tooltip.1"));
+        }
+
+        if (Block.getBlockFromItem(stack.getItem())
+            .equals(essentiaCell)) {
+            tooltip
+                .add(StatCollector.translateToLocal("hatchTier.tooltip.0") + " " + tierName[stack.getItemDamage() + 4]);
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/MyItems.java b/goodgen/src/main/java/goodgenerator/items/MyItems.java
new file mode 100644
index 0000000000..71a67d4fd6
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/MyItems.java
@@ -0,0 +1,127 @@
+package goodgenerator.items;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.main.GoodGenerator;
+
+public class MyItems extends Item {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon[] texture;
+
+    private String tex;
+    private String[] textureNames;
+    private final String Name;
+    private List<String> tooltips = new ArrayList<>();
+    private List<String> tooltipses = new ArrayList<>();
+
+    public MyItems(String name, CreativeTabs Tab) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.tex = name;
+        this.Name = name;
+    }
+
+    public MyItems(String name, CreativeTabs Tab, String[] textures) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.setHasSubtypes(true);
+        this.textureNames = textures;
+        this.Name = name;
+    }
+
+    public MyItems(String name, String[] tooltip, CreativeTabs Tab, String[] textures) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.setHasSubtypes(true);
+        this.textureNames = textures;
+        this.Name = name;
+        this.tooltipses = Arrays.asList(tooltip);
+    }
+
+    public MyItems(String name, String tooltip, CreativeTabs Tab) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.tex = name;
+        this.tooltips.add(tooltip);
+        this.Name = name;
+    }
+
+    public MyItems(String name, String[] tooltip, CreativeTabs Tab) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.tex = name;
+        this.tooltips = Arrays.asList(tooltip);
+        this.Name = name;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIconFromDamage(int meta) {
+        if (this.texture == null || this.texture.length < 1) return this.itemIcon;
+        else return meta < this.texture.length ? this.texture[meta] : this.texture[0];
+    }
+
+    @Override
+    public int getMetadata(int aMeta) {
+        return aMeta;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister iconRegister) {
+        if (this.textureNames == null || this.textureNames.length < 1) {
+            this.itemIcon = iconRegister.registerIcon(GoodGenerator.MOD_ID + ":" + this.tex);
+        } else {
+            this.texture = new IIcon[this.textureNames.length];
+            for (int i = 0; i < this.textureNames.length; ++i) {
+                this.texture[i] = iconRegister.registerIcon(this.textureNames[i]);
+            }
+        }
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack p_77667_1_) {
+        if (this.textureNames == null || this.textureNames.length < 1) {
+            return "item." + this.Name;
+        } else {
+            return "item." + this.Name + "." + p_77667_1_.getItemDamage();
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubItems(Item item, CreativeTabs tab, List list) {
+        if (this.texture == null || this.texture.length < 1) list.add(new ItemStack(item, 1, 0));
+        else {
+            for (int i = 0; i < this.texture.length; ++i) {
+                list.add(new ItemStack(item, 1, i));
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings({ "unchecked" })
+    public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List p_77624_3_, boolean p_77624_4_) {
+        if (tooltips.size() > 0) {
+            p_77624_3_.addAll(tooltips);
+        }
+        if (tooltipses.size() > 0) {
+            int meta = p_77624_1_.getItemDamage();
+            if (tooltipses.size() - 1 < meta) meta = tooltipses.size() - 1;
+            p_77624_3_.add(tooltipses.get(meta));
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/MyMaterial.java b/goodgen/src/main/java/goodgenerator/items/MyMaterial.java
new file mode 100644
index 0000000000..1e75167ef0
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/MyMaterial.java
@@ -0,0 +1,1524 @@
+package goodgenerator.items;
+
+import static com.github.bartimaeusnek.bartworks.util.BW_Util.subscriptNumbers;
+import static gregtech.api.enums.Materials.*;
+
+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+import com.github.bartimaeusnek.bartworks.util.Pair;
+
+import goodgenerator.util.CharExchanger;
+import gregtech.api.enums.TextureSet;
+
+@SuppressWarnings({ "unchecked" })
+public class MyMaterial implements Runnable {
+
+    protected static final int OffsetID = 10001;
+
+    // Uranium Based Fuel Line
+    public static final Werkstoff graphiteUraniumMixture = new Werkstoff(
+        new short[] { 0x3a, 0x77, 0x3d },
+        "Graphite-Uranium Mixture",
+        subscriptNumbers("C3U"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addMixerRecipes()
+            .onlyDust(),
+        OffsetID,
+        TextureSet.SET_DULL,
+        new Pair<>(Graphite, 3),
+        new Pair<>(Uranium, 1));
+
+    public static final Werkstoff uraniumBasedLiquidFuel = new Werkstoff(
+        new short[] { 0x00, 0xff, 0x00 },
+        "Uranium Based Liquid Fuel",
+        subscriptNumbers("U36K8Qt4Rn"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 1,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff uraniumBasedLiquidFuelExcited = new Werkstoff(
+        new short[] { 0x00, 0xff, 0x00 },
+        "Uranium Based Liquid Fuel (Excited State)",
+        subscriptNumbers("*(U36K8Qt4Rn)*"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 2,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff uraniumBasedLiquidFuelDepleted = new Werkstoff(
+        new short[] { 0x6e, 0x8b, 0x3d },
+        "Uranium Based Liquid Fuel (Depleted)",
+        subscriptNumbers("Pb?Bi?Ba?Xe?"),
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 3,
+        TextureSet.SET_FLUID);
+
+    // Thorium Based Fuel
+    public static final Werkstoff uraniumCarbideThoriumMixture = new Werkstoff(
+        new short[] { 0x16, 0x32, 0x07 },
+        "Uranium Carbide-Thorium Mixture",
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addMixerRecipes()
+            .onlyDust(),
+        OffsetID + 4,
+        TextureSet.SET_DULL,
+        new Pair<>(Thorium, 11),
+        new Pair<>(WerkstoffLoader.Thorium232, 1),
+        new Pair<>(Uranium235, 1),
+        new Pair<>(Carbon, 3));
+
+    public static final Werkstoff thoriumBasedLiquidFuel = new Werkstoff(
+        new short[] { 0x50, 0x32, 0x66 },
+        "Thorium Based Liquid Fuel",
+        subscriptNumbers("Th432Li4D2Hg"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 5,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thoriumBasedLiquidFuelExcited = new Werkstoff(
+        new short[] { 0x50, 0x32, 0x66 },
+        "Thorium Based Liquid Fuel (Excited State)",
+        subscriptNumbers("*(Th432Li4D2Hg)*"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 6,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thoriumBasedLiquidFuelDepleted = new Werkstoff(
+        new short[] { 0x7d, 0x6c, 0x8a },
+        "Thorium Based Liquid Fuel (Depleted)",
+        subscriptNumbers("Th?Pr?B?In?"),
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 7,
+        TextureSet.SET_FLUID);
+
+    // Plutonium Based Fuel
+    public static final Werkstoff plutoniumOxideUraniumMixture = new Werkstoff(
+        new short[] { 0xd1, 0x1f, 0x4a },
+        "Plutonium Oxide-Uranium Mixture",
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addMixerRecipes()
+            .onlyDust(),
+        OffsetID + 8,
+        TextureSet.SET_SHINY,
+        new Pair<>(Plutonium, 10),
+        new Pair<>(Oxygen, 12),
+        new Pair<>(Uranium, 2),
+        new Pair<>(Carbon, 8));
+
+    public static final Werkstoff plutoniumBasedLiquidFuel = new Werkstoff(
+        new short[] { 0xef, 0x15, 0x15 },
+        "Plutonium Based Liquid Fuel",
+        subscriptNumbers("Pu45Nt8Cs16Nq2"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 9,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff plutoniumBasedLiquidFuelExcited = new Werkstoff(
+        new short[] { 0xef, 0x15, 0x15 },
+        "Plutonium Based Liquid Fuel (Excited State)",
+        subscriptNumbers("*(Pu45Nt8Cs16Nq2)*"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 10,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff plutoniumBasedLiquidFuelDepleted = new Werkstoff(
+        new short[] { 0x67, 0x19, 0x19 },
+        "Plutonium Based Liquid Fuel (Depleted)",
+        subscriptNumbers("Tn?Ce?Au?Kr?"),
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 11,
+        TextureSet.SET_FLUID);
+
+    // Thorium-233
+    public static final Werkstoff oxalate = new Werkstoff(
+        new short[] { 0x79, 0xd8, 0x55 },
+        "Oxalate",
+        Werkstoff.Types.BIOLOGICAL,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 12,
+        TextureSet.SET_FLUID,
+        new Pair<>(Hydrogen, 2),
+        new Pair<>(Carbon, 2),
+        new Pair<>(Oxygen, 4));
+
+    public static final Werkstoff vanadiumPentoxide = new Werkstoff(
+        new short[] { 0xde, 0x8d, 0x12 },
+        "Vanadium Pentoxide",
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 13,
+        TextureSet.SET_SHINY,
+        new Pair<>(Vanadium, 2),
+        new Pair<>(Oxygen, 5));
+
+    public static final Werkstoff thoriumNitrate = new Werkstoff(
+        new short[] { 0xba, 0xe8, 0x26 },
+        "Thorium Nitrate",
+        subscriptNumbers("Th(NO3)4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 14,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff thoriumOxalate = new Werkstoff(
+        new short[] { 0x50, 0x63, 0x13 },
+        "Thorium Oxalate",
+        subscriptNumbers("Th(C2O4)2"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 15,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff thoriumHydroxide = new Werkstoff(
+        new short[] { 0x92, 0xae, 0x89 },
+        "Thorium Hydroxide",
+        subscriptNumbers("Th(OH)4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 16,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff sodiumOxalate = new Werkstoff(
+        new short[] { 0xe4, 0xf8, 0x9b },
+        "Sodium Oxalate",
+        subscriptNumbers("Na2C2O4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 17,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff thoriumTetrachloride = new Werkstoff(
+        new short[] { 0x13, 0x7c, 0x16 },
+        "Thorium Tetrachloride",
+        subscriptNumbers("ThCl4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 18,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thoriumTetrafluoride = new Werkstoff(
+        new short[] { 0x15, 0x6a, 0x6a },
+        "Thorium Tetrafluoride",
+        subscriptNumbers("ThF4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 19,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thorium232Tetrafluoride = new Werkstoff(
+        new short[] { 0x15, 0x6a, 0x6a },
+        "Thorium-232 Tetrafluoride",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 20,
+        TextureSet.SET_FLUID,
+        new Pair<>(WerkstoffLoader.Thorium232, 1),
+        new Pair<>(Fluorine, 4));
+
+    // Atomic Separation Catalyst
+    public static final Werkstoff orundum = new Werkstoff(
+        new short[] { 0xcd, 0x26, 0x26 },
+        "Orundum",
+        "Or",
+        new Werkstoff.Stats().setProtons(120)
+            .setMass(300),
+        Werkstoff.Types.ELEMENT,
+        new Werkstoff.GenerationFeatures().addGems()
+            .addMolten(),
+        OffsetID + 22,
+        TextureSet.SET_DIAMOND);
+
+    public static final Werkstoff atomicSeparationCatalyst = new Werkstoff(
+        new short[] { 0xe8, 0x5e, 0x0c },
+        "Atomic Separation Catalyst",
+        "the melting core...",
+        new Werkstoff.Stats().setMeltingPoint(5000),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addSimpleMetalWorkingItems()
+            .addCraftingMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems(),
+        OffsetID + 21,
+        TextureSet.SET_SHINY,
+        new Pair<>(MyMaterial.orundum, 2),
+        new Pair<>(Plutonium, 1),
+        new Pair<>(Naquadah, 2));
+
+    // Naquadah Fuel Rework
+    public static final Werkstoff extremelyUnstableNaquadah = new Werkstoff(
+        new short[] { 0x06, 0x26, 0x05 },
+        "Extremely Unstable Naquadah",
+        "Nq" + CharExchanger.shifter(9734),
+        new Werkstoff.Stats().setMeltingPoint(7000)
+            .setBlastFurnace(true)
+            .setProtons(200)
+            .setMass(450)
+            .setRadioactive(true),
+        Werkstoff.Types.ELEMENT,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addSimpleMetalWorkingItems()
+            .addCraftingMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems(),
+        OffsetID + 23,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff lightNaquadahFuel = new Werkstoff(
+        new short[] { 92, 203, 92 },
+        "Light Naquadah Fuel",
+        "far from enough",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 24,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff heavyNaquadahFuel = new Werkstoff(
+        new short[] { 54, 255, 54 },
+        "Heavy Naquadah Fuel",
+        "still need processing",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 25,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahGas = new Werkstoff(
+        new short[] { 93, 219, 0 },
+        "Naquadah Gas",
+        "Who need it?",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true)
+            .setGas(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 26,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahAsphalt = new Werkstoff(
+        new short[] { 5, 37, 5 },
+        "Naquadah Asphalt",
+        "It will damage the reactor.",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 27,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff ether = new Werkstoff(
+        new short[] { 0xeb, 0xbc, 0x2f },
+        "Ether",
+        subscriptNumbers("CH3CH2OCH2CH3"),
+        new Werkstoff.Stats().setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 28,
+        TextureSet.SET_FLUID,
+        new Pair<>(Carbon, 4),
+        new Pair<>(Hydrogen, 10),
+        new Pair<>(Oxygen, 1));
+
+    public static final Werkstoff antimonyTrichloride = new Werkstoff(
+        new short[] { 0x0f, 0xdc, 0x34 },
+        "Antimony Trichloride Solution",
+        subscriptNumbers("SbCl3"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 29,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff antimonyPentachlorideSolution = new Werkstoff(
+        new short[] { 0x15, 0x93, 0x2c },
+        "Antimony Pentachloride Solution",
+        subscriptNumbers("SbCl5"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 30,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff antimonyPentachloride = new Werkstoff(
+        new short[] { 0x15, 0x93, 0x2c },
+        "Antimony Pentachloride",
+        subscriptNumbers("SbCl5"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 31,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff antimonyPentafluoride = new Werkstoff(
+        new short[] { 0x16, 0xd5, 0xe2 },
+        "Antimony Pentafluoride",
+        subscriptNumbers("SbF5"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 32,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff fluoroantimonicAcid = new Werkstoff(
+        new short[] { 0x16, 0xd5, 0xe2 },
+        "Fluoroantimonic Acid",
+        subscriptNumbers("HSbF6"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 33,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff radioactiveSludge = new Werkstoff(
+        new short[] { 0xb3, 0x49, 0x1e },
+        "Radioactive Sludge",
+        ">>> DANGER <<<",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 34,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff acidNaquadahEmulsion = new Werkstoff(
+        new short[] { 0x25, 0x22, 0x22 },
+        "Acid Naquadah Emulsion",
+        "??Nq??H" + CharExchanger.shifter(8314),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 35,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahEmulsion = new Werkstoff(
+        new short[] { 0x4a, 0x46, 0x45 },
+        "Naquadah Emulsion",
+        "??Nq??",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 36,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahSolution = new Werkstoff(
+        new short[] { 0x84, 0x81, 0x80 },
+        "Naquadah Solution",
+        "~Nq~",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 37,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkI = new Werkstoff(
+        new short[] { 0x62, 0x5c, 0x5b },
+        "Naquadah Based Liquid Fuel MkI",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 38,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkIDepleted = new Werkstoff(
+        new short[] { 0xcb, 0xc3, 0xc1 },
+        "Naquadah Based Liquid Fuel MkI (Depleted)",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 39,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkII = new Werkstoff(
+        new short[] { 0x52, 0x4e, 0x4d },
+        "Naquadah Based Liquid Fuel MkII",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 40,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkIIDepleted = new Werkstoff(
+        new short[] { 0xb5, 0xb0, 0xae },
+        "Naquadah Based Liquid Fuel MkII (Depleted)",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 41,
+        TextureSet.SET_FLUID);
+    /* These materials will be enable when they are removed in GregTech */
+    /*
+     * public static final Werkstoff praseodymium = new Werkstoff( new short[]{0xff,0xff,0xff}, "praseodymium", "Pr",
+     * new Werkstoff.Stats(), Werkstoff.Types.ELEMENT, new
+     * Werkstoff.GenerationFeatures().disable().onlyDust().addMolten().addMetalItems(), OffsetID + 42,
+     * TextureSet.SET_METALLIC ); public static final Werkstoff rubidium = new Werkstoff( new short[]{0xff,0x2a,0x00},
+     * "rubidium", "Rb", new Werkstoff.Stats(), Werkstoff.Types.ELEMENT, new
+     * Werkstoff.GenerationFeatures().disable().onlyDust().addMolten().addMetalItems(), OffsetID + 43,
+     * TextureSet.SET_SHINY ); public static final Werkstoff thulium = new Werkstoff( new short[]{0xff,0xff,0xff},
+     * "Thulium", "Tm", new Werkstoff.Stats(), Werkstoff.Types.ELEMENT, new
+     * Werkstoff.GenerationFeatures().disable().onlyDust().addMolten().addMetalItems(), OffsetID + 44,
+     * TextureSet.SET_METALLIC );
+     */
+    public static final Werkstoff naquadahBasedFuelMkIII = new Werkstoff(
+        new short[] { 0x29, 0x22, 0x21 },
+        "Naquadah Based Liquid Fuel MkIII",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 45,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkIIIDepleted = new Werkstoff(
+        new short[] { 0x66, 0x40, 0x38 },
+        "Naquadah Based Liquid Fuel MkIII (Depleted)",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 46,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkIV = new Werkstoff(
+        new short[] { 0x0e, 0x0c, 0x0c },
+        "Naquadah Based Liquid Fuel MkIV",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 47,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkIVDepleted = new Werkstoff(
+        new short[] { 0x8e, 0x34, 0x22 },
+        "Naquadah Based Liquid Fuel MkIV (Depleted)",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 48,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkV = new Werkstoff(
+        new short[] { 0x00, 0x00, 0x00 },
+        "Naquadah Based Liquid Fuel MkV",
+        "THE END",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 49,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkVDepleted = new Werkstoff(
+        new short[] { 0xff, 0xff, 0xff },
+        "Naquadah Based Liquid Fuel MkV (Depleted)",
+        "THE END (literally)",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 50,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkVI = new Werkstoff(
+        new short[] { 0x30, 0x00, 0x00 },
+        "Naquadah Based Liquid Fuel MkVI",
+        "THE FUTURE",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 115,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahBasedFuelMkVIDepleted = new Werkstoff(
+        new short[] { 0x99, 0x33, 0x33 },
+        "Naquadah Based Liquid Fuel MkVI (Depleted)",
+        "THE FUTURE (achieved)",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 116,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff zincChloride = new Werkstoff(
+        new short[] { 0x73, 0xa5, 0xfc },
+        "Zinc Chloride",
+        subscriptNumbers("ZnCl2"),
+        new Werkstoff.Stats().setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 51,
+        TextureSet.SET_SHINY,
+        new Pair<>(Zinc, 1),
+        new Pair<>(Chlorine, 2));
+
+    public static final Werkstoff zincThoriumAlloy = new Werkstoff(
+        new short[] { 0x12, 0x34, 0x56 },
+        "Zn-Th Alloy",
+        subscriptNumbers("ZnTh"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust()
+            .addMolten()
+            .addMetalItems(),
+        OffsetID + 52,
+        TextureSet.SET_SHINY,
+        new Pair<>(Zinc, 1),
+        new Pair<>(Thorium, 1));
+
+    // Naquadah Rework Materials
+    public static final Werkstoff naquadahEarth = new Werkstoff(
+        new short[] { 0x4c, 0x4c, 0x4c },
+        "Naquadah Oxide Mixture",
+        subscriptNumbers("??NqTiGaAd??"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures(),
+        OffsetID + 53,
+        TextureSet.SET_METALLIC);
+
+    public static final Werkstoff titaniumTrifluoride = new Werkstoff(
+        new short[] { 0xc0, 0x92, 0xa8 },
+        "Titanium Trifluoride",
+        subscriptNumbers("TiF3"),
+        new Werkstoff.Stats().setElektrolysis(false),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 54,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Titanium, 1),
+        new Pair<>(Fluorine, 3));
+
+    public static final Werkstoff lowQualityNaquadahEmulsion = new Werkstoff(
+        new short[] { 0x4c, 0x4c, 0x4c },
+        "Low Quality Naquadah Emulsion",
+        subscriptNumbers("??NqGaAd??"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 55,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff galliumHydroxide = new Werkstoff(
+        new short[] { 0xa6, 0xa6, 0xa6 },
+        "Gallium Hydroxide",
+        subscriptNumbers("Ga(OH)3"),
+        new Werkstoff.Stats().setElektrolysis(false),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 56,
+        TextureSet.SET_DULL,
+        new Pair<>(Gallium, 1),
+        new Pair<>(Oxygen, 3),
+        new Pair<>(Hydrogen, 3));
+
+    public static final Werkstoff lowQualityNaquadahSolution = new Werkstoff(
+        new short[] { 0x71, 0x62, 0x62 },
+        "Low Quality Naquadah Solution",
+        subscriptNumbers("~??NqAd??~"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 57,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff towEthyl1Hexanol = new Werkstoff(
+        new short[] { 0x80, 0xb5, 0x57 },
+        "2-Ethyl-1-Hexanol",
+        subscriptNumbers("C8H18O"),
+        new Werkstoff.Stats().setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 58,
+        TextureSet.SET_FLUID,
+        new Pair<>(Carbon, 8),
+        new Pair<>(Oxygen, 1),
+        new Pair<>(Hydrogen, 18));
+
+    public static final Werkstoff P507 = new Werkstoff(
+        new short[] { 0x29, 0xc2, 0x2a },
+        "P-507",
+        subscriptNumbers("(C8H17)2PO3H"),
+        new Werkstoff.Stats().setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 59,
+        TextureSet.SET_FLUID,
+        new Pair<>(Carbon, 16),
+        new Pair<>(Phosphorus, 1),
+        new Pair<>(Oxygen, 3),
+        new Pair<>(Hydrogen, 35));
+
+    public static final Werkstoff naquadahAdamantiumSolution = new Werkstoff(
+        new short[] { 0x3d, 0x38, 0x38 },
+        "Naquadah-Adamantium Solution",
+        subscriptNumbers("~NqAd~"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 60,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahRichSolution = new Werkstoff(
+        new short[] { 0x33, 0x33, 0x33 },
+        "Naquadah-Rich Solution",
+        subscriptNumbers("~?Nq?~"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 61,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahine = new Werkstoff(
+        new short[] { 0x33, 0x33, 0x33 },
+        "Naquadahine",
+        subscriptNumbers("NqO2"),
+        new Werkstoff.Stats().setElektrolysis(false),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 62,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Naquadah, 1),
+        new Pair<>(Oxygen, 2));
+
+    public static final Werkstoff fluorineRichWasteLiquid = new Werkstoff(
+        new short[] { 0x13, 0x68, 0x62 },
+        "Fluorine-Rich Waste Liquid",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 63,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff wasteLiquid = new Werkstoff(
+        new short[] { 0x14, 0x1c, 0x68 },
+        "Waste Liquid",
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 64,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff adamantine = new Werkstoff(
+        new short[] { 0xb7, 0xb7, 0xb7 },
+        "Adamantine",
+        subscriptNumbers("Ad2O3"),
+        new Werkstoff.Stats().setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 65,
+        TextureSet.SET_DULL,
+        new Pair<>(Adamantium, 2),
+        new Pair<>(Oxygen, 3));
+
+    public static final Werkstoff enrichedNaquadahEarth = new Werkstoff(
+        new short[] { 0x82, 0x68, 0x68 },
+        "Enriched-Naquadah Oxide Mixture",
+        subscriptNumbers("??KeNq") + CharExchanger.shifter(8314) + "??",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures(),
+        OffsetID + 66,
+        TextureSet.SET_METALLIC);
+
+    public static final Werkstoff triniumSulphate = new Werkstoff(
+        new short[] { 0xda, 0xda, 0xda },
+        "Trinium Sulphate",
+        subscriptNumbers("KeSO4"),
+        new Werkstoff.Stats().setElektrolysis(false),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 67,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Trinium, 1),
+        new Pair<>(Sulfur, 1),
+        new Pair<>(Oxygen, 4));
+
+    public static final Werkstoff enrichedNaquadahRichSolution = new Werkstoff(
+        new short[] { 0x52, 0x39, 0x39 },
+        "Enriched-Naquadah-Rich Solution",
+        subscriptNumbers("~?Nq") + CharExchanger.shifter(8314) + "?~",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 68,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff concentratedEnrichedNaquadahSludge = new Werkstoff(
+        new short[] { 0x52, 0x39, 0x39 },
+        "Concentrated Enriched-Naquadah Sludge",
+        subscriptNumbers("?Nq") + CharExchanger.shifter(8314) + "?",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 69,
+        TextureSet.SET_METALLIC);
+
+    public static final Werkstoff enrichedNaquadahSulphate = new Werkstoff(
+        new short[] { 0x52, 0x39, 0x39 },
+        "Enriched-Naquadah Sulphate",
+        "Nq" + CharExchanger.shifter(8314) + subscriptNumbers("(SO4)2"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 70,
+        TextureSet.SET_DULL,
+        new Pair<>(NaquadahEnriched, 1),
+        new Pair<>(Sulfur, 2),
+        new Pair<>(Oxygen, 8));
+
+    public static final Werkstoff naquadriaEarth = new Werkstoff(
+        new short[] { 0x4d, 0x4d, 0x55 },
+        "Naquadria Oxide Mixture",
+        subscriptNumbers("??Nq*BaIn??"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures(),
+        OffsetID + 71,
+        TextureSet.SET_METALLIC);
+
+    public static final Werkstoff indiumPhosphate = new Werkstoff(
+        new short[] { 0x2b, 0x2e, 0x70 },
+        "Indium Phosphate",
+        subscriptNumbers("InPO4"),
+        new Werkstoff.Stats().setToxic(true)
+            .setElektrolysis(false),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 72,
+        TextureSet.SET_DULL,
+        new Pair<>(Indium, 1),
+        new Pair<>(Phosphorus, 1),
+        new Pair<>(Oxygen, 4));
+
+    public static final Werkstoff lowQualityNaquadriaPhosphate = new Werkstoff(
+        new short[] { 0x4d, 0x4d, 0x55 },
+        "Low Quality Naquadria Phosphate",
+        subscriptNumbers("??Nq*3(PO4)4??"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 73,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff naquadriaRichSolution = new Werkstoff(
+        new short[] { 0x1f, 0x1e, 0x33 },
+        "Naquadria-Rich Solution",
+        subscriptNumbers("~?Nq*?~"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 74,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff lowQualityNaquadriaSulphate = new Werkstoff(
+        new short[] { 0x73, 0x72, 0x84 },
+        "Low Quality Naquadria Sulphate",
+        subscriptNumbers("??Nq*(SO4)2??"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 75,
+        TextureSet.SET_METALLIC);
+
+    public static final Werkstoff lowQualityNaquadriaSolution = new Werkstoff(
+        new short[] { 0x73, 0x72, 0x84 },
+        "Low Quality Naquadria Sulphate",
+        subscriptNumbers("~??Nq*??~"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 76,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadriaSulphate = new Werkstoff(
+        new short[] { 0x1f, 0x1e, 0x33 },
+        "Naquadria Sulphate",
+        subscriptNumbers("Nq*(SO4)2"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true)
+            .setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 77,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Naquadria, 1),
+        new Pair<>(Sulfur, 2),
+        new Pair<>(Oxygen, 8));
+
+    public static final Werkstoff naquadahGoo = new Werkstoff(
+        new short[] { 0x4c, 0x4c, 0x4c },
+        "Naquadah Goo",
+        subscriptNumbers("??NqTiGaAd??"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 78,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff enrichedNaquadahGoo = new Werkstoff(
+        new short[] { 0x82, 0x68, 0x68 },
+        "Enriched Naquadah Goo",
+        subscriptNumbers("??KeNq") + CharExchanger.shifter(8314) + "??",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 79,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadriaGoo = new Werkstoff(
+        new short[] { 0x4d, 0x4d, 0x55 },
+        "Naquadria Goo",
+        subscriptNumbers("??Nq*BaIn??"),
+        new Werkstoff.Stats().setRadioactive(true)
+            .setToxic(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 80,
+        TextureSet.SET_FLUID);
+
+    // material for reactor stuff
+    public static final Werkstoff zircaloy4 = new Werkstoff(
+        new short[] { 0x8a, 0x6e, 0x68 },
+        "Zircaloy-4",
+        subscriptNumbers("Zr34Sn5Fe2Cr"),
+        new Werkstoff.Stats().setCentrifuge(true)
+            .setBlastFurnace(true)
+            .setMeltingPoint(2800),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 4),
+        OffsetID + 81,
+        TextureSet.SET_METALLIC,
+        new Pair<>(WerkstoffLoader.Zirconium, 34),
+        new Pair<>(Tin, 5),
+        new Pair<>(Iron, 2),
+        new Pair<>(Chrome, 1));
+
+    public static final Werkstoff zircaloy2 = new Werkstoff(
+        new short[] { 0xa4, 0x8f, 0x8b },
+        "Zircaloy-2",
+        subscriptNumbers("Zr34Sn4FeCrNi"),
+        new Werkstoff.Stats().setCentrifuge(true)
+            .setBlastFurnace(true)
+            .setMeltingPoint(2800),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 2),
+        OffsetID + 82,
+        TextureSet.SET_METALLIC,
+        new Pair<>(WerkstoffLoader.Zirconium, 34),
+        new Pair<>(Tin, 4),
+        new Pair<>(Iron, 1),
+        new Pair<>(Chrome, 1),
+        new Pair<>(Nickel, 1));
+
+    public static final Werkstoff incoloy903 = new Werkstoff(
+        new short[] { 0xa4, 0x8f, 0x8b },
+        "Incoloy-903",
+        subscriptNumbers("Fe12Ni10Co8Ti4Mo2Al"),
+        new Werkstoff.Stats().setCentrifuge(true)
+            .setBlastFurnace(true)
+            .setMeltingPoint(3700),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addSimpleMetalWorkingItems()
+            .addMixerRecipes((short) 6),
+        OffsetID + 83,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Iron, 12),
+        new Pair<>(Nickel, 10),
+        new Pair<>(Cobalt, 8),
+        new Pair<>(Titanium, 4),
+        new Pair<>(Molybdenum, 2),
+        new Pair<>(Aluminium, 1));
+
+    public static final Werkstoff adamantiumAlloy = new Werkstoff(
+        new short[] { 0xa0, 0xa0, 0xa0 },
+        "Adamantium Alloy",
+        subscriptNumbers("Ad5Nq2La3"),
+        new Werkstoff.Stats().setCentrifuge(true)
+            .setBlastFurnace(true)
+            .setMeltingPoint(5500)
+            .setSpeedOverride(191.2F)
+            .setDurOverride(102400),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addSimpleMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems()
+            .addMixerRecipes((short) 3),
+        OffsetID + 84,
+        TextureSet.SET_SHINY,
+        new Pair<>(Adamantium, 5),
+        new Pair<>(Naquadah, 2),
+        new Pair<>(Lanthanum, 3));
+
+    public static final Werkstoff ethanolGasoline = new Werkstoff(
+        new short[] { 0xe4, 0xc6, 0x61 },
+        "Ethanol Gasoline",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 85,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff cyclopentadiene = new Werkstoff(
+        new short[] { 0xff, 0xf6, 0xbd },
+        "Cyclopentadiene",
+        subscriptNumbers("C5H6"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 86,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff ferrousChloride = new Werkstoff(
+        new short[] { 0x5b, 0x5b, 0x5b },
+        "Iron II Chloride",
+        subscriptNumbers("FeCl2"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 87,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff diethylamine = new Werkstoff(
+        new short[] { 0x69, 0x77, 0xca },
+        "Diethylamine",
+        subscriptNumbers("C4H11N"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 88,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff impureFerroceneMixture = new Werkstoff(
+        new short[] { 0x79, 0x55, 0x08 },
+        "Impure Ferrocene Mixture",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 89,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff ferroceneSolution = new Werkstoff(
+        new short[] { 0xde, 0x7e, 0x1c },
+        "Ferrocene Solution",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 90,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff ferroceneWaste = new Werkstoff(
+        new short[] { 0x35, 0x1d, 0x03 },
+        "Ferrocene Waste",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 91,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff ferrocene = new Werkstoff(
+        new short[] { 0xf1, 0x8f, 0x2b },
+        "Ferrocene",
+        subscriptNumbers("Fe(C5H5)2"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 92,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff ironedKerosene = new Werkstoff(
+        new short[] { 0x97, 0x00, 0x61 },
+        "Jet Fuel No.3",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 93,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff ironedFuel = new Werkstoff(
+        new short[] { 0xff, 0x98, 0x00 },
+        "Jet Fuel A",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 94,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff marM200 = new Werkstoff(
+        new short[] { 0x51, 0x51, 0x51 },
+        "MAR-M200 Steel",
+        new Werkstoff.Stats().setCentrifuge(true)
+            .setBlastFurnace(true)
+            .setMeltingPoint(5000),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addSimpleMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems()
+            .addMixerRecipes((short) 7),
+        OffsetID + 95,
+        TextureSet.SET_SHINY,
+        new Pair<>(Niobium, 2),
+        new Pair<>(Chrome, 9),
+        new Pair<>(Aluminium, 5),
+        new Pair<>(Titanium, 2),
+        new Pair<>(Cobalt, 10),
+        new Pair<>(Tungsten, 13),
+        new Pair<>(Nickel, 18));
+
+    public static final Werkstoff marCeM200 = new Werkstoff(
+        new short[] { 0x38, 0x30, 0x30 },
+        "MAR-Ce-M200 Steel",
+        new Werkstoff.Stats().setCentrifuge(true)
+            .setBlastFurnace(true)
+            .setMeltingPoint(5000)
+            .setMass(1200)
+            .setProtons(1000)
+            .setSpeedOverride(150F)
+            .setDurOverride(204800),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addSimpleMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems(),
+        OffsetID + 96,
+        TextureSet.SET_METALLIC,
+        new Pair<>(marM200, 18),
+        new Pair<>(Cerium, 1));
+
+    public static final Werkstoff lithiumChloride = new Werkstoff(
+        new short[] { 0xb7, 0xe2, 0xce },
+        "Lithium Chloride",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .enforceUnification(),
+        OffsetID + 97,
+        TextureSet.SET_DULL,
+        new Pair<>(Lithium, 1),
+        new Pair<>(Chlorine, 1));
+
+    public static final Werkstoff signalium = new Werkstoff(
+        new short[] { 0xd4, 0x40, 0x00 },
+        "Signalium",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(4000),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems(),
+        OffsetID + 98,
+        TextureSet.SET_SHINY,
+        new Pair<>(AnnealedCopper, 4),
+        new Pair<>(Ardite, 2),
+        new Pair<>(RedAlloy, 2));
+
+    public static final Werkstoff lumiinessence = new Werkstoff(
+        new short[] { 0xe8, 0xf2, 0x24 },
+        "Lumiinessence",
+        subscriptNumbers("(Al??)2(PO4)4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust(),
+        OffsetID + 99,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff lumiium = new Werkstoff(
+        new short[] { 0xe8, 0xf2, 0x24 },
+        "Lumiium",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(4000),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems(),
+        OffsetID + 100,
+        TextureSet.SET_SHINY,
+        new Pair<>(TinAlloy, 4),
+        new Pair<>(SterlingSilver, 2),
+        new Pair<>(lumiinessence, 2));
+
+    public static final Werkstoff artheriumSn = new Werkstoff(
+        new short[] { 0x60, 0x36, 0xf7 },
+        "Artherium-Sn",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(6500)
+            .setCentrifuge(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 6),
+        OffsetID + 101,
+        TextureSet.SET_SHINY,
+        new Pair<>(adamantiumAlloy, 12),
+        new Pair<>(orundum, 9),
+        new Pair<>(Tin, 8),
+        new Pair<>(Arsenic, 7),
+        new Pair<>(Caesium, 4),
+        new Pair<>(Osmiridium, 3));
+
+    public static final Werkstoff titaniumBetaC = new Werkstoff(
+        new short[] { 0xc7, 0x2f, 0xcc },
+        "Tanmolyium Beta-C",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(5300)
+            .setCentrifuge(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 5),
+        OffsetID + 102,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Titanium, 5),
+        new Pair<>(Molybdenum, 5),
+        new Pair<>(Vanadium, 2),
+        new Pair<>(Chrome, 3),
+        new Pair<>(Aluminium, 1));
+
+    public static final Werkstoff dalisenite = new Werkstoff(
+        new short[] { 0xb0, 0xb8, 0x12 },
+        "Dalisenite",
+        new Werkstoff.Stats().setMeltingPoint(8700)
+            .setCentrifuge(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 6),
+        OffsetID + 103,
+        TextureSet.SET_SHINY,
+        new Pair<>(titaniumBetaC, 14),
+        new Pair<>(Tungsten, 10),
+        new Pair<>(NiobiumTitanium, 9),
+        new Pair<>(WerkstoffLoader.LuVTierMaterial, 8),
+        new Pair<>(Quantium, 7),
+        new Pair<>(Erbium, 3));
+
+    public static final Werkstoff hikarium = new Werkstoff(
+        new short[] { 0xff, 0xd6, 0xfb },
+        "Hikarium",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(5400)
+            .setCentrifuge(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 3),
+        OffsetID + 104,
+        TextureSet.SET_SHINY,
+        new Pair<>(lumiium, 18),
+        new Pair<>(Silver, 8),
+        new Pair<>(Sunnarium, 4));
+
+    public static final Werkstoff tairitsu = new Werkstoff(
+        new short[] { 0x36, 0x36, 0x36 },
+        "Tairitsu",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(7400)
+            .setCentrifuge(true),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMixerRecipes((short) 6),
+        OffsetID + 105,
+        TextureSet.SET_SHINY,
+        new Pair<>(Tungsten, 8),
+        new Pair<>(Naquadria, 7),
+        new Pair<>(Bedrockium, 4),
+        new Pair<>(Carbon, 4),
+        new Pair<>(Vanadium, 3),
+        new Pair<>(BlackPlutonium, 1));
+
+    public static final Werkstoff antimonyPentafluorideSolution = new Werkstoff(
+        new short[] { 0x16, 0xd5, 0xe2 },
+        "Antimony Pentafluoride Solution",
+        subscriptNumbers("SbF5"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 106,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff magnesiumSulphate = new Werkstoff(
+        new short[] { 0x87, 0x74, 0x91 },
+        "Magnesium Sulphate",
+        subscriptNumbers("MgSO4"),
+        new Werkstoff.Stats().setElektrolysis(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 107,
+        TextureSet.SET_DULL,
+        new Pair<>(Magnesium, 1),
+        new Pair<>(Sulfur, 1),
+        new Pair<>(Oxygen, 4));
+
+    public static final Werkstoff preciousMetalAlloy = new Werkstoff(
+        new short[] { 0x9d, 0x90, 0xc6 },
+        "Precious Metals Alloy",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(10000)
+            .setCentrifuge(true)
+            .setSpeedOverride(100F),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems()
+            .addMixerRecipes((short) 6),
+        OffsetID + 108,
+        TextureSet.SET_SHINY,
+        new Pair<>(WerkstoffLoader.Ruthenium, 1),
+        new Pair<>(WerkstoffLoader.Rhodium, 1),
+        new Pair<>(Palladium, 1),
+        new Pair<>(Platinum, 1),
+        new Pair<>(Osmium, 1),
+        new Pair<>(Iridium, 1));
+
+    public static final Werkstoff enrichedNaquadahAlloy = new Werkstoff(
+        new short[] { 0x16, 0x07, 0x40 },
+        "Enriched Naquadah Alloy",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setMeltingPoint(11000)
+            .setCentrifuge(true)
+            .setSpeedOverride(180F),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addSimpleMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems()
+            .addMixerRecipes((short) 4),
+        OffsetID + 109,
+        TextureSet.SET_METALLIC,
+        new Pair<>(NaquadahEnriched, 8),
+        new Pair<>(Tritanium, 5),
+        new Pair<>(WerkstoffLoader.Californium, 3),
+        new Pair<>(BlackPlutonium, 2));
+
+    public static final Werkstoff metastableOganesson = new Werkstoff(
+        new short[] { 0x14, 0x39, 0x7f },
+        "Metastable Oganesson",
+        "Og*",
+        new Werkstoff.Stats().setBlastFurnace(true)
+            .setProtons(118)
+            .setMass(294)
+            .setMeltingPoint(11000),
+        Werkstoff.Types.ELEMENT,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems()
+            .addMetaSolidifierRecipes(),
+        OffsetID + 110,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff shirabon = new Werkstoff(
+        new short[] { 0xe0, 0x15, 0x6d },
+        "Shirabon",
+        "Sh" + CharExchanger.shifter(9191),
+        new Werkstoff.Stats().setProtons(500)
+            .setMass(750)
+            .setMeltingPoint(13000)
+            .setSpeedOverride(640.0F)
+            .setDurOverride(15728640)
+            .setQualityOverride((byte) 26),
+        Werkstoff.Types.ELEMENT,
+        new Werkstoff.GenerationFeatures().onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addCraftingMetalWorkingItems()
+            .addSimpleMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems()
+            .addMetalCraftingSolidifierRecipes()
+            .addMetaSolidifierRecipes(),
+        OffsetID + 111,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff inertNaquadah = new Werkstoff(
+        new short[] { 0x3b, 0x3b, 0x3b },
+        "Inert Naquadah",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MATERIAL,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 112,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Naquadah, 1));
+
+    public static final Werkstoff inertEnrichedNaquadah = new Werkstoff(
+        new short[] { 0x61, 0x44, 0x44 },
+        "Inert Enriched Naquadah",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MATERIAL,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 113,
+        TextureSet.SET_METALLIC,
+        new Pair<>(NaquadahEnriched, 1));
+
+    public static final Werkstoff inertNaquadria = new Werkstoff(
+        new short[] { 0x00, 0x00, 0x00 },
+        "Inert Naquadria",
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.MATERIAL,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 114,
+        TextureSet.SET_METALLIC,
+        new Pair<>(Naquadria, 1));
+
+    @Override
+    public void run() {}
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/RadioactiveItem.java b/goodgen/src/main/java/goodgenerator/items/RadioactiveItem.java
new file mode 100644
index 0000000000..ab6c003268
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/RadioactiveItem.java
@@ -0,0 +1,40 @@
+package goodgenerator.items;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+import gregtech.api.util.GT_Utility;
+import ic2.core.IC2Potion;
+
+public class RadioactiveItem extends MyItems {
+
+    protected final int mRadio;
+
+    public RadioactiveItem(String name, CreativeTabs Tab, int Rad) {
+        super(name, Tab);
+        this.mRadio = Rad;
+    }
+
+    public RadioactiveItem(String name, String[] tooltip, CreativeTabs Tab, int Rad) {
+        super(name, tooltip, Tab);
+        this.mRadio = Rad;
+    }
+
+    public RadioactiveItem(String name, String tooltip, CreativeTabs Tab, int Rad) {
+        super(name, tooltip, Tab);
+        this.mRadio = Rad;
+    }
+
+    @Override
+    public void onUpdate(ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, boolean aIsInHand) {
+        super.onUpdate(aStack, aWorld, aPlayer, aTimer, aIsInHand);
+        EntityLivingBase tPlayer = (EntityPlayer) aPlayer;
+        if (!GT_Utility.isWearingFullRadioHazmat(tPlayer))
+            tPlayer.addPotionEffect(new PotionEffect(IC2Potion.radiation.id, mRadio, 4));
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/items/nuclear/IsotopeMaterial.java b/goodgen/src/main/java/goodgenerator/items/nuclear/IsotopeMaterial.java
new file mode 100644
index 0000000000..593a663a71
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/nuclear/IsotopeMaterial.java
@@ -0,0 +1,60 @@
+// package goodgenerator.items.nuclear;
+//
+// import goodgenerator.loader.Loaders;
+// import net.minecraft.item.ItemStack;
+//
+// import java.util.HashMap;
+// import java.util.HashSet;
+//
+// public class IsotopeMaterial {
+//
+// public static final HashSet<IsotopeMaterial> mIsotopeMaterial = new HashSet<>();
+// public static final HashMap<Integer, IsotopeMaterial> mIDMap = new HashMap<>();
+// public static final HashMap<String, IsotopeMaterial> mNameMap = new HashMap<>();
+//
+// public final int mID;
+// public final int mNeutron;
+// public final String mName;
+// public final String mLocalizedName;
+// public final String mMaterialName;
+// public final short[] mRGB;
+// public final short[] mRGBO;
+// public final NuclearTextures mTexture;
+//
+// public IsotopeMaterial(int aID, String aName, String aMaterialName, String aLocalizedName, NuclearTextures
+// aTexture, int aR, int aG, int aB, int aNeutron) {
+// if (mIDMap.get(aID) != null)
+// throw new UnsupportedOperationException("ID:" + aID + " is already used!");
+// this.mID = aID;
+// this.mNeutron = aNeutron;
+// this.mName = aName;
+// this.mMaterialName = aMaterialName;
+// this.mLocalizedName = aLocalizedName;
+// this.mRGB = new short[] {(short) (aR * 0.6), (short) (aG * 0.6), (short) (aB * 0.6), 0};
+// this.mRGBO = new short[] {(short) aR, (short) aG, (short) aB, 0};
+// this.mTexture = aTexture;
+// mIsotopeMaterial.add(this);
+// mIDMap.put(this.mID, this);
+// mNameMap.put(this.mName, this);
+// }
+//
+// public ItemStack getFull(int aAmount) {
+// if (aAmount > 64) aAmount = 64;
+// return new ItemStack(Loaders.Isotope, aAmount, mID + 1000);
+// }
+//
+// public ItemStack getTiny(int aAmount) {
+// if (aAmount > 64) aAmount = 64;
+// return new ItemStack(Loaders.Isotope, aAmount, mID + 2000);
+// }
+//
+// public ItemStack getFullOxide(int aAmount) {
+// if (aAmount > 64) aAmount = 64;
+// return new ItemStack(Loaders.Isotope, aAmount, mID + 3000);
+// }
+//
+// public ItemStack getTinyOxide(int aAmount) {
+// if (aAmount > 64) aAmount = 64;
+// return new ItemStack(Loaders.Isotope, aAmount, mID + 4000);
+// }
+// }
diff --git a/goodgen/src/main/java/goodgenerator/items/nuclear/IsotopeMaterialLoader.java b/goodgen/src/main/java/goodgenerator/items/nuclear/IsotopeMaterialLoader.java
new file mode 100644
index 0000000000..a014abaa32
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/nuclear/IsotopeMaterialLoader.java
@@ -0,0 +1,177 @@
+// package goodgenerator.items.nuclear;
+//
+// public class IsotopeMaterialLoader implements Runnable {
+//
+// protected static final int OffsetID = 0;
+//
+// public static final IsotopeMaterial Thorium232 = new IsotopeMaterial(
+// OffsetID,
+// "Thorium232", "Thorium", "Thorium-232",
+// NuclearTextures.STABLE1, 59, 59, 59,
+// 232
+// );
+//
+// public static final IsotopeMaterial Thorium230 = new IsotopeMaterial(
+// OffsetID + 1,
+// "Thorium232", "Thorium", "Thorium-230",
+// NuclearTextures.STABLE2, 59, 59, 59,
+// 230
+// );
+//
+// public static final IsotopeMaterial Uranium233 = new IsotopeMaterial(
+// OffsetID + 2,
+// "Uranium233", "Uranium", "Uranium-233",
+// NuclearTextures.UNSTABLE4, 60, 167, 85,
+// 233
+// );
+//
+// public static final IsotopeMaterial Uranium235 = new IsotopeMaterial(
+// OffsetID + 3,
+// "Uranium235", "Uranium", "Uranium-235",
+// NuclearTextures.UNSTABLE3, 60, 167, 85,
+// 235
+// );
+//
+// public static final IsotopeMaterial Uranium238 = new IsotopeMaterial(
+// OffsetID + 4,
+// "Uranium238", "Uranium", "Uranium-238",
+// NuclearTextures.STABLE2, 60, 167, 85,
+// 238
+// );
+//
+// public static final IsotopeMaterial Neptunium236 = new IsotopeMaterial(
+// OffsetID + 5,
+// "Neptunium236", "Neptunium", "Neptunium-236",
+// NuclearTextures.UNSTABLE1, 60, 170, 176,
+// 236
+// );
+//
+// public static final IsotopeMaterial Neptunium237 = new IsotopeMaterial(
+// OffsetID + 6,
+// "Neptunium237", "Neptunium", "Neptunium-237",
+// NuclearTextures.STABLE2, 60, 170, 176,
+// 237
+// );
+//
+// public static final IsotopeMaterial Plutonium238 = new IsotopeMaterial(
+// OffsetID + 7,
+// "Plutonium238", "Plutonium", "Plutonium-238",
+// NuclearTextures.STABLE1, 169, 169, 169,
+// 238
+// );
+//
+// public static final IsotopeMaterial Plutonium239 = new IsotopeMaterial(
+// OffsetID + 8,
+// "Plutonium239", "Plutonium", "Plutonium-239",
+// NuclearTextures.UNSTABLE1, 169, 169, 169,
+// 239
+// );
+//
+// public static final IsotopeMaterial Plutonium241 = new IsotopeMaterial(
+// OffsetID + 9,
+// "Plutonium241", "Plutonium", "Plutonium-241",
+// NuclearTextures.UNSTABLE2, 169, 169, 169,
+// 241
+// );
+//
+// public static final IsotopeMaterial Plutonium242 = new IsotopeMaterial(
+// OffsetID + 10,
+// "Plutonium242", "Plutonium", "Plutonium-242",
+// NuclearTextures.STABLE2, 169, 169, 169,
+// 242
+// );
+//
+// public static final IsotopeMaterial Americium241 = new IsotopeMaterial(
+// OffsetID + 11,
+// "Americium241", "Americium", "Americium-241",
+// NuclearTextures.STABLE1, 150, 120, 22,
+// 241
+// );
+//
+// public static final IsotopeMaterial Americium242 = new IsotopeMaterial(
+// OffsetID + 12,
+// "Americium242", "Americium", "Americium-242",
+// NuclearTextures.UNSTABLE4, 150, 120, 22,
+// 242
+// );
+//
+// public static final IsotopeMaterial Americium243 = new IsotopeMaterial(
+// OffsetID + 13,
+// "Americium243", "Americium", "Americium-243",
+// NuclearTextures.STABLE2, 150, 120, 22,
+// 243
+// );
+//
+// public static final IsotopeMaterial Curium243 = new IsotopeMaterial(
+// OffsetID + 14,
+// "Curium243", "Curium", "Curium-243",
+// NuclearTextures.UNSTABLE1, 107, 6, 105,
+// 243
+// );
+//
+// public static final IsotopeMaterial Curium245 = new IsotopeMaterial(
+// OffsetID + 15,
+// "Curium245", "Curium", "Curium-245",
+// NuclearTextures.UNSTABLE3, 107, 6, 105,
+// 245
+// );
+//
+// public static final IsotopeMaterial Curium246 = new IsotopeMaterial(
+// OffsetID + 16,
+// "Curium246", "Curium", "Curium-246",
+// NuclearTextures.STABLE2, 107, 6, 105,
+// 246
+// );
+//
+// public static final IsotopeMaterial Curium247 = new IsotopeMaterial(
+// OffsetID + 17,
+// "Curium247", "Curium", "Curium-247",
+// NuclearTextures.UNSTABLE4, 107, 6, 105,
+// 247
+// );
+//
+// public static final IsotopeMaterial Berkelium247 = new IsotopeMaterial(
+// OffsetID + 18,
+// "Berkelium247", "Berkelium", "Berkelium-247",
+// NuclearTextures.STABLE2, 130, 54, 29,
+// 247
+// );
+//
+// public static final IsotopeMaterial Berkelium248 = new IsotopeMaterial(
+// OffsetID + 19,
+// "Berkelium248", "Berkelium", "Berkelium-248",
+// NuclearTextures.UNSTABLE1, 130, 54, 29,
+// 248
+// );
+//
+// public static final IsotopeMaterial Californium249 = new IsotopeMaterial(
+// OffsetID + 20,
+// "Californium249", "Californium", "Californium-249",
+// NuclearTextures.UNSTABLE2, 186, 55, 11,
+// 249
+// );
+//
+// public static final IsotopeMaterial Californium250 = new IsotopeMaterial(
+// OffsetID + 21,
+// "Californium250", "Californium", "Californium-250",
+// NuclearTextures.STABLE1, 186, 55, 11,
+// 250
+// );
+//
+// public static final IsotopeMaterial Californium251 = new IsotopeMaterial(
+// OffsetID + 22,
+// "Californium251", "Californium", "Californium-251",
+// NuclearTextures.UNSTABLE4, 186, 55, 11,
+// 251
+// );
+//
+// public static final IsotopeMaterial Californium252 = new IsotopeMaterial(
+// OffsetID + 23,
+// "Californium252", "Californium", "Californium-252",
+// NuclearTextures.UNSTABLE1, 186, 55, 11,
+// 252
+// );
+//
+// @Override
+// public void run() { }
+// }
diff --git a/goodgen/src/main/java/goodgenerator/items/nuclear/NuclearMetaItemGenerator.java b/goodgen/src/main/java/goodgenerator/items/nuclear/NuclearMetaItemGenerator.java
new file mode 100644
index 0000000000..a0b71b52e5
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/nuclear/NuclearMetaItemGenerator.java
@@ -0,0 +1,110 @@
+// package goodgenerator.items.nuclear;
+//
+// import com.github.bartimaeusnek.bartworks.util.Pair;
+// import cpw.mods.fml.relauncher.Side;
+// import cpw.mods.fml.relauncher.SideOnly;
+// import goodgenerator.main.GoodGenerator;
+// import gregtech.api.interfaces.IIconContainer;
+// import gregtech.api.items.GT_MetaGenerated_Item;
+// import gregtech.api.util.GT_LanguageManager;
+// import gregtech.api.util.GT_OreDictUnificator;
+// import net.minecraft.creativetab.CreativeTabs;
+// import net.minecraft.item.Item;
+// import net.minecraft.item.ItemStack;
+// import net.minecraft.util.EnumChatFormatting;
+// import net.minecraft.util.IIcon;
+//
+// import java.util.List;
+//
+// import static goodgenerator.items.nuclear.IsotopeMaterial.mIDMap;
+// import static goodgenerator.items.nuclear.IsotopeMaterial.mIsotopeMaterial;
+//
+// public class NuclearMetaItemGenerator extends GT_MetaGenerated_Item {
+//
+// /**
+// * <p>Full ingot - 1000
+// * <p>Tiny ingot - 2000
+// * <p>Full-Oxide - 3000
+// * <p>Tiny-Oxide - 4000
+// */
+// public static final Pair<Integer, String>[] TYPE_OFFSET = new Pair[] {
+// new Pair<>(1000, "%s"),
+// new Pair<>(2000, "Tiny of %s"),
+// new Pair<>(3000, "%s Oxide"),
+// new Pair<>(4000, "Tiny of %s Oxide"),
+// };
+// public static final Pair<Integer, String>[] OREPREFIX = new Pair[] {
+// new Pair<>(1000, "item%s"),
+// new Pair<>(2000, "itemTiny%s"),
+// new Pair<>(3000, "item%sOxide"),
+// new Pair<>(4000, "itemTiny%sOxide"),
+// };
+//
+// public NuclearMetaItemGenerator() {
+// super("nuclearIsotopeMaterial", (short) 32766, (short) 0);
+// this.setCreativeTab(GoodGenerator.GG);
+// for (IsotopeMaterial tIsotope : mIsotopeMaterial) {
+// for (Pair<Integer, String> tType : TYPE_OFFSET) {
+// int tOffset = tType.getKey();
+// String tOreName = tType.getValue();
+// ItemStack tStack = new ItemStack(this, 1, tIsotope.mID + tOffset);
+// GT_LanguageManager.addStringLocalization(this.getUnlocalizedName(tStack) + ".name",
+// String.format(tOreName, tIsotope.mLocalizedName));
+// GT_LanguageManager.addStringLocalization(this.getUnlocalizedName(tStack) + ".tooltip",
+// EnumChatFormatting.AQUA + String.format("%s's Isotope.", tIsotope.mMaterialName) + EnumChatFormatting.RESET);
+// }
+// for (Pair<Integer, String> tOreDict : OREPREFIX) {
+// int tOffset = tOreDict.getKey();
+// String tOreName = tOreDict.getValue();
+// ItemStack tStack = new ItemStack(this, 1, tIsotope.mID + tOffset);
+// GT_OreDictUnificator.registerOre(String.format(tOreName, tIsotope.mName), tStack);
+// }
+// }
+// }
+//
+// @Override
+// public String getItemStackDisplayName(ItemStack aStack) {
+// return GT_LanguageManager.getTranslation(this.getUnlocalizedName(aStack) + ".name");
+// }
+//
+// @Override
+// public IIconContainer getIconContainer(int aMetaData) {
+// int tID = aMetaData % 1000;
+// int tType = aMetaData / 1000 - 1;
+// IsotopeMaterial tMaterial = mIDMap.get(tID);
+// if (tMaterial != null) {
+// return tMaterial.mTexture.mTextures[tType];
+// }
+// return null;
+// }
+//
+// @Override
+// @SideOnly(Side.CLIENT)
+// public void getSubItems(Item var1, CreativeTabs aCreativeTab, List aList) {
+// for (IsotopeMaterial tIsotope : mIsotopeMaterial) {
+// for (int i = 1; i <= 4; i ++) {
+// ItemStack tStack = new ItemStack(this, 1, tIsotope.mID + i * 1000);
+// aList.add(tStack);
+// }
+// }
+// }
+//
+// @Override
+// public short[] getRGBa(ItemStack aStack) {
+// int tID = aStack.getItemDamage() % 1000;
+// int tType = aStack.getItemDamage() / 1000;
+// IsotopeMaterial tMaterial = mIDMap.get(tID);
+// if (tMaterial != null) {
+// if (tType == 1 || tType == 2)
+// return tMaterial.mRGB;
+// else
+// return tMaterial.mRGBO;
+// }
+// return null;
+// }
+//
+// @Override
+// public final IIcon getIconFromDamage(int aMetaData) {
+// return this.getIconContainer(aMetaData).getIcon();
+// }
+// }
diff --git a/goodgen/src/main/java/goodgenerator/items/nuclear/NuclearTextures.java b/goodgen/src/main/java/goodgenerator/items/nuclear/NuclearTextures.java
new file mode 100644
index 0000000000..63314044cf
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/items/nuclear/NuclearTextures.java
@@ -0,0 +1,31 @@
+// package goodgenerator.items.nuclear;
+//
+// import gregtech.api.enums.Textures;
+// import gregtech.api.interfaces.IIconContainer;
+//
+// public class NuclearTextures {
+// public static final NuclearTextures
+// STABLE1 = new NuclearTextures("stable1"),
+// STABLE2 = new NuclearTextures("stable2"),
+// UNSTABLE1 = new NuclearTextures("unstable1"),
+// UNSTABLE2 = new NuclearTextures("unstable2"),
+// UNSTABLE3 = new NuclearTextures("unstable3"),
+// UNSTABLE4 = new NuclearTextures("unstable4");
+//
+// public final IIconContainer[] mTextures = new IIconContainer[4];
+// public final String mSetName;
+// public static final String mTextureDir = "icons/isotope/";
+// public static final int
+// FULL = 0,
+// TINY = 1,
+// FULL_OXIDE = 2,
+// TINY_OXIDE = 3;
+//
+// public NuclearTextures(String aName) {
+// mSetName = aName;
+// mTextures[0] = new Textures.ItemIcons.CustomIcon(mTextureDir + aName);
+// mTextures[1] = new Textures.ItemIcons.CustomIcon(mTextureDir + aName + "tiny");
+// mTextures[2] = new Textures.ItemIcons.CustomIcon(mTextureDir + aName);
+// mTextures[3] = new Textures.ItemIcons.CustomIcon(mTextureDir + aName + "tiny");
+// }
+// }
diff --git a/goodgen/src/main/java/goodgenerator/loader/AchievementLoader.java b/goodgen/src/main/java/goodgenerator/loader/AchievementLoader.java
new file mode 100644
index 0000000000..2df30c8752
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/AchievementLoader.java
@@ -0,0 +1,4 @@
+package goodgenerator.loader;
+
+public class AchievementLoader {
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java
new file mode 100644
index 0000000000..f83712c7db
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java
@@ -0,0 +1,503 @@
+package goodgenerator.loader;
+
+import static goodgenerator.util.ItemRefer.Compassline_Casing_EV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_HV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_IV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_LV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_LuV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_MV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_UEV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_UHV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_UIV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_UMV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_UV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_UXV;
+import static goodgenerator.util.ItemRefer.Compassline_Casing_ZPM;
+import static goodgenerator.util.ItemRefer.Component_Assembly_Line;
+import static goodgenerator.util.Log.LOGGER;
+import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.HOURS;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+import static gregtech.api.util.GT_RecipeConstants.AssemblyLine;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME;
+
+import java.util.HashMap;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.apache.logging.log4j.Level;
+
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+import com.github.technus.tectech.recipe.TT_recipeAdder;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import goodgenerator.items.MyMaterial;
+import goodgenerator.util.StackUtils;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.recipe.common.CI;
+
+public class ComponentAssemblyLineMiscRecipes {
+
+    public static final String[] circuitTierMaterials = { "Primitive", "Basic", "Good", "Advanced", "Data", "Elite",
+        "Master", "Ultimate", "Superconductor", "Infinite", "Bio", "Optical", "Piko", "Quantum" };
+
+    static final HashMap<String, Integer> NameToTier = new HashMap<>();
+
+    static void run() {
+        for (int i = 0; i < circuitTierMaterials.length; i++) NameToTier.put(circuitTierMaterials[i], i);
+        // Cry about it
+        NameToTier.put("Nano", 11);
+
+        generateCasingRecipes();
+        generateWrapRecipes();
+        // Try and find the ZPM Fluid solidifier
+        ItemStack solidifier;
+        try {
+            Class<?> c = Class.forName("com.dreammaster.gthandler.CustomItemList");
+            Object maybeSolidifier = c.getMethod("valueOf", String.class)
+                .invoke(null, "FluidSolidifierZPM");
+            solidifier = (ItemStack) (c.getMethod("get", long.class, Object[].class)
+                .invoke(maybeSolidifier, 16L, null));
+            if (GT_Utility.isStackValid(solidifier)) LOGGER.log(Level.INFO, "ZPM Fluid Solidifier found.");
+            else throw new NullPointerException();
+        } catch (Exception e) {
+            LOGGER.log(Level.ERROR, "ZPM Fluid Solidifier not found, falling back to IV.", e);
+            solidifier = ItemList.Machine_IV_FluidSolidifier.get(16);
+        }
+
+        // The controller itself
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Compassline_Casing_EV.get(1))
+            .metadata(RESEARCH_TIME, 1 * HOURS)
+            .itemInputs(
+                ItemList.Machine_Multi_Assemblyline.get(16L),
+                ItemList.Casing_Assembler.get(16L),
+                ItemList.Casing_Gearbox_TungstenSteel.get(32L),
+                ComponentType.Robot_Arm.getComponent(8)
+                    .get(16),
+                ComponentType.Conveyor_Module.getComponent(8)
+                    .get(32),
+                ComponentType.Electric_Motor.getComponent(7)
+                    .get(32),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Polybenzimidazole, 16),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 32),
+                solidifier,
+                getALCircuit(8, 16),
+                getALCircuit(7, 20),
+                getALCircuit(6, 24))
+            .fluidInputs(
+                new FluidStack(FluidRegistry.getFluid("molten.indalloy140"), 144 * 12),
+                Materials.Naquadria.getMolten(144 * 16),
+                Materials.Lubricant.getFluid(5000))
+            .itemOutputs(Component_Assembly_Line.get(1))
+            .eut(TierEU.RECIPE_UHV / 2)
+            .duration(30 * SECONDS)
+            .addTo(AssemblyLine);
+    }
+
+    /** Recipes for the Component Assembly Line Casings */
+    private static void generateCasingRecipes() {
+        int t = 1;
+        // lv 1
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Steel, 4),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(4),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(10),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Steel, 4),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tin, 6),
+                getCircuit(t, 16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1)))
+            .itemOutputs(Compassline_Casing_LV.get(1))
+            .duration(16 * SECONDS)
+            .eut(GT_Values.VP[t])
+            .addTo(assemblerRecipes);
+        // mv 2
+        t++;
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Aluminium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Aluminium, 4),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(4),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(10),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Aluminium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.AnyCopper, 6),
+                getCircuit(t, 8),
+                getCircuit(t - 1, 16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1)))
+            .itemOutputs(Compassline_Casing_MV.get(1))
+            .duration(16 * SECONDS)
+            .eut(GT_Values.VP[t])
+            .addTo(assemblerRecipes);
+        // hv 3
+        t++;
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StainlessSteel, 4),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(4),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(10),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.StainlessSteel, 4),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Gold, 6),
+                getCircuit(t, 8),
+                getCircuit(t - 1, 16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1)))
+            .itemOutputs(Compassline_Casing_HV.get(1))
+            .duration(16 * SECONDS)
+            .eut(GT_Values.VP[t])
+            .addTo(assemblerRecipes);
+        // ev 4
+        t++;
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Titanium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 4),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(4),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(10),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Aluminium, 6),
+                getCircuit(t, 8),
+                getCircuit(t - 1, 16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1)))
+            .itemOutputs(Compassline_Casing_EV.get(1))
+            .duration(16 * SECONDS)
+            .eut(GT_Values.VP[t])
+            .addTo(assemblerRecipes);
+        // iv 5
+        t++;
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.TungstenSteel, 4),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(4),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(10),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.TungstenSteel, 4),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tungsten, 6),
+                getCircuit(t, 8),
+                getCircuit(t - 1, 16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1)))
+            .itemOutputs(Compassline_Casing_IV.get(1))
+            .duration(16 * SECONDS)
+            .eut(GT_Values.VP[t])
+            .addTo(assemblerRecipes);
+
+        Fluid sold = FluidRegistry.getFluid("molten.indalloy140");
+        // Assline Recipes!
+        // luv 6
+        t++;
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Compassline_Casing_IV.get(1))
+            .metadata(RESEARCH_TIME, (2250 << t) * TICKS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Europium, 1),
+                WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.plateDense, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGt, 4),
+                WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGtSmall, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.VanadiumGallium, 8),
+                getALCircuit(t, 8),
+                getALCircuit(t - 1, 16))
+            .fluidInputs(
+                new FluidStack(sold, 144 * t * 4),
+                CI.getTieredFluid(t, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t),
+                Materials.Lubricant.getFluid(1000 * (t - 2)))
+            .itemOutputs(Compassline_Casing_LuV.get(1))
+            .eut(TierEU.RECIPE_IV)
+            .duration(30 * SECONDS)
+            .addTo(AssemblyLine);
+        // zpm 7
+        t++;
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Compassline_Casing_LuV.get(1))
+            .metadata(RESEARCH_TIME, (2250 << t) * TICKS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Iridium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Iridium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Iridium, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Naquadah, 8),
+                getALCircuit(t, 8),
+                getALCircuit(t - 1, 16))
+            .fluidInputs(
+                new FluidStack(sold, 144 * t * 4),
+                CI.getTieredFluid(t, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t),
+                Materials.Lubricant.getFluid(1000 * (t - 2)))
+            .itemOutputs(Compassline_Casing_ZPM.get(1))
+            .eut(TierEU.RECIPE_LuV)
+            .duration(30 * SECONDS)
+            .addTo(AssemblyLine);
+        // uv 8
+        t++;
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Compassline_Casing_ZPM.get(1))
+            .metadata(RESEARCH_TIME, (2250 << t) * TICKS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmium, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Osmium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Osmium, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NaquadahAlloy, 8),
+                getALCircuit(t, 8),
+                getALCircuit(t - 1, 16))
+            .fluidInputs(
+                new FluidStack(sold, 144 * t * 4),
+                CI.getTieredFluid(t, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t),
+                Materials.Lubricant.getFluid(1000 * (t - 2)))
+            .itemOutputs(Compassline_Casing_UV.get(1))
+            .eut(TierEU.RECIPE_ZPM)
+            .duration(30 * SECONDS)
+            .addTo(AssemblyLine);
+        // uhv 9
+        t++;
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            Compassline_Casing_UV.get(1),
+            375 << (t - 2),
+            1 << (t - 3),
+            (int) TierEU.RECIPE_UV,
+            1,
+            new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.CosmicNeutronium, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.CosmicNeutronium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.CosmicNeutronium, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Bedrockium, 8), getALCircuit(t, 8),
+                getALCircuit(t - 1, 16) },
+            new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) },
+            Compassline_Casing_UHV.get(1),
+            50 * SECONDS,
+            (int) TierEU.RECIPE_UV);
+        sold = FluidRegistry.getFluid("molten.mutatedlivingsolder");
+        // uev 10
+        t++;
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            Compassline_Casing_UHV.get(1),
+            375 << (t - 2),
+            1 << (t - 3),
+            (int) TierEU.RECIPE_UHV,
+            1,
+            new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Infinity, 4),
+                GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Infinity, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Draconium, 8), getALCircuit(t, 8),
+                getALCircuit(t - 1, 16) },
+            new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) },
+            Compassline_Casing_UEV.get(1),
+            50 * SECONDS,
+            (int) TierEU.RECIPE_UHV);
+        // uiv 11
+        t++;
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            Compassline_Casing_UEV.get(1),
+            375 << (t - 2),
+            1 << (t - 3),
+            (int) TierEU.RECIPE_UEV,
+            1,
+            new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, MaterialsUEVplus.TranscendentMetal, 4),
+                GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, MaterialsUEVplus.TranscendentMetal, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NetherStar, 8), getALCircuit(t, 8),
+                getALCircuit(t - 1, 16) },
+            new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) },
+            Compassline_Casing_UIV.get(1),
+            50 * SECONDS,
+            (int) TierEU.RECIPE_UEV);
+        // umv 12
+        t++;
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            Compassline_Casing_UIV.get(1),
+            375 << (t - 2),
+            1 << (t - 3),
+            (int) TierEU.RECIPE_UIV,
+            1,
+            new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6),
+                ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, MaterialsUEVplus.SpaceTime, 4),
+                GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, MaterialsUEVplus.SpaceTime, 16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Quantium, 8), getALCircuit(t, 8),
+                getALCircuit(t - 1, 16) },
+            new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t - 1, 144 * t * 2),
+                StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) },
+            Compassline_Casing_UMV.get(1),
+            50 * 20,
+            (int) TierEU.RECIPE_UIV);
+        // uxv 13
+        t++;
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            Compassline_Casing_UMV.get(1),
+            375 << (t - 2),
+            1 << (t - 3),
+            (int) TierEU.RECIPE_UMV,
+            1,
+            new Object[] {
+                GT_OreDictUnificator
+                    .get(OrePrefixes.frameGt, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 1),
+                GT_OreDictUnificator
+                    .get(OrePrefixes.plateDense, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 3),
+                MyMaterial.shirabon.get(OrePrefixes.plateDense, 3), ComponentType.Robot_Arm.getComponent(t)
+                    .get(8),
+                ComponentType.Electric_Piston.getComponent(t)
+                    .get(10),
+                ComponentType.Electric_Motor.getComponent(t)
+                    .get(16),
+                GT_OreDictUnificator
+                    .get(OrePrefixes.gearGt, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 2),
+                MyMaterial.shirabon.get(OrePrefixes.gearGt, 2),
+                GT_OreDictUnificator
+                    .get(OrePrefixes.gearGtSmall, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 8),
+                MyMaterial.shirabon.get(OrePrefixes.gearGtSmall, 8),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Infinity, 4),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, MaterialsUEVplus.SpaceTime, 4), getALCircuit(t, 8),
+                getALCircuit(t - 1, 16) },
+            new FluidStack[] { new FluidStack(sold, 144 * t * 4),
+                MaterialsUEVplus.BlackDwarfMatter.getMolten(144 * t * 2), MaterialsUEVplus.Eternity.getMolten(144 * t),
+                Materials.Lubricant.getFluid(1000 * (t - 2)) },
+            Compassline_Casing_UXV.get(1),
+            50 * SECONDS,
+            (int) TierEU.RECIPE_UMV);
+    }
+
+    private static void generateWrapRecipes() {
+        for (int i = 0; i <= 11; i++) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(getCircuit(i, 16), GT_Utility.getIntegratedCircuit(16))
+                .fluidInputs(Materials.SolderingAlloy.getMolten(72L))
+                .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, i))
+                .duration(30 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(assemblerRecipes);
+        }
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GameRegistry.findItemStack("dreamcraft", "item.PikoCircuit", 16),
+                GT_Utility.getIntegratedCircuit(16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(72L))
+            .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, 12))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(assemblerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GameRegistry.findItemStack("dreamcraft", "item.QuantumCircuit", 16),
+                GT_Utility.getIntegratedCircuit(16))
+            .fluidInputs(Materials.SolderingAlloy.getMolten(72L))
+            .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, 13))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(assemblerRecipes);
+    }
+
+    @SuppressWarnings("unused")
+    private enum ComponentType {
+
+        Electric_Motor,
+        Electric_Piston,
+        Robot_Arm,
+        Electric_Pump,
+        Field_Generator,
+        Conveyor_Module,
+        Emitter,
+        Sensor;
+
+        public ItemList getComponent(int tier) {
+            if (tier < 0 || tier > GT_Values.VN.length) throw new IllegalArgumentException("Tier is out of range!");
+            return ItemList.valueOf(this.name() + "_" + GT_Values.VN[tier]);
+        }
+    }
+
+    private static ItemStack getCircuit(int tier, long amount) {
+        return GT_OreDictUnificator.get(OrePrefixes.circuit, getCircuitMaterial(tier), amount);
+    }
+
+    private static Object[] getALCircuit(int tier, int amount) {
+        return new Object[] { OrePrefixes.circuit.get(getCircuitMaterial(tier)), amount };
+    }
+
+    @Nullable
+    public static Materials getCircuitMaterial(int tier) {
+        return Materials.getRealMaterial(circuitTierMaterials[tier]);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java
new file mode 100644
index 0000000000..f1b16089d9
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java
@@ -0,0 +1,484 @@
+package goodgenerator.loader;
+
+import static goodgenerator.util.StackUtils.getTotalItems;
+import static goodgenerator.util.StackUtils.mergeStacks;
+import static goodgenerator.util.StackUtils.multiplyAndSplitIntoStacks;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.objects.ItemData;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.GT_IntegratedCircuit_Item;
+
+public class ComponentAssemblyLineRecipeLoader {
+
+    private static final String[] compPrefixes = { "Electric_Motor_", "Electric_Piston_", "Electric_Pump_",
+        "Robot_Arm_", "Conveyor_Module_", "Emitter_", "Sensor_", "Field_Generator_", };
+    private static final String[] blacklistedDictPrefixes = { "circuit" };
+    private static final String[] softBlacklistedDictPrefixes = { "Any", "crafting", "nanite" };
+    private static final String moltenMHDCSM = "molten.magnetohydrodynamicallyconstrainedstarmatter";
+
+    private static LinkedHashMap<List<GT_Recipe>, Pair<ItemList, Integer>> allAssemblerRecipes;
+    private static LinkedHashMap<List<GT_Recipe.GT_Recipe_AssemblyLine>, Pair<ItemList, Integer>> allAsslineRecipes;
+
+    private static final HashMap<OrePrefixes, Double> magnetoConversionMultipliers = new HashMap<>();
+    private static final HashMap<OrePrefixes, OrePrefixes> conversion = new HashMap<>();
+
+    private static final int INPUT_MULTIPLIER = 48;
+    private static final int OUTPUT_MULTIPLIER = 64;
+    private static final int FLUID_CONVERSION_STACKSIZE_THRESHOLD = 64;
+
+    public static void run() {
+        ComponentAssemblyLineMiscRecipes.run();
+        conversion.put(OrePrefixes.cableGt01, OrePrefixes.cableGt16);
+        conversion.put(OrePrefixes.wireGt01, OrePrefixes.wireGt16);
+        conversion.put(OrePrefixes.cableGt02, OrePrefixes.cableGt16);
+        conversion.put(OrePrefixes.wireGt02, OrePrefixes.wireGt16);
+        conversion.put(OrePrefixes.cableGt04, OrePrefixes.cableGt16);
+        conversion.put(OrePrefixes.wireGt04, OrePrefixes.wireGt16);
+        conversion.put(OrePrefixes.cableGt08, OrePrefixes.cableGt16);
+        conversion.put(OrePrefixes.wireGt08, OrePrefixes.wireGt16);
+        conversion.put(OrePrefixes.plate, OrePrefixes.plateDense);
+        conversion.put(OrePrefixes.foil, OrePrefixes.plate);
+        conversion.put(OrePrefixes.stick, OrePrefixes.stickLong);
+        conversion.put(OrePrefixes.gearGtSmall, OrePrefixes.gearGt);
+        magnetoConversionMultipliers.put(OrePrefixes.frameGt, 1.0);
+        magnetoConversionMultipliers.put(OrePrefixes.plate, 1.0);
+        magnetoConversionMultipliers.put(OrePrefixes.plateDense, 3.0);
+        magnetoConversionMultipliers.put(OrePrefixes.stick, 1.0 / 2.0);
+        magnetoConversionMultipliers.put(OrePrefixes.round, 1.0 / 8.0);
+        magnetoConversionMultipliers.put(OrePrefixes.bolt, 1.0 / 8.0);
+        magnetoConversionMultipliers.put(OrePrefixes.screw, 1.0 / 8.0);
+        magnetoConversionMultipliers.put(OrePrefixes.ring, 1.0 / 4.0);
+        magnetoConversionMultipliers.put(OrePrefixes.foil, 1.0 / 8.0);
+        magnetoConversionMultipliers.put(OrePrefixes.gearGtSmall, 1.0);
+        magnetoConversionMultipliers.put(OrePrefixes.rotor, 2.0);
+        magnetoConversionMultipliers.put(OrePrefixes.stickLong, 1.0);
+        magnetoConversionMultipliers.put(OrePrefixes.gearGt, 2.0);
+        magnetoConversionMultipliers.put(OrePrefixes.wireFine, 1.0 / 8.0);
+        findAllRecipes();
+        generateAssemblerRecipes();
+        generateAsslineRecipes();
+    }
+
+    /** Normal assembler recipes (LV-IV) */
+    private static void generateAssemblerRecipes() {
+        allAssemblerRecipes.forEach((recipeList, info) -> {
+            for (GT_Recipe recipe : recipeList) {
+                if (recipe != null) {
+                    ArrayList<ItemStack> fixedInputs = new ArrayList<>();
+                    ArrayList<FluidStack> fixedFluids = new ArrayList<>();
+
+                    for (int j = 0; j < recipe.mInputs.length; j++) {
+                        ItemStack input = recipe.mInputs[j];
+                        if (GT_Utility.isStackValid(input) && !(input.getItem() instanceof GT_IntegratedCircuit_Item))
+                            fixedInputs.addAll(multiplyAndSplitIntoStacks(input, INPUT_MULTIPLIER));
+                    }
+                    for (int j = 0; j < recipe.mFluidInputs.length; j++) {
+                        FluidStack currFluid = recipe.mFluidInputs[j].copy();
+                        currFluid.amount = currFluid.amount * INPUT_MULTIPLIER;
+                        fixedFluids.add(currFluid);
+                    }
+
+                    fixedInputs = compactItems(fixedInputs, info.getRight());
+                    replaceIntoFluids(fixedInputs, fixedFluids, 64);
+                    int tier = info.getRight();
+                    int energy = (int) Math.min(Integer.MAX_VALUE - 7, GT_Values.VP[tier - 1]);
+                    MyRecipeAdder.instance.addComponentAssemblyLineRecipe(
+                        fixedInputs.toArray(new ItemStack[0]),
+                        fixedFluids.toArray(new FluidStack[0]),
+                        info.getLeft()
+                            .get(OUTPUT_MULTIPLIER),
+                        recipe.mDuration * INPUT_MULTIPLIER,
+                        energy,
+                        info.getRight());
+                }
+            }
+        });
+    }
+
+    /** Assembly Line Recipes (LuV+) **/
+    private static void generateAsslineRecipes() {
+        allAsslineRecipes.forEach((recipeList, info) -> {
+            for (GT_Recipe.GT_Recipe_AssemblyLine recipe : recipeList) {
+                if (recipe != null) {
+                    int componentCircuit = -1;
+                    for (int i = 0; i < compPrefixes.length; i++) if (info.getLeft()
+                        .toString()
+                        .startsWith(compPrefixes[i])) componentCircuit = i + 1;
+                    if (componentCircuit == -1) {
+                        throw new NullPointerException(
+                            "Wrong circuit. Comp: " + info.getLeft()
+                                .toString());
+                    }
+                    final boolean addProgrammedCircuit = componentCircuit <= 7;
+                    // Arrays of the item and fluid inputs, that are updated to be multiplied and/or condensed in the
+                    // following code
+                    ArrayList<ItemStack> fixedInputs = new ArrayList<>();
+                    ArrayList<FluidStack> fixedFluids = new ArrayList<>();
+
+                    // Multiplies the original fluid inputs
+                    for (int j = 0; j < recipe.mFluidInputs.length; j++) {
+                        FluidStack currFluid = recipe.mFluidInputs[j].copy();
+                        currFluid.amount *= (double) INPUT_MULTIPLIER;
+                        fixedFluids.add(currFluid);
+                    }
+
+                    // First pass.
+                    for (ItemStack input : recipe.mInputs) {
+                        if (GT_Utility.isStackValid(input)) {
+                            int count = input.stackSize;
+                            // Mulitplies the input by its multiplier, and adjusts the stacks accordingly
+                            if (!(input.getItem() instanceof GT_IntegratedCircuit_Item)) {
+
+                                ItemData data = GT_OreDictUnificator.getAssociation(input);
+                                // trying to fix some circuit oredicting issues
+
+                                if (data != null && data.mPrefix == OrePrefixes.circuit) fixedInputs.addAll(
+                                    multiplyAndSplitIntoStacks(
+                                        GT_OreDictUnificator.get(data.mPrefix, data.mMaterial.mMaterial, count),
+                                        INPUT_MULTIPLIER));
+                                else fixedInputs.addAll(multiplyAndSplitIntoStacks(input, INPUT_MULTIPLIER));
+                            }
+                        }
+                    }
+                    fixedInputs = compactItems(fixedInputs, info.getRight());
+                    replaceIntoFluids(fixedInputs, fixedFluids, FLUID_CONVERSION_STACKSIZE_THRESHOLD);
+                    // If it overflows then it tries REALLY HARD to cram as much stuff into there.
+                    if (fixedInputs.size() > (addProgrammedCircuit ? 8 : 9))
+                        replaceIntoFluids(fixedInputs, fixedFluids, FLUID_CONVERSION_STACKSIZE_THRESHOLD / 2);
+                    if (addProgrammedCircuit) fixedInputs.add(GT_Utility.getIntegratedCircuit(componentCircuit));
+
+                    addEternityForMHDCSM(fixedFluids);
+                    MyRecipeAdder.instance.addComponentAssemblyLineRecipe(
+                        fixedInputs.toArray(new ItemStack[0]),
+                        fixedFluids.toArray(new FluidStack[0]),
+                        info.getLeft()
+                            .get(OUTPUT_MULTIPLIER), // The component output
+                        recipe.mDuration * INPUT_MULTIPLIER, // Takes as long as this many
+                        recipe.mEUt,
+                        info.getRight()); // Casing tier
+
+                    // Add a second recipe using Styrene-Butadiene
+                    // Rubber instead of Silicone Rubber.
+                    // This relies on silicone rubber being first in
+                    // @allSyntheticRubber so it's quite fragile, but
+                    // it's also the least invasive change.
+                    if (swapSiliconeForStyreneButadiene(fixedFluids)) {
+                        MyRecipeAdder.instance.addComponentAssemblyLineRecipe(
+                            fixedInputs.toArray(new ItemStack[0]),
+                            fixedFluids.toArray(new FluidStack[0]),
+                            info.getLeft()
+                                .get(OUTPUT_MULTIPLIER), // The component output
+                            recipe.mDuration * INPUT_MULTIPLIER, // Takes as long as this many
+                            recipe.mEUt,
+                            info.getRight()); // Casing tier
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * Looks for a matching FluidStack and merges the amount of the converted fluid with the one it found. Otherwise, it
+     * will add the converted to the fluid inputs.
+     */
+    private static void replaceIntoFluids(List<ItemStack> inputs, List<FluidStack> fluidOutputs, int threshold) {
+        HashMap<ItemStack, Integer> totals = getTotalItems(inputs.toArray(new ItemStack[0]));
+        ArrayList<ItemStack> newInputs = new ArrayList<>();
+        for (ItemStack input : totals.keySet()) {
+            int count = totals.get(input);
+            boolean isConverted = false;
+            if (OreDictionary.getOreIDs(input).length > 0 && count > threshold) {
+                FluidStack foundFluidStack = tryConvertItemStackToFluidMaterial(input);
+
+                ItemData data = GT_OreDictUnificator.getAssociation(input);
+
+                // Prevents the uncraftable molten magnetic samarium from being converted into fluid during auto
+                // generation
+                if (data != null && data.mMaterial.mMaterial == Materials.SamariumMagnetic) {
+                    input = GT_OreDictUnificator.get(data.mPrefix, Materials.Samarium, 1);
+                    foundFluidStack = tryConvertItemStackToFluidMaterial(input);
+                } else if (data != null && data.mMaterial.mMaterial == Materials.TengamAttuned) {
+                    input = GT_OreDictUnificator.get(data.mPrefix, Materials.TengamPurified, 1);
+                    foundFluidStack = tryConvertItemStackToFluidMaterial(input);
+                }
+
+                if (foundFluidStack != null) {
+                    foundFluidStack.amount *= count;
+                    boolean alreadyHasFluid = false;
+                    for (FluidStack fluidstack : fluidOutputs) {
+                        if (foundFluidStack.getFluid()
+                            .equals(fluidstack.getFluid())) {
+                            fluidstack.amount += foundFluidStack.amount;
+                            alreadyHasFluid = true;
+                            break;
+                        }
+                    }
+                    if (!alreadyHasFluid) {
+                        fluidOutputs.add(foundFluidStack);
+                    }
+                    isConverted = true;
+                }
+            }
+            if (!isConverted) {
+                newInputs.add(GT_Utility.copyAmountUnsafe(count, input));
+            }
+        }
+        inputs.clear();
+        inputs.addAll(newInputs);
+    }
+
+    /**
+     * Tries to convert {@code input} into its molten form. Because the internal names for material fluids in GT5u,
+     * GT++, and BartWorks follow the same naming scheme, this method should work for any {@code ItemStack} from any of
+     * the 3 material systems.
+     */
+    @Nullable
+    private static FluidStack tryConvertItemStackToFluidMaterial(ItemStack input) {
+        ArrayList<String> oreDicts = new ArrayList<>();
+        for (int id : OreDictionary.getOreIDs(input)) {
+            oreDicts.add(OreDictionary.getOreName(id));
+        }
+        oreDictLoop: for (String dict : oreDicts) {
+            for (String blacklistedPrefix : blacklistedDictPrefixes) {
+                if (dict.startsWith(blacklistedPrefix)) {
+                    return null;
+                }
+            }
+            for (String blacklistedPrefix : softBlacklistedDictPrefixes) {
+                if (dict.startsWith(blacklistedPrefix)) {
+                    continue oreDictLoop;
+                }
+            }
+            OrePrefixes orePrefix;
+            try {
+                orePrefix = OrePrefixes.valueOf(findBestPrefix(dict));
+            } catch (Exception e) {
+                continue;
+            }
+
+            String strippedOreDict = dict.substring(
+                orePrefix.toString()
+                    .length());
+
+            // Prevents things like AnyCopper or AnyIron from messing the search up.
+            if (strippedOreDict.contains("Any")) continue;
+            if (strippedOreDict.contains("PTMEG")) return FluidRegistry.getFluidStack(
+                "molten.silicone",
+                (int) (orePrefix.mMaterialAmount / (GT_Values.M / 144)) * input.stackSize);
+            return FluidRegistry.getFluidStack(
+                "molten." + strippedOreDict.toLowerCase(),
+                (int) (orePrefix.mMaterialAmount / (GT_Values.M / 144)) * input.stackSize);
+        }
+        return null;
+    }
+
+    /**
+     * Gives the longest Ore Prefix that the OreDictionary string starts with. This makes it the most accurate prefix.
+     * For example: If your OreDictionary is something like {@code gearGtSmallSpaceTime}, a conventional search would
+     * return something like {@code gearGt} instead of {@code gearGtSmall}. This makes the longer String the most
+     * accurate.
+     *
+     * @param oreDict The Ore Dictionary entry
+     * @return The longest ore prefix that the OreDict string starts with. This makes it the most accurate prefix.
+     */
+    private static String findBestPrefix(String oreDict) {
+        int longestPrefixLength = 0;
+        String matchingPrefix = null;
+        for (OrePrefixes prefix : OrePrefixes.values()) {
+            String name = prefix.toString();
+            if (oreDict.startsWith(name)) {
+                if (name.length() > longestPrefixLength) {
+                    longestPrefixLength = name.length();
+                    matchingPrefix = name;
+                }
+            }
+        }
+        return matchingPrefix;
+    }
+
+    /**
+     * Transforms each {@code ItemStack}, if possible, into a more compact form. For example, a stack of 16 1x cables,
+     * when passed into the {@code items} array, will be converted into a single 16x cable. Also handles GraviStar and
+     * neutronium nanite conversion.
+     */
+    private static ArrayList<ItemStack> compactItems(List<ItemStack> items, int tier) {
+        ArrayList<ItemStack> stacks = new ArrayList<>();
+        HashMap<ItemStack, Integer> totals = getTotalItems(items);
+        for (ItemStack itemstack : totals.keySet()) {
+            int totalItems = totals.get(itemstack);
+            ItemData data = GT_OreDictUnificator.getAssociation(itemstack);
+            boolean isCompacted = false;
+
+            for (String dict : Arrays.stream(OreDictionary.getOreIDs(itemstack))
+                .mapToObj(OreDictionary::getOreName)
+                .collect(Collectors.toList())) {
+                if (dict.startsWith("circuit")) {
+                    stacks.addAll(getWrappedCircuits(itemstack, totalItems, dict));
+                    isCompacted = true;
+                    break;
+                }
+                if (dict.contains("Magneto")) {
+                    stacks.addAll(getMagnetoConversion(itemstack, totalItems));
+                    isCompacted = true;
+                    break;
+                }
+            }
+
+            if (data != null && !isCompacted) {
+                OrePrefixes goInto = conversion.get(data.mPrefix);
+                if (goInto != null && GT_OreDictUnificator.get(goInto, data.mMaterial.mMaterial, 1) != null) {
+                    compactorHelper(data, goInto, stacks, totalItems);
+                    isCompacted = true;
+                }
+            }
+            if (GT_Utility.areStacksEqual(itemstack, ItemList.Gravistar.get(1)) && tier >= 9) {
+                stacks.addAll(multiplyAndSplitIntoStacks(ItemList.NuclearStar.get(1), totalItems / 16));
+                isCompacted = true;
+            }
+            if (GT_Utility
+                .areStacksEqual(itemstack, GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Neutronium, 1))) {
+                stacks.addAll(
+                    multiplyAndSplitIntoStacks(
+                        GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Gold, 1),
+                        totalItems / 16));
+                isCompacted = true;
+            }
+            if (!isCompacted) stacks.addAll(multiplyAndSplitIntoStacks(itemstack, totalItems));
+        }
+        stacks = mergeStacks(stacks);
+        return stacks;
+    }
+
+    /** A helper method for compacting items */
+    private static void compactorHelper(ItemData data, OrePrefixes compactInto, ArrayList<ItemStack> output,
+        int total) {
+        int materialRatio = (int) ((double) compactInto.mMaterialAmount / data.mPrefix.mMaterialAmount);
+        output.addAll(
+            multiplyAndSplitIntoStacks(
+                GT_OreDictUnificator.get(compactInto, data.mMaterial.mMaterial, 1),
+                total / materialRatio));
+    }
+
+    /**
+     * Searches the Assembler and Assembly line registry for all the base component recipes.
+     */
+    private static void findAllRecipes() {
+        allAssemblerRecipes = new LinkedHashMap<>();
+        allAsslineRecipes = new LinkedHashMap<>();
+        for (String compPrefix : compPrefixes) {
+            for (int t = 1; t <= 13; t++) {
+                String vName = GT_Values.VN[t];
+                ItemList currentComponent = ItemList.valueOf(compPrefix + vName);
+                if (currentComponent.hasBeenSet()) {
+                    if (t < 6) {
+                        ArrayList<GT_Recipe> foundRecipes = new ArrayList<>();
+                        for (GT_Recipe recipe : RecipeMaps.assemblerRecipes.getAllRecipes()) {
+                            if (GT_Utility.areStacksEqual(currentComponent.get(1), recipe.mOutputs[0])) {
+                                foundRecipes.add(recipe);
+                            }
+                        }
+                        allAssemblerRecipes.put(foundRecipes, Pair.of(currentComponent, t));
+                    } else {
+                        ArrayList<GT_Recipe.GT_Recipe_AssemblyLine> foundRecipes = new ArrayList<>();
+                        for (GT_Recipe.GT_Recipe_AssemblyLine recipe : GT_Recipe.GT_Recipe_AssemblyLine.sAssemblylineRecipes) {
+                            if (GT_Utility.areStacksEqual(currentComponent.get(1), recipe.mOutput)) {
+                                foundRecipes.add(recipe);
+                            }
+                        }
+                        allAsslineRecipes.put(foundRecipes, Pair.of(currentComponent, t));
+                    }
+                }
+            }
+        }
+    }
+
+    private static List<ItemStack> getWrappedCircuits(ItemStack item, int total, String oreDict) {
+        ArrayList<ItemStack> stacks = new ArrayList<>();
+        String circuitMaterial = oreDict.substring(7);
+        int tier = ComponentAssemblyLineMiscRecipes.NameToTier.get(circuitMaterial);
+        if (total >= 16)
+            stacks.addAll(multiplyAndSplitIntoStacks(new ItemStack(Loaders.circuitWrap, 1, tier), total / 16));
+        else stacks.addAll(multiplyAndSplitIntoStacks(item, total));
+
+        return stacks;
+    }
+
+    private static List<ItemStack> getMagnetoConversion(ItemStack item, int total) {
+        ArrayList<ItemStack> stacks = new ArrayList<>();
+        ItemData data = GT_OreDictUnificator.getAssociation(item);
+        if (data == null) {
+            return stacks;
+        }
+        if (total >= FLUID_CONVERSION_STACKSIZE_THRESHOLD) {
+            double multiplier = magnetoConversionMultipliers.get(data.mPrefix);
+            stacks.addAll(
+                getWrappedCircuits(
+                    GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Infinite, 1),
+                    (int) (total * multiplier),
+                    "circuitInfinite"));
+        }
+        stacks.addAll(multiplyAndSplitIntoStacks(item, total));
+        return stacks;
+    }
+
+    private static void addEternityForMHDCSM(ArrayList<FluidStack> fluidInputs) {
+        boolean eternity = false;
+        boolean mhdcsm = false;
+        int mhdcsmAmount = 0;
+
+        for (FluidStack fluidstack : fluidInputs) {
+            if (fluidstack.getFluid()
+                .equals(FluidRegistry.getFluid(moltenMHDCSM))) {
+                mhdcsm = true;
+                mhdcsmAmount = fluidstack.amount;
+            }
+            if (fluidstack.getFluid()
+                .equals(FluidRegistry.getFluid("molten.eternity"))) {
+                eternity = true;
+            }
+        }
+
+        if (mhdcsm && !eternity) {
+            // 576 * 48 is substracted because uxv parts have 576L mhdcsm fluid (not solid, so no EIC conversion needed)
+            // in their assline recipes and each CoAl recipe has 48x recipe inputs
+            fluidInputs.add(MaterialsUEVplus.Eternity.getMolten(mhdcsmAmount - 576 * 48));
+        }
+    }
+
+    private static boolean swapSiliconeForStyreneButadiene(ArrayList<FluidStack> fluidInputs) {
+        for (int i = 0; i < fluidInputs.size(); i++) {
+            FluidStack fluidstack = fluidInputs.get(i);
+            if (fluidstack.getFluid()
+                .equals(FluidRegistry.getFluid("molten.silicone"))) {
+                fluidInputs.set(i, FluidRegistry.getFluidStack("molten.styrenebutadienerubber", fluidstack.amount));
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/FuelRecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/FuelRecipeLoader.java
new file mode 100644
index 0000000000..2a1981b201
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/FuelRecipeLoader.java
@@ -0,0 +1,168 @@
+package goodgenerator.loader;
+
+import static goodgenerator.main.GG_Config_Loader.NaquadahFuelTime;
+import static goodgenerator.main.GG_Config_Loader.NaquadahFuelVoltage;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+
+import goodgenerator.items.MyMaterial;
+import goodgenerator.util.ItemRefer;
+import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gtPlusPlus.core.material.ELEMENT;
+
+public class FuelRecipeLoader {
+
+    public static void RegisterFuel() {
+        // MyRecipeAdder.instance.addLiquidMentalFuel(Materials.NaquadahEnriched.getMolten(1L),Materials.Naquadah.getMolten(1L),32768,100);
+        // MyRecipeAdder.instance.addLiquidMentalFuel(Materials.Naquadria.getMolten(1L),Materials.Naquadah.getMolten(1L),262144,120);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(1),
+            MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[0],
+            NaquadahFuelTime[0]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.thoriumBasedLiquidFuelExcited.getFluidOrGas(1),
+            MyMaterial.thoriumBasedLiquidFuelDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[1],
+            NaquadahFuelTime[1]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(1),
+            MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[2],
+            NaquadahFuelTime[2]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(1),
+            MyMaterial.naquadahBasedFuelMkIDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[3],
+            NaquadahFuelTime[3]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.naquadahBasedFuelMkII.getFluidOrGas(1),
+            MyMaterial.naquadahBasedFuelMkIIDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[4],
+            NaquadahFuelTime[4]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(1),
+            MyMaterial.naquadahBasedFuelMkIIIDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[5],
+            NaquadahFuelTime[5]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(1),
+            MyMaterial.naquadahBasedFuelMkIVDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[6],
+            NaquadahFuelTime[6]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(1),
+            MyMaterial.naquadahBasedFuelMkVDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[7],
+            NaquadahFuelTime[7]);
+        MyRecipeAdder.instance.addLiquidMentalFuel(
+            MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(1),
+            MyMaterial.naquadahBasedFuelMkVIDepleted.getFluidOrGas(1),
+            NaquadahFuelVoltage[8],
+            NaquadahFuelTime[8]);
+        // MK III Naquadah Fuel
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.heavyNaquadahFuel.getFluidOrGas(800),
+                MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), },
+            new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 4),
+                WerkstoffLoader.Tiberium.get(OrePrefixes.dust, 27), ItemRefer.High_Density_Uranium.get(2),
+                ItemRefer.High_Density_Plutonium.get(1), },
+            MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(100),
+            1100000,
+            100,
+            1);
+
+        // Alternative higher tier recipe
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.heavyNaquadahFuel.getFluidOrGas(800),
+                MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), },
+            new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 8),
+                GT_ModHandler.getModItem("miscutils", "itemDustChromaticGlass", 9),
+                ItemRefer.High_Density_Uranium.get(2), ItemRefer.High_Density_Plutonium.get(1), },
+            MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(200),
+            2100000,
+            100,
+            1);
+        // MK IV Naquadah Fuel
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(2000),
+                Materials.Praseodymium.getMolten(9216L) },
+            new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 27),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NetherStar, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64),
+                MyMaterial.orundum.get(OrePrefixes.dust, 32), },
+            MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(250),
+            46000000,
+            160,
+            2);
+
+        // Alternate higher tier recipe
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(2000),
+                new FluidStack(FluidRegistry.getFluid("molten.hypogen"), 1440) },
+            new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 27),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64),
+                MyMaterial.orundum.get(OrePrefixes.dust, 64), },
+            MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(500),
+            75000000,
+            160,
+            2);
+
+        // MK V Naquadah Fuel
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(2000),
+                FluidRegistry.getFluidStack("heavyradox", 1000), },
+            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Infinity, 16),
+                MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.dust, 32), },
+            MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(500),
+            100000000,
+            200,
+            2);
+
+        // Alternate higher tier recipe
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(2000),
+                FluidRegistry.getFluidStack("heavyradox", 1000), },
+            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.SpaceTime, 8),
+                GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.TranscendentMetal, 16),
+                MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.dust, 48), },
+            MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(750),
+            300000000,
+            200,
+            3);
+
+        // MK VI Naquadah Fuel
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(2000),
+                FluidRegistry.getFluidStack("molten.shirabon", 1440), },
+            new ItemStack[] { ELEMENT.STANDALONE.ASTRAL_TITANIUM.getDust(64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 32), },
+            MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(500),
+            320000000,
+            240,
+            3);
+
+        // Alternate higher tier recipe
+        MyRecipeAdder.instance.addNaquadahFuelRefineRecipe(
+            new FluidStack[] { MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(2000),
+                FluidRegistry.getFluidStack("molten.shirabon", 1440), },
+            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.WhiteDwarfMatter, 8),
+                ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getDust(64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 48), },
+            MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(750),
+            530000000,
+            240,
+            4);
+
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/FuelRodLoader.java b/goodgen/src/main/java/goodgenerator/loader/FuelRodLoader.java
new file mode 100644
index 0000000000..9654479861
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/FuelRodLoader.java
@@ -0,0 +1,248 @@
+package goodgenerator.loader;
+
+import static goodgenerator.util.DescTextLocalization.addText;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import goodgenerator.items.DepletedFuelRod;
+import goodgenerator.items.FuelRod;
+import goodgenerator.main.GoodGenerator;
+
+public class FuelRodLoader {
+
+    public static Item rodCompressedUraniumDepleted;
+    public static Item rodCompressedUraniumDepleted_2;
+    public static Item rodCompressedUraniumDepleted_4;
+    public static Item rodCompressedPlutoniumDepleted;
+    public static Item rodCompressedPlutoniumDepleted_2;
+    public static Item rodCompressedPlutoniumDepleted_4;
+    public static Item rodLiquidUraniumDepleted;
+    public static Item rodLiquidUraniumDepleted_2;
+    public static Item rodLiquidUraniumDepleted_4;
+    public static Item rodLiquidPlutoniumDepleted;
+    public static Item rodLiquidPlutoniumDepleted_2;
+    public static Item rodLiquidPlutoniumDepleted_4;
+    public static Item rodCompressedUranium;
+    public static Item rodCompressedUranium_2;
+    public static Item rodCompressedUranium_4;
+    public static Item rodCompressedPlutonium;
+    public static Item rodCompressedPlutonium_2;
+    public static Item rodCompressedPlutonium_4;
+    public static Item rodLiquidUranium;
+    public static Item rodLiquidUranium_2;
+    public static Item rodLiquidUranium_4;
+    public static Item rodLiquidPlutonium;
+    public static Item rodLiquidPlutonium_2;
+    public static Item rodLiquidPlutonium_4;
+
+    public static void RegisterRod() {
+        rodCompressedUraniumDepleted = new DepletedFuelRod(
+            "rodCompressedUraniumDepleted",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            100);
+        rodCompressedUraniumDepleted_2 = new DepletedFuelRod(
+            "rodCompressedUraniumDepleted2",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            200);
+        rodCompressedUraniumDepleted_4 = new DepletedFuelRod(
+            "rodCompressedUraniumDepleted4",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            400);
+        rodCompressedPlutoniumDepleted = new DepletedFuelRod(
+            "rodCompressedPlutoniumDepleted",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            120);
+        rodCompressedPlutoniumDepleted_2 = new DepletedFuelRod(
+            "rodCompressedPlutoniumDepleted2",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            240);
+        rodCompressedPlutoniumDepleted_4 = new DepletedFuelRod(
+            "rodCompressedPlutoniumDepleted4",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            480);
+        rodLiquidUraniumDepleted = new DepletedFuelRod(
+            "rodLiquidUraniumDepleted",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            800);
+        rodLiquidUraniumDepleted_2 = new DepletedFuelRod(
+            "rodLiquidUraniumDepleted2",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            1600);
+        rodLiquidUraniumDepleted_4 = new DepletedFuelRod(
+            "rodLiquidUraniumDepleted4",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            3200);
+        rodLiquidPlutoniumDepleted = new DepletedFuelRod(
+            "rodLiquidPlutoniumDepleted",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            1000);
+        rodLiquidPlutoniumDepleted_2 = new DepletedFuelRod(
+            "rodLiquidPlutoniumDepleted2",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            2000);
+        rodLiquidPlutoniumDepleted_4 = new DepletedFuelRod(
+            "rodLiquidPlutoniumDepleted4",
+            addText("depletedfuelrod.tooltip", 1),
+            GoodGenerator.GG,
+            4000);
+
+        GameRegistry.registerItem(rodCompressedUraniumDepleted, "rodCompressedUraniumDepleted", GoodGenerator.MOD_ID);
+        GameRegistry
+            .registerItem(rodCompressedUraniumDepleted_2, "rodCompressedUraniumDepleted2", GoodGenerator.MOD_ID);
+        GameRegistry
+            .registerItem(rodCompressedUraniumDepleted_4, "rodCompressedUraniumDepleted4", GoodGenerator.MOD_ID);
+        GameRegistry
+            .registerItem(rodCompressedPlutoniumDepleted, "rodCompressedPlutoniumDepleted", GoodGenerator.MOD_ID);
+        GameRegistry
+            .registerItem(rodCompressedPlutoniumDepleted_2, "rodCompressedPlutoniumDepleted2", GoodGenerator.MOD_ID);
+        GameRegistry
+            .registerItem(rodCompressedPlutoniumDepleted_4, "rodCompressedPlutoniumDepleted4", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidUraniumDepleted, "rodLiquidUraniumDepleted", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidUraniumDepleted_2, "rodLiquidUraniumDepleted2", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidUraniumDepleted_4, "rodLiquidUraniumDepleted4", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidPlutoniumDepleted, "rodLiquidPlutoniumDepleted", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidPlutoniumDepleted_2, "rodLiquidPlutoniumDepleted2", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidPlutoniumDepleted_4, "rodLiquidPlutoniumDepleted4", GoodGenerator.MOD_ID);
+
+        rodCompressedUranium = new FuelRod(
+            "rodCompressedUranium",
+            1,
+            100,
+            4,
+            800,
+            70000,
+            new ItemStack(rodCompressedUraniumDepleted, 1),
+            GoodGenerator.GG);
+        rodCompressedUranium_2 = new FuelRod(
+            "rodCompressedUranium2",
+            2,
+            100,
+            4,
+            1600,
+            70000,
+            new ItemStack(rodCompressedUraniumDepleted_2, 1),
+            GoodGenerator.GG);
+        rodCompressedUranium_4 = new FuelRod(
+            "rodCompressedUranium4",
+            4,
+            100,
+            4,
+            3200,
+            70000,
+            new ItemStack(rodCompressedUraniumDepleted_4, 1),
+            GoodGenerator.GG);
+        rodCompressedPlutonium = new FuelRod(
+            "rodCompressedPlutonium",
+            1,
+            50,
+            4,
+            1000,
+            30000,
+            6,
+            new ItemStack(rodCompressedPlutoniumDepleted, 1),
+            GoodGenerator.GG);
+        rodCompressedPlutonium_2 = new FuelRod(
+            "rodCompressedPlutonium2",
+            2,
+            50,
+            4,
+            2000,
+            30000,
+            6,
+            new ItemStack(rodCompressedPlutoniumDepleted_2, 1),
+            GoodGenerator.GG);
+        rodCompressedPlutonium_4 = new FuelRod(
+            "rodCompressedPlutonium4",
+            4,
+            50,
+            4,
+            4000,
+            30000,
+            6,
+            new ItemStack(rodCompressedPlutoniumDepleted_4, 1),
+            GoodGenerator.GG);
+        rodLiquidUranium = new FuelRod(
+            "rodLiquidUranium",
+            1,
+            1200,
+            64,
+            8000,
+            6000,
+            new ItemStack(rodLiquidUraniumDepleted, 1),
+            GoodGenerator.GG);
+        rodLiquidUranium_2 = new FuelRod(
+            "rodLiquidUranium2",
+            2,
+            1200,
+            64,
+            8000,
+            6000,
+            new ItemStack(rodLiquidUraniumDepleted_2, 1),
+            GoodGenerator.GG);
+        rodLiquidUranium_4 = new FuelRod(
+            "rodLiquidUranium4",
+            4,
+            1200,
+            64,
+            8000,
+            6000,
+            new ItemStack(rodLiquidUraniumDepleted_4, 1),
+            GoodGenerator.GG);
+        rodLiquidPlutonium = new FuelRod(
+            "rodLiquidPlutonium",
+            1,
+            1600,
+            64,
+            10000,
+            10000,
+            2,
+            new ItemStack(rodLiquidPlutoniumDepleted, 1),
+            GoodGenerator.GG);
+        rodLiquidPlutonium_2 = new FuelRod(
+            "rodLiquidPlutonium2",
+            2,
+            1600,
+            64,
+            10000,
+            10000,
+            2,
+            new ItemStack(rodLiquidPlutoniumDepleted_2, 1),
+            GoodGenerator.GG);
+        rodLiquidPlutonium_4 = new FuelRod(
+            "rodLiquidPlutonium4",
+            4,
+            1600,
+            64,
+            10000,
+            10000,
+            2,
+            new ItemStack(rodLiquidPlutoniumDepleted_4, 1),
+            GoodGenerator.GG);
+
+        GameRegistry.registerItem(rodCompressedUranium, "rodCompressedUranium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodCompressedUranium_2, "rodCompressedUranium2", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodCompressedUranium_4, "rodCompressedUranium4", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodCompressedPlutonium, "rodCompressedPlutonium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodCompressedPlutonium_2, "rodCompressedPlutonium2", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodCompressedPlutonium_4, "rodCompressedPlutonium4", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidUranium, "rodLiquidUranium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidUranium_2, "rodLiquidUranium2", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidUranium_4, "rodLiquidUranium4", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidPlutonium, "rodLiquidPlutonium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidPlutonium_2, "rodLiquidPlutonium2", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rodLiquidPlutonium_4, "rodLiquidPlutonium4", GoodGenerator.MOD_ID);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/Loaders.java b/goodgen/src/main/java/goodgenerator/loader/Loaders.java
new file mode 100644
index 0000000000..30ca824dc0
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/Loaders.java
@@ -0,0 +1,489 @@
+package goodgenerator.loader;
+
+import static goodgenerator.util.DescTextLocalization.addText;
+import static gregtech.api.enums.Mods.GTPlusPlus;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.registry.GameRegistry;
+import goodgenerator.blocks.myFluids.FluidsBuilder;
+import goodgenerator.blocks.regularBlock.Casing;
+import goodgenerator.blocks.regularBlock.ComplexTextureCasing;
+import goodgenerator.blocks.regularBlock.Frame;
+import goodgenerator.blocks.regularBlock.TEBlock;
+import goodgenerator.blocks.regularBlock.TurbineCasing;
+import goodgenerator.blocks.tileEntity.ComponentAssemblyLine;
+import goodgenerator.blocks.tileEntity.CoolantTower;
+import goodgenerator.blocks.tileEntity.EssentiaHatch;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch_ME;
+import goodgenerator.blocks.tileEntity.ExtremeHeatExchanger;
+import goodgenerator.blocks.tileEntity.FuelRefineFactory;
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.DieselGenerator;
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator;
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronSensor;
+import goodgenerator.blocks.tileEntity.GTMetaTileEntity.YOTTAHatch;
+import goodgenerator.blocks.tileEntity.LargeEssentiaGenerator;
+import goodgenerator.blocks.tileEntity.LargeEssentiaSmeltery;
+import goodgenerator.blocks.tileEntity.LargeFusionComputer1;
+import goodgenerator.blocks.tileEntity.LargeFusionComputer2;
+import goodgenerator.blocks.tileEntity.LargeFusionComputer3;
+import goodgenerator.blocks.tileEntity.LargeFusionComputer4;
+import goodgenerator.blocks.tileEntity.LargeFusionComputer5;
+import goodgenerator.blocks.tileEntity.MultiNqGenerator;
+import goodgenerator.blocks.tileEntity.NeutronActivator;
+import goodgenerator.blocks.tileEntity.PreciseAssembler;
+import goodgenerator.blocks.tileEntity.SupercriticalFluidTurbine;
+import goodgenerator.blocks.tileEntity.UniversalChemicalFuelEngine;
+import goodgenerator.blocks.tileEntity.YottaFluidTank;
+import goodgenerator.client.render.BlockRenderHandler;
+import goodgenerator.crossmod.ic2.CropsLoader;
+import goodgenerator.crossmod.nei.NEI_Config;
+import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData;
+import goodgenerator.items.MyItemBlocks;
+import goodgenerator.items.MyItems;
+import goodgenerator.items.MyMaterial;
+import goodgenerator.items.RadioactiveItem;
+import goodgenerator.main.GoodGenerator;
+import goodgenerator.util.CrackRecipeAdder;
+import goodgenerator.util.MaterialFix;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.render.TextureFactory;
+
+public class Loaders {
+
+    public static final int IDOffset = 32001;
+    public static final byte GoodGeneratorTexturePage = 12;
+
+    public static final Item _null_ = new MyItems("_null_", null);
+
+    public static final Item radiationProtectionPlate = new MyItems("radiationProtectionPlate", GoodGenerator.GG);
+    public static final Item wrappedUraniumIngot = new MyItems("wrappedUraniumIngot", GoodGenerator.GG);
+    public static final Item highDensityUraniumNugget = new RadioactiveItem(
+        "highDensityUraniumNugget",
+        GoodGenerator.GG,
+        200);
+    public static final Item highDensityUranium = new RadioactiveItem("highDensityUranium", GoodGenerator.GG, 1800);
+    public static final Item wrappedThoriumIngot = new MyItems("wrappedThoriumIngot", GoodGenerator.GG);
+    public static final Item highDensityThoriumNugget = new RadioactiveItem(
+        "highDensityThoriumNugget",
+        GoodGenerator.GG,
+        50);
+    public static final Item highDensityThorium = new RadioactiveItem("highDensityThorium", GoodGenerator.GG, 450);
+    public static final Item wrappedPlutoniumIngot = new MyItems("wrappedPlutoniumIngot", GoodGenerator.GG);
+    public static final Item highDensityPlutoniumNugget = new RadioactiveItem(
+        "highDensityPlutoniumNugget",
+        GoodGenerator.GG,
+        450);
+    public static final Item highDensityPlutonium = new RadioactiveItem("highDensityPlutonium", GoodGenerator.GG, 4050);
+    public static final Item rawAtomicSeparationCatalyst = new MyItems("rawAtomicSeparationCatalyst", GoodGenerator.GG);
+    public static final Item advancedRadiationProtectionPlate = new MyItems(
+        "advancedRadiationProtectionPlate",
+        GoodGenerator.GG);
+    public static final Item aluminumNitride = new MyItems("aluminumNitride", "AlN", GoodGenerator.GG);
+    public static final Item specialCeramics = new MyItems("specialCeramics", GoodGenerator.GG);
+    public static final Item specialCeramicsPlate = new MyItems("specialCeramicsPlate", GoodGenerator.GG);
+    public static final Item radioactiveWaste = new RadioactiveItem("radioactiveWaste", GoodGenerator.GG, 400);
+    public static final Item plasticCase = new MyItems("plasticCase", GoodGenerator.GG);
+    public static final Item quartzWafer = new MyItems("quartzWafer", GoodGenerator.GG);
+    public static final Item microHeater = new MyItems("microHeater", GoodGenerator.GG);
+    public static final Item quartzCrystalResonator = new MyItems("quartzCrystalResonator", GoodGenerator.GG);
+    public static final Item inverter = new MyItems("inverter", addText("inverter.tooltip", 1), GoodGenerator.GG);
+    public static final Item neutronSource = new MyItems("neutronSource", GoodGenerator.GG);
+    public static final Item naquadahMass = new MyItems(
+        "naquadahMass",
+        addText("naquadahMass.tooltip", 1),
+        GoodGenerator.GG);
+    public static final Item enrichedNaquadahMass = new MyItems(
+        "enrichedNaquadahMass",
+        addText("enrichedNaquadahMass.tooltip", 1),
+        GoodGenerator.GG);
+    public static final Item naquadriaMass = new MyItems(
+        "naquadriaMass",
+        addText("naquadriaMass.tooltip", 1),
+        GoodGenerator.GG);
+    public static final Item advancedFuelRod = new MyItems("advancedFuelRod", GoodGenerator.GG);
+    public static final Item fluidCore = new MyItems(
+        "fluidCore",
+        GoodGenerator.GG,
+        new String[] { GoodGenerator.MOD_ID + ":fluidCore/1", GoodGenerator.MOD_ID + ":fluidCore/2",
+            GoodGenerator.MOD_ID + ":fluidCore/3", GoodGenerator.MOD_ID + ":fluidCore/4",
+            GoodGenerator.MOD_ID + ":fluidCore/5", GoodGenerator.MOD_ID + ":fluidCore/6",
+            GoodGenerator.MOD_ID + ":fluidCore/7", GoodGenerator.MOD_ID + ":fluidCore/8",
+            GoodGenerator.MOD_ID + ":fluidCore/9", GoodGenerator.MOD_ID + ":fluidCore/10" });
+    public static final Item upgradeEssentia = new MyItems(
+        "upgradeEssentia",
+        GoodGenerator.GG,
+        new String[] { GoodGenerator.MOD_ID + ":upgradeEssentia/null", GoodGenerator.MOD_ID + ":upgradeEssentia/air",
+            GoodGenerator.MOD_ID + ":upgradeEssentia/thermal", GoodGenerator.MOD_ID + ":upgradeEssentia/unstable",
+            GoodGenerator.MOD_ID + ":upgradeEssentia/victus", GoodGenerator.MOD_ID + ":upgradeEssentia/tainted",
+            GoodGenerator.MOD_ID + ":upgradeEssentia/mechanics", GoodGenerator.MOD_ID + ":upgradeEssentia/spirit",
+            GoodGenerator.MOD_ID + ":upgradeEssentia/radiation", GoodGenerator.MOD_ID + ":upgradeEssentia/electric" });
+    public static final Item highEnergyMixture = new MyItems(
+        "highEnergyMixture",
+        GoodGenerator.GG,
+        new String[] { GoodGenerator.MOD_ID + ":highEnergyMixture" });
+    public static final Item saltyRoot = new MyItems(
+        "saltyRoot",
+        GoodGenerator.GG,
+        new String[] { GoodGenerator.MOD_ID + ":saltyRoot" });
+    public static final Item huiCircuit = new MyItems(
+        "huiCircuit",
+        addText("huiCircuit.tooltip", 5),
+        GoodGenerator.GG,
+        new String[] { GoodGenerator.MOD_ID + ":ciruits/1", GoodGenerator.MOD_ID + ":ciruits/2",
+            GoodGenerator.MOD_ID + ":ciruits/3", GoodGenerator.MOD_ID + ":ciruits/4",
+            GoodGenerator.MOD_ID + ":ciruits/5", });
+
+    public static final Item circuitWrap = new MyItems(
+        "circuitWrap",
+        GoodGenerator.GG,
+        new String[] { GoodGenerator.MOD_ID + ":wraps/0", GoodGenerator.MOD_ID + ":wraps/1",
+            GoodGenerator.MOD_ID + ":wraps/2", GoodGenerator.MOD_ID + ":wraps/3", GoodGenerator.MOD_ID + ":wraps/4",
+            GoodGenerator.MOD_ID + ":wraps/5", GoodGenerator.MOD_ID + ":wraps/6", GoodGenerator.MOD_ID + ":wraps/7",
+            GoodGenerator.MOD_ID + ":wraps/8", GoodGenerator.MOD_ID + ":wraps/9", GoodGenerator.MOD_ID + ":wraps/10",
+            GoodGenerator.MOD_ID + ":wraps/11", GoodGenerator.MOD_ID + ":wraps/12", GoodGenerator.MOD_ID + ":wraps/13",
+            GoodGenerator.MOD_ID + ":wraps/14" });
+
+    public static final Block MAR_Casing = new Casing(
+        "MAR_Casing",
+        new String[] { GoodGenerator.MOD_ID + ":MAR_Casing" });
+    public static final Block FRF_Casings = new Casing(
+        "FRF_Casing",
+        new String[] { "gregtech:iconsets/MACHINE_CASING_MINING_BLACKPLUTONIUM" });
+    public static final Block FRF_Coil_1 = new Casing(
+        "FRF_Coil_1",
+        new String[] { GoodGenerator.MOD_ID + ":FRF_Coils/1" });
+    public static final Block FRF_Coil_2 = new Casing(
+        "FRF_Coil_2",
+        new String[] { GoodGenerator.MOD_ID + ":FRF_Coils/2" });
+    public static final Block FRF_Coil_3 = new Casing(
+        "FRF_Coil_3",
+        new String[] { GoodGenerator.MOD_ID + ":FRF_Coils/3" });
+    public static final Block FRF_Coil_4 = new Casing(
+        "FRF_Coil_4",
+        new String[] { GoodGenerator.MOD_ID + ":FRF_Coils/4" });
+    public static final Block radiationProtectionSteelFrame = new Frame(
+        "radiationProtectionSteelFrame",
+        new String[] { GoodGenerator.MOD_ID + ":radiationProtectionSteelFrame" });
+    public static final Block fieldRestrictingGlass = new Frame(
+        "fieldRestrictingGlass",
+        new String[] { GoodGenerator.MOD_ID + ":fieldRestrictingGlass" });
+    public static final Block rawCylinder = new Casing(
+        "rawCylinder",
+        new String[] { GoodGenerator.MOD_ID + ":rawCylinder" });
+    public static final Block titaniumPlatedCylinder = new Casing(
+        "titaniumPlatedCylinder",
+        new String[] { GoodGenerator.MOD_ID + ":titaniumPlatedCylinder" });
+    public static final Block magicCasing = new Casing(
+        "magicCasing",
+        new String[] { GoodGenerator.MOD_ID + ":MagicCasing" });
+    public static final Block essentiaCell = new Casing(
+        "essentiaCell",
+        new String[] { GoodGenerator.MOD_ID + ":essentiaCell/1", GoodGenerator.MOD_ID + ":essentiaCell/2",
+            GoodGenerator.MOD_ID + ":essentiaCell/3", GoodGenerator.MOD_ID + ":essentiaCell/4" });
+    public static final Block speedingPipe = new ComplexTextureCasing(
+        "speedingPipe",
+        new String[] { GoodGenerator.MOD_ID + ":speedingPipe_SIDE" },
+        new String[] { GoodGenerator.MOD_ID + ":speedingPipe_TOP" });
+    public static final Block yottaFluidTankCell = new Casing(
+        "yottaFluidTankCell",
+        new String[] { GoodGenerator.MOD_ID + ":yottaFluidTankCell/1", GoodGenerator.MOD_ID + ":yottaFluidTankCell/2",
+            GoodGenerator.MOD_ID + ":yottaFluidTankCell/3", GoodGenerator.MOD_ID + ":yottaFluidTankCell/4",
+            GoodGenerator.MOD_ID + ":yottaFluidTankCell/5", GoodGenerator.MOD_ID + ":yottaFluidTankCell/6",
+            GoodGenerator.MOD_ID + ":yottaFluidTankCell/7", GoodGenerator.MOD_ID + ":yottaFluidTankCell/8",
+            GoodGenerator.MOD_ID + ":yottaFluidTankCell/9", GoodGenerator.MOD_ID + ":yottaFluidTankCell/10", });
+    public static final Block yottaFluidTankCasing = new ComplexTextureCasing(
+        "yottaFluidTankCasing",
+        new String[] { GoodGenerator.MOD_ID + ":yottaFluidTankCasing_SIDE" },
+        new String[] { GoodGenerator.MOD_ID + ":yottaFluidTankCasing_TOP" });
+    public static final Block supercriticalFluidTurbineCasing = new TurbineCasing(
+        "supercriticalFluidTurbineCasing",
+        "supercriticalFluidTurbineCasing");
+    public static final Block pressureResistantWalls = new Casing(
+        "pressureResistantWalls",
+        new String[] { GoodGenerator.MOD_ID + ":pressureResistantWalls" });
+    public static final Block preciseUnitCasing = new Casing(
+        "preciseUnitCasing",
+        new String[] { GoodGenerator.MOD_ID + ":preciseUnitCasing/1", GoodGenerator.MOD_ID + ":preciseUnitCasing/2",
+            GoodGenerator.MOD_ID + ":preciseUnitCasing/3" });
+    public static final Block compactFusionCoil = new Casing(
+        "compactFusionCoil",
+        new String[] { GoodGenerator.MOD_ID + ":fuison/1", GoodGenerator.MOD_ID + ":fuison/2",
+            GoodGenerator.MOD_ID + ":fuison/3", GoodGenerator.MOD_ID + ":fuison/4",
+            GoodGenerator.MOD_ID + ":fuison/5" });
+    public static final Block essentiaFilterCasing = new Casing(
+        "essentiaFilterCasing",
+        new String[] { GoodGenerator.MOD_ID + ":essentiaFilterCasing" });
+    public static Block essentiaHatch;
+    public static Block essentiaOutputHatch;
+    public static Block essentiaOutputHatch_ME;
+    public static final Block componentAssemblylineCasing = new Casing(
+        "componentAssemblyLineCasing",
+        new String[] { GoodGenerator.MOD_ID + ":compAsslineCasing/0", // LV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/1", // MV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/2", // HV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/3", // EV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/4", // IV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/5", // LuV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/6", // ZPM
+            GoodGenerator.MOD_ID + ":compAsslineCasing/7", // UV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/8", // UHV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/9", // UEV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/10", // UIV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/11", // UMV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/12", // UXV
+            GoodGenerator.MOD_ID + ":compAsslineCasing/13" // MAX
+        });
+    public static ItemStack MAR;
+    public static ItemStack FRF;
+    public static ItemStack UCFE;
+    public static ItemStack LEG;
+    public static ItemStack NS;
+    public static ItemStack NA;
+    public static ItemStack YFT;
+    public static ItemStack YFH;
+    public static ItemStack SCTurbine;
+    public static ItemStack XHE;
+    public static ItemStack PA;
+    public static ItemStack LES;
+    public static ItemStack CT;
+    public static ItemStack[] LFC = new ItemStack[5];
+
+    public static ItemStack[] NeutronAccelerators = new ItemStack[9];
+    public static ItemStack[] Generator_Diesel = new ItemStack[2];
+
+    public static ItemStack CompAssline;
+    // public static Item Isotope = new NuclearMetaItemGenerator();
+
+    public static void GTMetaTileRegister() {
+        Loaders.MAR = new MultiNqGenerator(12732, "NaG", "Large Naquadah Reactor").getStackForm(1L);
+        Loaders.FRF = new FuelRefineFactory(16999, "FRF", "Naquadah Fuel Refinery").getStackForm(1L);
+        Loaders.UCFE = new UniversalChemicalFuelEngine(
+            IDOffset,
+            "UniversalChemicalFuelEngine",
+            "Universal Chemical Fuel Engine").getStackForm(1L);
+        for (int i = 0; i < 9; i++) {
+            Loaders.NeutronAccelerators[i] = new NeutronAccelerator(
+                IDOffset + 2 + i,
+                "Neutron Accelerator " + GT_Values.VN[i],
+                "Neutron Accelerator " + GT_Values.VN[i],
+                i).getStackForm(1L);
+        }
+        Loaders.NS = new NeutronSensor(IDOffset + 11, "Neutron Sensor", "Neutron Sensor", 5).getStackForm(1L);
+        Loaders.NA = new NeutronActivator(IDOffset + 12, "NeutronActivator", "Neutron Activator").getStackForm(1L);
+        Loaders.YFT = new YottaFluidTank(IDOffset + 13, "YottaFluidTank", "YOTTank").getStackForm(1L);
+        Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1L);
+        Loaders.SCTurbine = new SupercriticalFluidTurbine(
+            IDOffset + 15,
+            "SupercriticalSteamTurbine",
+            "SC Steam Turbine").getStackForm(1L);
+        Loaders.XHE = new ExtremeHeatExchanger(IDOffset + 16, "ExtremeHeatExchanger", "Extreme Heat Exchanger")
+            .getStackForm(1L);
+        Loaders.PA = new PreciseAssembler(IDOffset + 17, "PreciseAssembler", "Precise Auto-Assembler MT-3662")
+            .getStackForm(1L);
+        Loaders.LFC[0] = new LargeFusionComputer1(
+            IDOffset + 18,
+            "LargeFusionComputer1",
+            "Compact Fusion Computer MK-I Prototype").getStackForm(1);
+        Loaders.LFC[1] = new LargeFusionComputer2(
+            IDOffset + 19,
+            "LargeFusionComputer2",
+            "Compact Fusion Computer MK-II").getStackForm(1L);
+        Loaders.LFC[2] = new LargeFusionComputer3(
+            IDOffset + 20,
+            "LargeFusionComputer3",
+            "Compact Fusion Computer MK-III").getStackForm(1L);
+        if (GTPlusPlus.isModLoaded()) {
+            Loaders.LFC[3] = new LargeFusionComputer4(
+                IDOffset + 21,
+                "LargeFusionComputer4",
+                "Compact Fusion Computer MK-IV Prototype").getStackForm(1L);
+            Loaders.LFC[4] = new LargeFusionComputer5(
+                IDOffset + 22,
+                "LargeFusionComputer5",
+                "Compact Fusion Computer MK-V").getStackForm(1L);
+        }
+        Loaders.Generator_Diesel[0] = new DieselGenerator(
+            1113,
+            "basicgenerator.diesel.tier.04",
+            "Turbo Supercharging Combustion Generator",
+            4).getStackForm(1L);
+        Loaders.Generator_Diesel[1] = new DieselGenerator(
+            1114,
+            "basicgenerator.diesel.tier.05",
+            "Ultimate Chemical Energy Releaser",
+            5).getStackForm(1L);
+        Loaders.CT = new CoolantTower(IDOffset + 24, "CoolantTower", "Coolant Tower").getStackForm(1L);
+        Loaders.CompAssline = new ComponentAssemblyLine(
+            IDOffset + 25,
+            "ComponentAssemblyLine",
+            "Component Assembly Line").getStackForm(1L);
+        CrackRecipeAdder.registerPipe(30995, MyMaterial.incoloy903, 15000, 8000, true);
+        CrackRecipeAdder.registerWire(32749, MyMaterial.signalium, 12, 131072, 16, true);
+        CrackRecipeAdder.registerWire(32737, MyMaterial.lumiium, 8, 524288, 64, true);
+    }
+
+    public static void Register() {
+
+        GameRegistry.registerItem(_null_, "_null_", GoodGenerator.MOD_ID);
+        NEI_Config.hide(_null_);
+
+        GameRegistry.registerBlock(MAR_Casing, MyItemBlocks.class, "MAR_Casing");
+        GameRegistry.registerBlock(radiationProtectionSteelFrame, MyItemBlocks.class, "radiationProtectionSteelFrame");
+        GameRegistry.registerBlock(fieldRestrictingGlass, MyItemBlocks.class, "fieldRestrictingGlass");
+        GameRegistry.registerBlock(FRF_Casings, MyItemBlocks.class, "FRF_Casings");
+        GameRegistry.registerBlock(FRF_Coil_1, MyItemBlocks.class, "FRF_Coil_1");
+        GameRegistry.registerBlock(FRF_Coil_2, MyItemBlocks.class, "FRF_Coil_2");
+        GameRegistry.registerBlock(FRF_Coil_3, MyItemBlocks.class, "FRF_Coil_3");
+        GameRegistry.registerBlock(FRF_Coil_4, MyItemBlocks.class, "FRF_Coil_4");
+        GameRegistry.registerBlock(rawCylinder, MyItemBlocks.class, "rawCylinder");
+        GameRegistry.registerBlock(titaniumPlatedCylinder, MyItemBlocks.class, "titaniumPlatedCylinder");
+        GameRegistry.registerBlock(speedingPipe, MyItemBlocks.class, "speedingPipe");
+        GameRegistry.registerBlock(yottaFluidTankCell, MyItemBlocks.class, "yottaFluidTankCells");
+        GameRegistry.registerBlock(yottaFluidTankCasing, MyItemBlocks.class, "yottaFluidTankCasing");
+        GameRegistry
+            .registerBlock(supercriticalFluidTurbineCasing, MyItemBlocks.class, "supercriticalFluidTurbineCasing");
+        GameRegistry.registerBlock(componentAssemblylineCasing, MyItemBlocks.class, "componentAssemblylineCasing");
+        GameRegistry.registerBlock(pressureResistantWalls, MyItemBlocks.class, "pressureResistantWalls");
+        GameRegistry.registerBlock(preciseUnitCasing, MyItemBlocks.class, "preciseUnitCasing");
+        GameRegistry.registerBlock(compactFusionCoil, MyItemBlocks.class, "compactFusionCoil");
+        GameRegistry.registerItem(radiationProtectionPlate, "radiationProtectionPlate", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(wrappedUraniumIngot, "wrappedUraniumIngot", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highDensityUraniumNugget, "highDensityUraniumNugget", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highDensityUranium, "highDensityUranium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(wrappedThoriumIngot, "wrappedThoriumIngot", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highDensityThoriumNugget, "highDensityThoriumNugget", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highDensityThorium, "highDensityThorium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(wrappedPlutoniumIngot, "wrappedPlutoniumIngot", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highDensityPlutoniumNugget, "highDensityPlutoniumNugget", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highDensityPlutonium, "highDensityPlutonium", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(rawAtomicSeparationCatalyst, "rawAtomicSeparationCatalyst", GoodGenerator.MOD_ID);
+        GameRegistry
+            .registerItem(advancedRadiationProtectionPlate, "advancedRadiationProtectionPlate", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(aluminumNitride, "aluminumNitride", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(specialCeramics, "specialCeramics", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(specialCeramicsPlate, "specialCeramicsPlate", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(radioactiveWaste, "radioactiveWaste", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(plasticCase, "plasticCase", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(quartzWafer, "quartzWafer", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(microHeater, "microHeater", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(quartzCrystalResonator, "quartzCrystalResonator", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(inverter, "inverter", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(neutronSource, "neutronSource", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(naquadahMass, "naquadahMass", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(enrichedNaquadahMass, "enrichedNaquadahMass", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(naquadriaMass, "naquadriaMass", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(advancedFuelRod, "advancedFuelRod", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(fluidCore, "fluidCore", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(highEnergyMixture, "highEnergyMixture", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(saltyRoot, "saltyRoot", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(huiCircuit, "huiCircuit", GoodGenerator.MOD_ID);
+        GameRegistry.registerItem(circuitWrap, "circuitWrap", GoodGenerator.MOD_ID);
+    }
+
+    public static void compactMod() {
+        if (Loader.isModLoaded("Thaumcraft")) {
+            LargeEssentiaEnergyData.processEssentiaData();
+            GameRegistry.registerItem(upgradeEssentia, "upgradeEssentia", GoodGenerator.MOD_ID);
+            GameRegistry.registerTileEntity(EssentiaHatch.class, "EssentiaHatch");
+            GameRegistry.registerTileEntity(EssentiaOutputHatch.class, "EssentiaOutputHatch");
+            GameRegistry.registerTileEntity(EssentiaOutputHatch_ME.class, "EssentiaOutputHatch_ME");
+            Loaders.LEG = new LargeEssentiaGenerator(IDOffset + 1, "LargeEssentiaGenerator", "Large Essentia Generator")
+                .getStackForm(1L);
+            Loaders.LES = new LargeEssentiaSmeltery(IDOffset + 23, "LargeEssentiaSmeltery", "Large Essentia Smeltery")
+                .getStackForm(1L);
+            essentiaHatch = new TEBlock("essentiaHatch", new String[] { GoodGenerator.MOD_ID + ":essentiaHatch" }, 1);
+            essentiaOutputHatch = new TEBlock(
+                "essentiaOutputHatch",
+                new String[] { GoodGenerator.MOD_ID + ":essentiaOutputHatch" },
+                2);
+            essentiaOutputHatch_ME = new TEBlock(
+                "essentiaOutputHatch_ME",
+                new String[] { GoodGenerator.MOD_ID + ":essentiaOutputHatch_ME" },
+                3);
+            GameRegistry.registerBlock(magicCasing, MyItemBlocks.class, "magicCasing");
+            GameRegistry.registerBlock(essentiaCell, MyItemBlocks.class, "essentiaCell");
+            GameRegistry.registerBlock(essentiaHatch, MyItemBlocks.class, "essentiaHatch");
+            GameRegistry.registerBlock(essentiaOutputHatch, MyItemBlocks.class, "essentiaOutputHatch");
+            GameRegistry.registerBlock(essentiaFilterCasing, MyItemBlocks.class, "essentiaFilterCasing");
+            GameRegistry.registerBlock(essentiaOutputHatch_ME, MyItemBlocks.class, "essentiaOutputHatch_ME");
+
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing);
+        }
+    }
+
+    public static void addOreDic() {
+        OreDictionary.registerOre("dustAluminumNitride", aluminumNitride);
+    }
+
+    public static void addTexturePage() {
+        if (Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] == null) {
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] = new ITexture[128];
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][1] = TextureFactory
+                .of(yottaFluidTankCasing);
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][2] = TextureFactory
+                .of(supercriticalFluidTurbineCasing);
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][3] = TextureFactory
+                .of(preciseUnitCasing, 0);
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][4] = TextureFactory
+                .of(preciseUnitCasing, 1);
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][5] = TextureFactory
+                .of(preciseUnitCasing, 2);
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][6] = TextureFactory
+                .of(GregTech_API.sBlockConcretes, 8);
+        }
+    }
+
+    public static void preInitLoad() {
+        Register();
+        addOreDic();
+        addTexturePage();
+        compactMod();
+        FluidsBuilder.Register();
+        FuelRodLoader.RegisterRod();
+    }
+
+    public static void initLoad() {
+        if (FMLCommonHandler.instance()
+            .getSide()
+            .isClient()) {
+            new BlockRenderHandler();
+        }
+        GTMetaTileRegister();
+        initLoadRecipes();
+        CropsLoader.registerCrops();
+    }
+
+    public static void postInitLoad() {
+        postInitLoadRecipes();
+    }
+
+    public static void completeLoad() {
+        RecipeLoader_02.FinishLoadRecipe();
+        MaterialFix.addRecipeForMultiItems();
+        ComponentAssemblyLineRecipeLoader.run();
+    }
+
+    public static void initLoadRecipes() {
+        RecipeLoader.InitLoadRecipe();
+        RecipeLoader_02.InitLoadRecipe();
+        FuelRecipeLoader.RegisterFuel();
+        NaquadahReworkRecipeLoader.RecipeLoad();
+    }
+
+    public static void postInitLoadRecipes() {
+        RecipeLoader.RecipeLoad();
+        RecipeLoader.Fixer();
+        RecipeLoader_02.RecipeLoad();
+        NeutronActivatorLoader.NARecipeLoad();
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java
new file mode 100644
index 0000000000..ad51d7a99d
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java
@@ -0,0 +1,1376 @@
+package goodgenerator.loader;
+
+import static goodgenerator.items.MyMaterial.P507;
+import static goodgenerator.items.MyMaterial.adamantine;
+import static goodgenerator.items.MyMaterial.concentratedEnrichedNaquadahSludge;
+import static goodgenerator.items.MyMaterial.enrichedNaquadahEarth;
+import static goodgenerator.items.MyMaterial.enrichedNaquadahGoo;
+import static goodgenerator.items.MyMaterial.enrichedNaquadahRichSolution;
+import static goodgenerator.items.MyMaterial.enrichedNaquadahSulphate;
+import static goodgenerator.items.MyMaterial.fluorineRichWasteLiquid;
+import static goodgenerator.items.MyMaterial.fluoroantimonicAcid;
+import static goodgenerator.items.MyMaterial.galliumHydroxide;
+import static goodgenerator.items.MyMaterial.indiumPhosphate;
+import static goodgenerator.items.MyMaterial.inertEnrichedNaquadah;
+import static goodgenerator.items.MyMaterial.inertNaquadah;
+import static goodgenerator.items.MyMaterial.inertNaquadria;
+import static goodgenerator.items.MyMaterial.lowQualityNaquadahEmulsion;
+import static goodgenerator.items.MyMaterial.lowQualityNaquadahSolution;
+import static goodgenerator.items.MyMaterial.lowQualityNaquadriaPhosphate;
+import static goodgenerator.items.MyMaterial.lowQualityNaquadriaSolution;
+import static goodgenerator.items.MyMaterial.lowQualityNaquadriaSulphate;
+import static goodgenerator.items.MyMaterial.magnesiumSulphate;
+import static goodgenerator.items.MyMaterial.naquadahAdamantiumSolution;
+import static goodgenerator.items.MyMaterial.naquadahEarth;
+import static goodgenerator.items.MyMaterial.naquadahGoo;
+import static goodgenerator.items.MyMaterial.naquadahRichSolution;
+import static goodgenerator.items.MyMaterial.naquadahine;
+import static goodgenerator.items.MyMaterial.naquadriaEarth;
+import static goodgenerator.items.MyMaterial.naquadriaGoo;
+import static goodgenerator.items.MyMaterial.naquadriaRichSolution;
+import static goodgenerator.items.MyMaterial.naquadriaSulphate;
+import static goodgenerator.items.MyMaterial.titaniumTrifluoride;
+import static goodgenerator.items.MyMaterial.towEthyl1Hexanol;
+import static goodgenerator.items.MyMaterial.triniumSulphate;
+import static goodgenerator.items.MyMaterial.wasteLiquid;
+import static goodgenerator.main.GG_Config_Loader.EnableNaquadahRework;
+import static gregtech.api.enums.Mods.GTPlusPlus;
+import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes;
+import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes;
+import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes;
+import static gregtech.api.recipe.RecipeMaps.chemicalReactorRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.maceratorRecipes;
+import static gregtech.api.recipe.RecipeMaps.mixerRecipes;
+import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes;
+import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT;
+import static gregtech.api.util.GT_RecipeConstants.UniversalChemical;
+import static gregtech.common.items.GT_MetaGenerated_Item_01.registerCauldronCleaningFor;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashSet;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.item.crafting.ShapedRecipes;
+import net.minecraft.item.crafting.ShapelessRecipes;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+import net.minecraftforge.oredict.ShapedOreRecipe;
+import net.minecraftforge.oredict.ShapelessOreRecipe;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement.PlatinumSludgeOverHaul;
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+
+import goodgenerator.main.GoodGenerator;
+import goodgenerator.util.CrackRecipeAdder;
+import goodgenerator.util.ItemRefer;
+import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.CombType;
+import gregtech.loaders.misc.GT_Bees;
+import gtPlusPlus.api.recipe.GTPPRecipeMaps;
+import gtPlusPlus.core.item.chemistry.GenericChem;
+import gtPlusPlus.core.lib.CORE;
+
+public class NaquadahReworkRecipeLoader {
+
+    public static void RecipeLoad() {
+
+        if (!EnableNaquadahRework) return;
+
+        if (GTPlusPlus.isModLoaded()) {
+            try {
+                // Naquadah (UEV)
+                CORE.RA.addQuantumTransformerRecipe(
+                    new ItemStack[] { naquadahEarth.get(OrePrefixes.dust, 32), Materials.Sodium.getDust(64),
+                        Materials.Carbon.getDust(1), GT_Utility.copyAmount(0, GenericChem.mSimpleNaquadahCatalyst) },
+                    new FluidStack[] { Materials.Hydrogen.getGas(64000L), Materials.Fluorine.getGas(64000L),
+                        Materials.Oxygen.getGas(100L) },
+                    new FluidStack[] {},
+                    new ItemStack[] { inertNaquadah.get(OrePrefixes.dust, 1), Materials.Titanium.getDust(64),
+                        Materials.Adamantium.getDust(64), Materials.Gallium.getDust(64) },
+                    new int[] { 2500, 2500, 2500, 2500 },
+                    10 * 20,
+                    (int) GT_Values.VP[10],
+                    2);
+                // Enriched Naquadah (UIV)
+                CORE.RA.addQuantumTransformerRecipe(
+                    new ItemStack[] { enrichedNaquadahEarth.get(OrePrefixes.dust, 32), Materials.Zinc.getDust(64),
+                        Materials.Carbon.getDust(1), GT_Utility.copyAmount(0, GenericChem.mSimpleNaquadahCatalyst) },
+                    new FluidStack[] { Materials.SulfuricAcid.getFluid(16000), Materials.Oxygen.getGas(100L) },
+                    new FluidStack[] { wasteLiquid.getFluidOrGas(32000) },
+                    new ItemStack[] { inertEnrichedNaquadah.get(OrePrefixes.dust, 1), Materials.Trinium.getDust(64), },
+                    new int[] { 3300, 3300, 3300 },
+                    10 * 20,
+                    (int) GT_Values.VP[11],
+                    2);
+                // Naquadria (UMV)
+                CORE.RA.addQuantumTransformerRecipe(
+                    new ItemStack[] { naquadriaEarth.get(OrePrefixes.dust, 32), Materials.Magnesium.getDust(64),
+                        GT_Utility.copyAmount(0, GenericChem.mAdvancedNaquadahCatalyst) },
+                    new FluidStack[] { Materials.PhosphoricAcid.getFluid(16000), Materials.SulfuricAcid.getFluid(16000),
+                        Materials.Oxygen.getGas(100L) },
+                    new FluidStack[] {},
+                    new ItemStack[] { inertNaquadria.get(OrePrefixes.dust, 1), Materials.Barium.getDust(64),
+                        Materials.Indium.getDust(64), ItemList.NaquadriaSupersolid.get(1) },
+                    new int[] { 2500, 2500, 2500, 2500 },
+                    5 * 20,
+                    (int) GT_Values.VP[12],
+                    3);
+                // Activate Them
+                MyRecipeAdder.instance.addNeutronActivatorRecipe(
+                    new FluidStack[] { Materials.Nickel.getPlasma(144 * 16) },
+                    new ItemStack[] { inertNaquadah.get(OrePrefixes.dust, 64),
+                        inertNaquadah.get(OrePrefixes.dust, 32) },
+                    new FluidStack[] { Materials.Naquadah.getMolten(144 * 9216) },
+                    new ItemStack[] { Materials.Nickel.getDust(16) },
+                    2000,
+                    600,
+                    500);
+                MyRecipeAdder.instance.addNeutronActivatorRecipe(
+                    new FluidStack[] { Materials.Titanium.getPlasma(16 * 144) },
+                    new ItemStack[] { inertEnrichedNaquadah.get(OrePrefixes.dust, 64),
+                        inertEnrichedNaquadah.get(OrePrefixes.dust, 32) },
+                    new FluidStack[] { Materials.NaquadahEnriched.getMolten(144 * 9216) },
+                    new ItemStack[] { Materials.Titanium.getDust(16) },
+                    2000,
+                    900,
+                    850);
+                MyRecipeAdder.instance.addNeutronActivatorRecipe(
+                    new FluidStack[] { Materials.Americium.getPlasma(144 * 16) },
+                    new ItemStack[] { inertNaquadria.get(OrePrefixes.dust, 64),
+                        inertNaquadria.get(OrePrefixes.dust, 32) },
+                    new FluidStack[] { Materials.Naquadria.getMolten(144 * 9216) },
+                    new ItemStack[] { Materials.Americium.getDust(16) },
+                    2000,
+                    1100,
+                    1080);
+            } catch (Throwable t) {
+                // Cry about it
+            }
+        }
+
+        // Fix shit
+        GT_Values.RA.stdBuilder()
+            .itemInputs(lowQualityNaquadriaSolution.get(OrePrefixes.cell, 1))
+            .itemOutputs(Materials.Tin.getDust(2))
+            .duration(16 * SECONDS + 14 * TICKS)
+            .eut(4)
+            .addTo(maceratorRecipes);
+
+        // Naquadah Rework Line
+        GT_Values.RA.stdBuilder()
+            .itemInputs(naquadahEarth.get(OrePrefixes.dust, 2), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(fluoroantimonicAcid.getFluidOrGas(3000))
+            .fluidOutputs(lowQualityNaquadahEmulsion.getFluidOrGas(2000))
+            .itemOutputs(titaniumTrifluoride.get(OrePrefixes.dust, 4))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .metadata(COIL_HEAT, 3000)
+            .addTo(blastFurnaceRecipes);
+
+        // TiF3 + 3H = Ti + 3HF
+        GT_Values.RA.stdBuilder()
+            .itemInputs(titaniumTrifluoride.get(OrePrefixes.dust, 4), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Hydrogen.getGas(3000))
+            .fluidOutputs(Materials.HydrofluoricAcid.getFluid(3000))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Titanium, 1))
+            .duration(6 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .metadata(COIL_HEAT, 2000)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Copper, 1)),
+                Materials.Hydrogen.getCells(8))
+            .fluidInputs(FluidRegistry.getFluidStack("seedoil", 3000))
+            .itemOutputs(ItemList.Cell_Empty.get(8))
+            .fluidOutputs(towEthyl1Hexanol.getFluidOrGas(1000))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(UniversalChemical);
+
+        // 2C8H18O + H3PO4 =Na,C2H6O= C16H35O3P + 2H2O
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 2))
+            .fluidInputs(
+                towEthyl1Hexanol.getFluidOrGas(2000),
+                Materials.PhosphoricAcid.getFluid(1000),
+                Materials.Ethanol.getFluid(2000))
+            .fluidOutputs(P507.getFluidOrGas(1000))
+            .duration(1 * MINUTES)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(lowQualityNaquadahSolution.get(OrePrefixes.cell, 36), P507.get(OrePrefixes.cell, 4))
+            .itemOutputs(naquadahAdamantiumSolution.get(OrePrefixes.cell, 30), ItemList.Cell_Empty.get(10))
+            .fluidOutputs(fluorineRichWasteLiquid.getFluidOrGas(10000))
+            .duration(3 * MINUTES + 20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(chemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .fluidInputs(P507.getFluidOrGas(4000), lowQualityNaquadahSolution.getFluidOrGas(36000))
+            .fluidOutputs(fluorineRichWasteLiquid.getFluidOrGas(10000), naquadahAdamantiumSolution.getFluidOrGas(30000))
+            .duration(3 * MINUTES + 20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 40))
+            .fluidInputs(fluorineRichWasteLiquid.getFluidOrGas(1500))
+            .fluidOutputs(wasteLiquid.getFluidOrGas(1000))
+            .itemOutputs(WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 60))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(UniversalChemical);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            wasteLiquid.getFluidOrGas(10000),
+            new FluidStack[] { Materials.SaltWater.getFluid(3000), FluidRegistry.getFluidStack("phenol", 2000),
+                Materials.HydrochloricAcid.getFluid(5000) },
+            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Chrome, 3),
+            15 * SECONDS,
+            TierEU.RECIPE_HV);
+
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            new FluidStack[] { naquadahAdamantiumSolution.getFluidOrGas(3000) },
+            null,
+            new FluidStack[] { naquadahRichSolution.getFluidOrGas(2000) },
+            new ItemStack[] { adamantine.get(OrePrefixes.dust, 4), naquadahEarth.get(OrePrefixes.dust, 2),
+                concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 1) },
+            100,
+            230,
+            200);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27))
+            .fluidInputs(naquadahRichSolution.getFluidOrGas(5000))
+            .itemOutputs(naquadahine.get(OrePrefixes.dust, 30))
+            .fluidOutputs(P507.getFluidOrGas(1000))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(autoclaveRecipes);
+
+        // NqO2 + C = CO2 + Nq
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                naquadahine.get(OrePrefixes.dust, 3),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Carbon, 1))
+            .fluidOutputs(Materials.CarbonDioxide.getGas(1000))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadah, 1))
+            .duration(2 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .metadata(COIL_HEAT, 5000)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(lowQualityNaquadahEmulsion.getFluidOrGas(10000))
+            .itemOutputs(
+                galliumHydroxide.get(OrePrefixes.dust, 64),
+                galliumHydroxide.get(OrePrefixes.dust, 48),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Antimony, 15))
+            .outputChances(6250, 6250, 10000)
+            .fluidOutputs(lowQualityNaquadahSolution.getFluidOrGas(9000))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(enrichedNaquadahEarth.get(OrePrefixes.dust, 4))
+            .fluidInputs(P507.getFluidOrGas(1000), Materials.SulfuricAcid.getFluid(18000))
+            .fluidOutputs(enrichedNaquadahRichSolution.getFluidOrGas(4000), wasteLiquid.getFluidOrGas(1000))
+            .itemOutputs(naquadahEarth.get(OrePrefixes.dust, 1), triniumSulphate.get(OrePrefixes.dust, 1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        // ZnSO4 + 2H = H2SO4 + Zn
+        GT_Values.RA.stdBuilder()
+            .itemInputs(WerkstoffLoader.ZincSulfate.get(OrePrefixes.dust, 6))
+            .fluidInputs(Materials.Hydrogen.getGas(2000))
+            .fluidOutputs(Materials.SulfuricAcid.getFluid(1000))
+            .itemOutputs(Materials.Zinc.getDust(1))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_ULV)
+            .addTo(UniversalChemical);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 60))
+            .fluidInputs(enrichedNaquadahRichSolution.getFluidOrGas(10000))
+            .itemOutputs(concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 8))
+            .fluidOutputs(P507.getFluidOrGas(2500))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(autoclaveRecipes);
+
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            null,
+            new ItemStack[] { concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 16), },
+            null,
+            new ItemStack[] { enrichedNaquadahSulphate.get(OrePrefixes.dust, 64),
+                enrichedNaquadahSulphate.get(OrePrefixes.dust, 64), enrichedNaquadahSulphate.get(OrePrefixes.dust, 37),
+                WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 64),
+                WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 64),
+                WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 12),
+                lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 2), },
+            120,
+            480,
+            460);
+
+        // Nq+(SO4)2 + 2Zn = Nq+ + 2ZnSO4
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                enrichedNaquadahSulphate.get(OrePrefixes.dust, 11),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Zinc, 2))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.NaquadahEnriched, 1),
+                WerkstoffLoader.ZincSulfate.get(OrePrefixes.dust, 12))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .metadata(COIL_HEAT, 7500)
+            .addTo(blastFurnaceRecipes);
+
+        // KeSO4 + 2H = Ke + H2SO4
+        GT_Values.RA.stdBuilder()
+            .itemInputs(triniumSulphate.get(OrePrefixes.dust, 6))
+            .fluidInputs(Materials.Hydrogen.getGas(2000))
+            .fluidOutputs(Materials.SulfuricAcid.getFluid(1000))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Trinium, 1))
+            .duration(6 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(naquadriaEarth.get(OrePrefixes.dust, 4))
+            .fluidInputs(Materials.PhosphoricAcid.getFluid(4000))
+            .itemOutputs(
+                indiumPhosphate.get(OrePrefixes.dust, 6),
+                lowQualityNaquadriaPhosphate.get(OrePrefixes.dust, 4))
+            .outputChances(2000, 10000)
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .addTo(centrifugeRecipes);
+
+        // Ga(OH)3 + 3Na = Ga + 3NaOH
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                galliumHydroxide.get(OrePrefixes.dust, 7),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 3))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gallium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 9))
+            .duration(2 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        // 2InPO4 + 3Ca = 2In + Ca3(PO4)2
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                indiumPhosphate.get(OrePrefixes.dust, 12),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 3))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Indium, 2),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TricalciumPhosphate, 5))
+            .duration(1 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(lowQualityNaquadriaPhosphate.get(OrePrefixes.dust, 10), Materials.SulfuricAcid.getCells(30))
+            .fluidOutputs(naquadriaRichSolution.getFluidOrGas(9000))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Barite, 1), ItemList.Cell_Empty.get(30))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(UniversalChemical);
+
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            new FluidStack[] { naquadriaRichSolution.getFluidOrGas(9000) },
+            null,
+            null,
+            new ItemStack[] { naquadriaSulphate.get(OrePrefixes.dust, 44),
+                lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 6) },
+            100,
+            1100,
+            1050);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 3), Materials.Water.getCells(3))
+            .fluidInputs(P507.getFluidOrGas(500))
+            .fluidOutputs(lowQualityNaquadriaSolution.getFluidOrGas(3500))
+            .itemOutputs(ItemList.Cell_Empty.get(3))
+            .duration(25 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(UniversalChemical);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            lowQualityNaquadriaSolution.getFluidOrGas(7000),
+            new FluidStack[] { P507.getFluidOrGas(1000), naquadriaRichSolution.getFluidOrGas(5400),
+                Materials.DilutedSulfuricAcid.getFluid(12000) },
+            enrichedNaquadahEarth.get(OrePrefixes.dust, 2),
+            25 * SECONDS,
+            TierEU.RECIPE_IV);
+
+        // Nq*(SO4)2 + 2Mg = Nq* + 2MgSO4
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                naquadriaSulphate.get(OrePrefixes.dust, 11),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 2))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadria, 1),
+                magnesiumSulphate.get(OrePrefixes.dust, 12))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .metadata(COIL_HEAT, 9100)
+            .addTo(blastFurnaceRecipes);
+
+        // InPO4 + Ga(OH)3 = InGaP
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                indiumPhosphate.get(OrePrefixes.dust, 6),
+                galliumHydroxide.get(OrePrefixes.dust, 7),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.IndiumGalliumPhosphide, 3))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_ULV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Ball.get(0))
+            .fluidInputs(naquadahGoo.getFluidOrGas(72))
+            .itemOutputs(ItemRefer.Naquadah_Mass.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Ball.get(0))
+            .fluidInputs(enrichedNaquadahGoo.getFluidOrGas(72))
+            .itemOutputs(ItemRefer.Enriched_Naquadah_Mass.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Ball.get(0))
+            .fluidInputs(naquadriaGoo.getFluidOrGas(72))
+            .itemOutputs(ItemRefer.Naquadria_Mass.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Naquadah_Mass.get(1))
+            .itemOutputs(naquadahEarth.get(OrePrefixes.dust, 1), enrichedNaquadahEarth.get(OrePrefixes.dust, 1))
+            .outputChances(10000, 100)
+            .duration(5 * SECONDS)
+            .eut(2)
+            .addTo(maceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Enriched_Naquadah_Mass.get(1))
+            .itemOutputs(enrichedNaquadahEarth.get(OrePrefixes.dust, 1), naquadriaEarth.get(OrePrefixes.dust, 1))
+            .outputChances(10000, 100)
+            .duration(5 * SECONDS)
+            .eut(2)
+            .addTo(maceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Naquadria_Mass.get(1))
+            .itemOutputs(naquadriaEarth.get(OrePrefixes.dust, 1), naquadriaEarth.get(OrePrefixes.dust, 1))
+            .outputChances(10000, 100)
+            .duration(5 * SECONDS)
+            .eut(2)
+            .addTo(maceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.block, Materials.SiliconSG, 16),
+                naquadahine.get(OrePrefixes.dust, 3),
+                ItemList.GalliumArsenideCrystal.get(1L))
+            .fluidInputs(Materials.Argon.getGas(8000))
+            .itemOutputs(ItemList.Circuit_Silicon_Ingot3.get(1))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .metadata(COIL_HEAT, 4484)
+            .addTo(blastFurnaceRecipes);
+
+        // NqO2 + 4Na = 2Na2O + Nq
+        GT_Values.RA.stdBuilder()
+            .itemInputs(naquadahine.get(OrePrefixes.dust, 3), Materials.Sodium.getDust(4))
+            .itemOutputs(Materials.Naquadah.getDust(1), Materials.SodiumOxide.getDust(6))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(UniversalChemical);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(naquadahEarth.get(OrePrefixes.dust, 2), GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(Materials.Nitrogen.getGas(1000))
+            .itemOutputs(Materials.Naquadah.getNuggets(1))
+            .duration(2 * MINUTES)
+            .eut(TierEU.RECIPE_IV)
+            .metadata(COIL_HEAT, 5000)
+            .addTo(blastFurnaceRecipes);
+
+        // C2H4 + H2O(g) = C2H6O
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(24))
+            .fluidInputs(Materials.Ethylene.getGas(1000), FluidRegistry.getFluidStack("steam", 2000))
+            .fluidOutputs(Materials.Ethanol.getFluid(1000))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Ethylene.getCells(1), GT_Utility.getIntegratedCircuit(24))
+            .fluidInputs(FluidRegistry.getFluidStack("steam", 2000))
+            .itemOutputs(Materials.Ethanol.getCells(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(chemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadah, 1))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadah, 1))
+            .duration(16 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(vacuumFreezerRecipes);
+    }
+
+    public static void SmallRecipeChange() {
+
+        GT_Recipe tRecipe;
+
+        tRecipe = RecipeMaps.chemicalReactorRecipes.findRecipe(
+            null,
+            false,
+            1 << 30,
+            new FluidStack[] { Materials.SulfuricAcid.getFluid(500) },
+            GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Platinum, 16),
+            ItemList.Empty_Board_Elite.get(2));
+        if (tRecipe != null) {
+            RecipeMaps.chemicalReactorRecipes.getBackend()
+                .removeRecipe(tRecipe);
+            GT_Recipe tRecipe2 = tRecipe.copy();
+            tRecipe2.mInputs = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 8),
+                ItemList.Empty_Board_Elite.get(2) };
+            RecipeMaps.chemicalReactorRecipes.add(tRecipe2);
+            RecipeMaps.chemicalReactorRecipes.getBackend()
+                .reInit();
+        }
+
+        tRecipe = RecipeMaps.multiblockChemicalReactorRecipes.findRecipe(
+            null,
+            false,
+            1 << 30,
+            new FluidStack[] { Materials.SulfuricAcid.getFluid(500) },
+            GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Platinum, 16),
+            ItemList.Empty_Board_Elite.get(2));
+        if (tRecipe != null) {
+            RecipeMaps.multiblockChemicalReactorRecipes.getBackend()
+                .removeRecipe(tRecipe);
+            GT_Recipe tRecipe2 = tRecipe.copy();
+            tRecipe2.mInputs = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 8),
+                ItemList.Empty_Board_Elite.get(2) };
+            RecipeMaps.multiblockChemicalReactorRecipes.add(tRecipe2);
+            RecipeMaps.multiblockChemicalReactorRecipes.getBackend()
+                .reInit();
+        }
+
+        tRecipe = RecipeMaps.assemblerRecipes.findRecipe(
+            null,
+            false,
+            1 << 30,
+            new FluidStack[] { Materials.Polybenzimidazole.getMolten(36) },
+            GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Polybenzimidazole, 2),
+            GT_OreDictUnificator.get(OrePrefixes.foil, Materials.HSSS, 1),
+            GT_Utility.getIntegratedCircuit(1));
+        if (tRecipe != null) {
+            RecipeMaps.assemblerRecipes.getBackend()
+                .removeRecipe(tRecipe);
+            GT_Recipe tRecipe2 = tRecipe.copy();
+            tRecipe2.mInputs = new ItemStack[] {
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Polybenzimidazole, 2),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.NaquadahEnriched, 1) };
+            RecipeMaps.assemblerRecipes.add(tRecipe2);
+            RecipeMaps.assemblerRecipes.getBackend()
+                .reInit();
+        }
+    }
+
+    public static void Remover() {
+
+        if (!EnableNaquadahRework) return;
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Begin to remove pure Naquadah, Enriched Naquadah and Naquadria.\n");
+
+        HashSet<GT_Recipe> remove = new HashSet<>(5000);
+        HashSet<GT_Recipe> reAdd = new HashSet<>(5000);
+
+        // For Crusher
+        for (GT_Recipe recipe : RecipeMaps.maceratorRecipes.getAllRecipes()) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if ((OreDictionary.getOreName(oreDictID)
+                        .startsWith("ore")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("rawOre")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("crushed"))
+                        && OreDictionary.getOreName(oreDictID)
+                            .contains("Naq")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        boolean modified = false;
+                        for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            }
+                        }
+                        if (modified) {
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        RecipeMaps.maceratorRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.maceratorRecipes::add);
+        RecipeMaps.maceratorRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Crusher done!\n");
+
+        // For Washer
+        for (GT_Recipe recipe : RecipeMaps.oreWasherRecipes.getAllRecipes()) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID)
+                        .startsWith("crushed")
+                        && OreDictionary.getOreName(oreDictID)
+                            .contains("Naq")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        boolean modified = false;
+                        for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            }
+                        }
+                        if (modified) {
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        RecipeMaps.oreWasherRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.oreWasherRecipes::add);
+        RecipeMaps.oreWasherRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Washer done!\n");
+
+        // For Thermal Centrifuge
+        for (GT_Recipe recipe : RecipeMaps.thermalCentrifugeRecipes.getAllRecipes()) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID)
+                        .startsWith("crushed")
+                        && OreDictionary.getOreName(oreDictID)
+                            .contains("Naq")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        boolean modified = false;
+                        for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            }
+                        }
+                        if (modified) {
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        RecipeMaps.thermalCentrifugeRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.thermalCentrifugeRecipes::add);
+        RecipeMaps.thermalCentrifugeRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Thermal Centrifuge done!\n");
+
+        // For Centrifuge
+        for (GT_Recipe recipe : RecipeMaps.centrifugeRecipes.getAllRecipes()) {
+            ItemStack input = null;
+            if (recipe.mInputs.length > 0) input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                if (input.isItemEqual(GT_Bees.combs.getStackForType(CombType.DOB))) {
+                    GT_Recipe tRecipe = recipe.copy();
+                    boolean modified = false;
+                    for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                        if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                        if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) {
+                            tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                tRecipe.mOutputs[i].stackSize * 2L,
+                                naquadahEarth.get(OrePrefixes.dustTiny, 1));
+                            modified = true;
+                        }
+                    }
+                    if (modified) {
+                        reAdd.add(tRecipe);
+                        remove.add(recipe);
+                    }
+                } else for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID)
+                        .startsWith("dustPureNaq")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustImpureNaq")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustSpace")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustNaq")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        boolean modified = false;
+                        for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dustTiny, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dustTiny, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dustTiny, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dustSmall, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dustSmall, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dustSmall, 1));
+                                modified = true;
+                            }
+                        }
+                        if (modified) {
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        RecipeMaps.centrifugeRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.centrifugeRecipes::add);
+        RecipeMaps.centrifugeRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Centrifuge done!\n");
+
+        // For Centrifuge (PA)
+        for (GT_Recipe recipe : RecipeMaps.centrifugeNonCellRecipes.getAllRecipes()) {
+            ItemStack input = null;
+            if (recipe.mInputs.length > 0) input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                if (input.isItemEqual(GT_Bees.combs.getStackForType(CombType.DOB))) {
+                    GT_Recipe tRecipe = recipe.copy();
+                    boolean modified = false;
+                    for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                        if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                        if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) {
+                            tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                tRecipe.mOutputs[i].stackSize * 2L,
+                                naquadahEarth.get(OrePrefixes.dustTiny, 1));
+                            modified = true;
+                        }
+                    }
+                    if (modified) {
+                        reAdd.add(tRecipe);
+                        remove.add(recipe);
+                    }
+                } else for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID)
+                        .startsWith("dustPureNaq")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustImpureNaq")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustSpace")
+                        || OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustNaq")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        boolean modified = false;
+                        for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dustTiny, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dustTiny, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dustTiny, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dustSmall, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dustSmall, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dustSmall, 1));
+                                modified = true;
+                            }
+                        }
+                        if (modified) {
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        RecipeMaps.centrifugeNonCellRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.centrifugeNonCellRecipes::add);
+        RecipeMaps.centrifugeNonCellRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Centrifuge (PA) done!\n");
+
+        // For Hammer
+        for (GT_Recipe recipe : RecipeMaps.hammerRecipes.getAllRecipes()) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID)
+                        .startsWith("crushed")
+                        && OreDictionary.getOreName(oreDictID)
+                            .contains("Naq")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        boolean modified = false;
+                        for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                    tRecipe.mOutputs[i].stackSize * 2,
+                                    naquadriaEarth.get(OrePrefixes.dust, 1));
+                                modified = true;
+                            }
+                        }
+                        if (modified) {
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        RecipeMaps.hammerRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.hammerRecipes::add);
+        RecipeMaps.hammerRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Hammer done!\n");
+
+        // For Chemical Reactor
+        for (GT_Recipe recipe : RecipeMaps.chemicalReactorRecipes.getAllRecipes()) {
+            if (recipe.mFluidOutputs == null) continue;
+            boolean isAny = false;
+            for (int i = 0; i < recipe.mFluidOutputs.length; i++) {
+                if (recipe.mFluidOutputs[i] == null) continue;
+                if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1))
+                    || recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))
+                    || recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) {
+                    isAny = true;
+                    break;
+                }
+            }
+            if (!isAny) continue;
+            GT_Recipe tRecipe = recipe.copy();
+            boolean modified = false;
+            for (int i = 0; i < recipe.mFluidOutputs.length; i++) {
+                if (recipe.mFluidOutputs[i] == null) continue;
+                if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1))) {
+                    tRecipe.mFluidOutputs[i] = naquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2);
+                    modified = true;
+                } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))) {
+                    tRecipe.mFluidOutputs[i] = enrichedNaquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2);
+                    modified = true;
+                } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) {
+                    tRecipe.mFluidOutputs[i] = naquadriaGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2);
+                    modified = true;
+                }
+            }
+            if (modified) {
+                reAdd.add(tRecipe);
+                remove.add(recipe);
+            }
+        }
+        RecipeMaps.chemicalReactorRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.chemicalReactorRecipes::add);
+        RecipeMaps.chemicalReactorRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Chemical Reactor done!\n");
+
+        // For Multi Chemical Reactor
+        for (GT_Recipe recipe : RecipeMaps.multiblockChemicalReactorRecipes.getAllRecipes()) {
+            if (recipe.mFluidOutputs == null) continue;
+            boolean isAny = false;
+            for (int i = 0; i < recipe.mFluidOutputs.length; i++) {
+                if (recipe.mFluidOutputs[i] == null) continue;
+                if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1))
+                    || recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))
+                    || recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) {
+                    isAny = true;
+                    break;
+                }
+            }
+            if (!isAny) continue;
+            GT_Recipe tRecipe = recipe.copy();
+            boolean modified = false;
+            for (int i = 0; i < recipe.mFluidOutputs.length; i++) {
+                if (recipe.mFluidOutputs[i] == null) continue;
+                if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1))) {
+                    tRecipe.mFluidOutputs[i] = naquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2);
+                    modified = true;
+                } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))) {
+                    tRecipe.mFluidOutputs[i] = enrichedNaquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2);
+                    modified = true;
+                } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) {
+                    tRecipe.mFluidOutputs[i] = naquadriaGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2);
+                    modified = true;
+                }
+            }
+            if (modified) {
+                reAdd.add(tRecipe);
+                remove.add(recipe);
+            }
+        }
+        RecipeMaps.multiblockChemicalReactorRecipes.getBackend()
+            .removeRecipes(remove);
+        reAdd.forEach(RecipeMaps.multiblockChemicalReactorRecipes::add);
+        RecipeMaps.multiblockChemicalReactorRecipes.getBackend()
+            .reInit();
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Multi Chemical Reactor done!\n");
+
+        if (GTPlusPlus.isModLoaded()) {
+            // For Gt++ Multi Centrifuge
+            // Apparently NEI will break down if one modifies the hash list directly.
+            // GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.mRecipeList.clear();
+            // RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells(
+            // RecipeMaps.centrifugeRecipes,
+            // GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT);
+            // GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.reInit();
+
+            // For Simple Washer
+            for (GT_Recipe recipe : GTPPRecipeMaps.simpleWasherRecipes.getAllRecipes()) {
+                ItemStack input = recipe.mInputs[0];
+                if (GT_Utility.isStackValid(input)) {
+                    int[] oreDict = OreDictionary.getOreIDs(input);
+                    for (int oreDictID : oreDict) {
+                        if (OreDictionary.getOreName(oreDictID)
+                            .startsWith("dustImpureNaq")
+                            || OreDictionary.getOreName(oreDictID)
+                                .startsWith("dustPureNaq")) {
+                            GT_Recipe tRecipe = recipe.copy();
+                            boolean modified = false;
+                            for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                                if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                                if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                    tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                        tRecipe.mOutputs[i].stackSize,
+                                        naquadahEarth.get(OrePrefixes.dust, 1));
+                                    modified = true;
+                                } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) {
+                                    tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                        tRecipe.mOutputs[i].stackSize,
+                                        enrichedNaquadahEarth.get(OrePrefixes.dust, 1));
+                                    modified = true;
+                                } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) {
+                                    tRecipe.mOutputs[i] = GT_Utility.copyAmount(
+                                        tRecipe.mOutputs[i].stackSize,
+                                        naquadriaEarth.get(OrePrefixes.dust, 1));
+                                    modified = true;
+                                }
+                            }
+                            if (modified) {
+                                reAdd.add(tRecipe);
+                                remove.add(recipe);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            GTPPRecipeMaps.simpleWasherRecipes.getBackend()
+                .removeRecipes(remove);
+            reAdd.forEach(GTPPRecipeMaps.simpleWasherRecipes::add);
+            GTPPRecipeMaps.simpleWasherRecipes.getBackend()
+                .reInit();
+
+            GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! ");
+
+            remove.clear();
+            reAdd.clear();
+
+            GT_Log.out.print("Simple Washer done!\n");
+        }
+
+        // For Cauldron Wash
+        registerCauldronCleaningFor(Materials.Naquadah, naquadahEarth.getBridgeMaterial());
+        registerCauldronCleaningFor(Materials.NaquadahEnriched, enrichedNaquadahEarth.getBridgeMaterial());
+        registerCauldronCleaningFor(Materials.Naquadria, naquadriaEarth.getBridgeMaterial());
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace 3! ");
+        GT_Log.out.print("Cauldron Wash done!\n");
+
+        // For Crafting Table
+        CraftingManager.getInstance()
+            .getRecipeList()
+            .forEach(NaquadahReworkRecipeLoader::replaceInCraftTable);
+
+        GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace Unknown! ");
+        GT_Log.out.print("Crafting Table done!\n");
+    }
+
+    // I don't understand. . .
+    // I use and copy some private methods in Bartworks because his system runs well.
+    // Bartworks is under MIT License
+    /*
+     * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a
+     * copy of this software and associated documentation files (the "Software"), to deal in the Software without
+     * restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
+     * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+     * subject to the following conditions: The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+     * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+     * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+     * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+     * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+     */
+    public static void replaceInCraftTable(Object obj) {
+
+        Constructor<?> cs = null;
+        PlatinumSludgeOverHaul BartObj = null;
+        try {
+            cs = PlatinumSludgeOverHaul.class.getDeclaredConstructor();
+            cs.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+
+        if (cs == null) return;
+
+        try {
+            BartObj = (PlatinumSludgeOverHaul) cs.newInstance();
+        } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+
+        Method recipeCheck = null;
+
+        try {
+            recipeCheck = PlatinumSludgeOverHaul.class.getDeclaredMethod("checkRecipe", Object.class, Materials.class);
+            recipeCheck.setAccessible(true);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        String inputName = "output";
+        String inputItemName = "input";
+        if (!(obj instanceof ShapedOreRecipe || obj instanceof ShapelessOreRecipe)) {
+            if (obj instanceof ShapedRecipes || (obj instanceof ShapelessRecipes)) {
+                inputName = "recipeOutput";
+                inputItemName = "recipeItems";
+            }
+        }
+        IRecipe recipe = (IRecipe) obj;
+        ItemStack result = recipe.getRecipeOutput();
+
+        Field out = FieldUtils.getDeclaredField(recipe.getClass(), inputName, true);
+        if (out == null) out = FieldUtils.getField(recipe.getClass(), inputName, true);
+
+        Field in = FieldUtils.getDeclaredField(recipe.getClass(), inputItemName, true);
+        if (in == null) in = FieldUtils.getField(recipe.getClass(), inputItemName, true);
+        if (in == null) return;
+
+        // this part here is NOT MIT LICENSED BUT LICSENSED UNDER THE Apache License, Version 2.0!
+        try {
+            if (Modifier.isFinal(in.getModifiers())) {
+                // Do all JREs implement Field with a private ivar called "modifiers"?
+                Field modifiersField = Field.class.getDeclaredField("modifiers");
+                boolean doForceAccess = !modifiersField.isAccessible();
+                if (doForceAccess) {
+                    modifiersField.setAccessible(true);
+                }
+                try {
+                    modifiersField.setInt(in, in.getModifiers() & ~Modifier.FINAL);
+                } finally {
+                    if (doForceAccess) {
+                        modifiersField.setAccessible(false);
+                    }
+                }
+            }
+        } catch (NoSuchFieldException ignored) {
+            // The field class contains always a modifiers field
+        } catch (IllegalAccessException ignored) {
+            // The modifiers field is made accessible
+        }
+        // END OF APACHE COMMONS COLLECTION COPY
+
+        Object input;
+        try {
+            input = in.get(obj);
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return;
+        }
+
+        if (out == null || recipeCheck == null) return;
+
+        if (GT_Utility.areStacksEqual(result, Materials.Naquadah.getDust(1), true)) {
+
+            recipeCheck.setAccessible(true);
+            boolean isOk = true;
+
+            try {
+                isOk = (boolean) recipeCheck.invoke(BartObj, input, Materials.Naquadah);
+            } catch (InvocationTargetException | IllegalAccessException ignored) {}
+
+            if (isOk) return;
+            try {
+                out.set(recipe, naquadahEarth.get(OrePrefixes.dust, 2));
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        } else if (GT_Utility.areStacksEqual(result, Materials.NaquadahEnriched.getDust(1), true)) {
+
+            recipeCheck.setAccessible(true);
+            boolean isOk = true;
+
+            try {
+                isOk = (boolean) recipeCheck.invoke(BartObj, input, Materials.NaquadahEnriched);
+            } catch (InvocationTargetException | IllegalAccessException ignored) {}
+
+            if (isOk) return;
+            try {
+                out.set(recipe, enrichedNaquadahEarth.get(OrePrefixes.dust, 2));
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        } else if (GT_Utility.areStacksEqual(result, Materials.Naquadria.getDust(1), true)) {
+
+            recipeCheck.setAccessible(true);
+            boolean isOk = true;
+
+            try {
+                isOk = (boolean) recipeCheck.invoke(BartObj, input, Materials.Naquadria);
+            } catch (InvocationTargetException | IllegalAccessException ignored) {}
+
+            if (isOk) return;
+            try {
+                out.set(recipe, naquadriaEarth.get(OrePrefixes.dust, 2));
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/NeutronActivatorLoader.java b/goodgen/src/main/java/goodgenerator/loader/NeutronActivatorLoader.java
new file mode 100644
index 0000000000..353277dc1f
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/NeutronActivatorLoader.java
@@ -0,0 +1,46 @@
+package goodgenerator.loader;
+
+import static goodgenerator.items.MyMaterial.*;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+
+public class NeutronActivatorLoader {
+
+    public static void NARecipeLoad() {
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            new FluidStack[] { thoriumBasedLiquidFuelExcited.getFluidOrGas(200) },
+            null,
+            new FluidStack[] { thoriumBasedLiquidFuelDepleted.getFluidOrGas(200) },
+            null,
+            10000,
+            700,
+            500);
+
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            new FluidStack[] { uraniumBasedLiquidFuel.getFluidOrGas(100) },
+            new ItemStack[] {
+                GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tungsten, 1)) },
+            new FluidStack[] { uraniumBasedLiquidFuelExcited.getFluidOrGas(100) },
+            null,
+            80,
+            550,
+            450);
+
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            new FluidStack[] { plutoniumBasedLiquidFuel.getFluidOrGas(100) },
+            new ItemStack[] {
+                GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tritanium, 1)) },
+            new FluidStack[] { plutoniumBasedLiquidFuelExcited.getFluidOrGas(100) },
+            null,
+            80,
+            600,
+            500);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/RecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader.java
new file mode 100644
index 0000000000..0c7ae0e60f
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader.java
@@ -0,0 +1,1466 @@
+package goodgenerator.loader;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
+import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes;
+import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes;
+import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes;
+import static gregtech.api.recipe.RecipeMaps.compressorRecipes;
+import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes;
+import static gregtech.api.recipe.RecipeMaps.extruderRecipes;
+import static gregtech.api.recipe.RecipeMaps.formingPressRecipes;
+import static gregtech.api.recipe.RecipeMaps.fusionRecipes;
+import static gregtech.api.recipe.RecipeMaps.implosionRecipes;
+import static gregtech.api.recipe.RecipeMaps.mixerRecipes;
+import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes;
+import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.HOURS;
+import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+import static gregtech.api.util.GT_RecipeConstants.ADDITIVE_AMOUNT;
+import static gregtech.api.util.GT_RecipeConstants.AssemblyLine;
+import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT;
+import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE;
+import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE;
+import static gregtech.api.util.GT_RecipeConstants.FUSION_THRESHOLD;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME;
+import static gregtech.api.util.GT_RecipeConstants.UniversalChemical;
+import static gregtech.loaders.postload.GT_MachineRecipeLoader.solderingMats;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+
+import goodgenerator.items.MyMaterial;
+import goodgenerator.util.CrackRecipeAdder;
+import goodgenerator.util.ItemRefer;
+import goodgenerator.util.MaterialFix;
+import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SubTag;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_RecipeConstants;
+import gregtech.api.util.GT_Utility;
+
+public class RecipeLoader {
+
+    public static void RecipeLoad() {
+
+        // Radiation Protection Plate
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 8L),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 8L),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Lead.getMolten(1152))
+            .itemOutputs(ItemRefer.Radiation_Protection_Plate.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lanthanum, 4L),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 8L),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Lead.getMolten(1152))
+            .itemOutputs(ItemRefer.Radiation_Protection_Plate.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null
+            ? FluidRegistry.getFluid("molten.indalloy140")
+            : FluidRegistry.getFluid("molten.solderingalloy");
+
+        // LNR Controller
+        GT_Values.RA.stdBuilder()
+            .metadata(
+                RESEARCH_ITEM,
+                ItemList.Generator_Naquadah_Mark_III.get(1)
+                    .copy())
+            .metadata(RESEARCH_TIME, 1 * HOURS + 24 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Adamantium, 8),
+                ItemRefer.Radiation_Protection_Plate.get(16),
+                ItemList.Field_Generator_ZPM.get(2),
+                ItemList.Electric_Pump_ZPM.get(8),
+                new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4 },
+                GT_OreDictUnificator.get(OrePrefixes.wireGt08, Materials.SuperconductorLuV, 8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.Naquadah, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 8),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmium, 16))
+            .fluidInputs(
+                Materials.Trinium.getMolten(576),
+                new FluidStack(solderIndalloy, 4608),
+                Materials.Lubricant.getFluid(8000))
+            .itemOutputs(ItemRefer.Large_Naquadah_Reactor.get(1))
+            .eut(TierEU.RECIPE_ZPM)
+            .duration(13 * MINUTES + 30 * SECONDS)
+            .addTo(AssemblyLine);
+
+        // LNR Casing
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Radiation_Protection_Plate.get(6),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Europium, 1),
+                ItemList.Field_Generator_MV.get(1),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(ItemRefer.Field_Restriction_Casing.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        // LNR Frame
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.NaquadahAlloy, 8),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.HSSE, 4),
+                GT_Utility.getIntegratedCircuit(24))
+            .itemOutputs(ItemRefer.Radiation_Proof_Steel_Frame_Box.get(1))
+            .duration(16 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        // Uranium Liquid Fuel Process Line
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.graphiteUraniumMixture.get(OrePrefixes.dust, 4),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.TungstenCarbide, 2),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(ItemRefer.Wrapped_Uranium_Ingot.get(1))
+            .duration(1 * MINUTES + 10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Wrapped_Uranium_Ingot.get(4))
+            .itemOutputs(
+                ItemRefer.High_Density_Uranium_Nugget.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.TungstenCarbide, 8))
+            .duration(1 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .metadata(ADDITIVE_AMOUNT, 8)
+            .addTo(implosionRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.High_Density_Uranium_Nugget.get(9))
+            .itemOutputs(ItemRefer.High_Density_Uranium.get(1))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(compressorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.High_Density_Uranium.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Potassium, 8),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quantium, 4),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Radon.getGas(1000L))
+            .fluidOutputs(MyMaterial.uraniumBasedLiquidFuel.getFluidOrGas(1000))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_LuV / 2)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .fluidInputs(MyMaterial.uraniumBasedLiquidFuel.getFluidOrGas(10), Materials.Hydrogen.getGas(100L))
+            .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(10))
+            .duration(2 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .metadata(FUSION_THRESHOLD, 200000000)
+            .addTo(fusionRecipes);
+
+        // Thorium Liquid Process Line
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.uraniumCarbideThoriumMixture.get(OrePrefixes.dust, 64),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.TungstenSteel, 4),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(ItemRefer.Wrapped_Thorium_Ingot.get(1))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Wrapped_Thorium_Ingot.get(1))
+            .itemOutputs(
+                ItemRefer.High_Density_Thorium_Nugget.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.TungstenSteel, 8))
+            .duration(1 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .metadata(ADDITIVE_AMOUNT, 4)
+            .addTo(implosionRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.High_Density_Thorium_Nugget.get(9))
+            .itemOutputs(ItemRefer.High_Density_Thorium.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(compressorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.High_Density_Thorium.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Draconium, 2),
+                GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(Materials.Mercury.getFluid(1000L))
+            .fluidOutputs(MyMaterial.thoriumBasedLiquidFuel.getFluidOrGas(4000))
+            .duration(2 * MINUTES + 30 * SECONDS)
+            .eut(TierEU.RECIPE_HV / 2)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.thoriumBasedLiquidFuel.get(OrePrefixes.cell, 1), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Helium.getPlasma(250L))
+            .itemOutputs(MyMaterial.thoriumBasedLiquidFuelExcited.get(OrePrefixes.cell, 1))
+            .duration(6 * SECONDS)
+            .eut(TierEU.RECIPE_IV / 2)
+            .addTo(mixerRecipes);
+
+        // Liquid Plutonium Process Line
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.plutoniumOxideUraniumMixture.get(OrePrefixes.dust, 8),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.HSSS, 4),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(ItemRefer.Wrapped_Plutonium_Ingot.get(1))
+            .duration(1 * MINUTES + 30 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Wrapped_Plutonium_Ingot.get(2))
+            .itemOutputs(
+                ItemRefer.High_Density_Plutonium_Nugget.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.HSSS, 8))
+            .duration(1 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .metadata(ADDITIVE_AMOUNT, 16)
+            .addTo(implosionRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.High_Density_Plutonium_Nugget.get(9))
+            .itemOutputs(ItemRefer.High_Density_Plutonium.get(1))
+            .duration(1 * MINUTES)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(compressorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.High_Density_Plutonium.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neutronium, 8),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Caesium, 16),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 2),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuel.getFluidOrGas(1000))
+            .duration(18 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .fluidInputs(Materials.Lutetium.getMolten(16), MyMaterial.plutoniumBasedLiquidFuel.getFluidOrGas(20))
+            .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(20))
+            .duration(1 * SECONDS)
+            .eut(TierEU.RECIPE_LuV / 2)
+            .metadata(FUSION_THRESHOLD, 220000000)
+            .addTo(fusionRecipes);
+
+        // Th-232
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sugar, 24),
+                MyMaterial.vanadiumPentoxide.get(OrePrefixes.dust, 0),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(FluidRegistry.getFluidStack("nitricacid", 6000))
+            .fluidOutputs(MyMaterial.oxalate.getFluidOrGas(3000), Materials.NitricOxide.getGas(6000))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        // Th + 2O = ThO2
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1))
+            .fluidInputs(Materials.Oxygen.getGas(2000))
+            .itemOutputs(WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 3))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .metadata(COIL_HEAT, 1200)
+            .addTo(blastFurnaceRecipes);
+
+        // Th + 8HNO3 =HF= Th(NO3)4 + 4NO2 + 4H2O
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Thorium.getDust(1))
+            .fluidInputs(Materials.HydrofluoricAcid.getFluid(100), FluidRegistry.getFluidStack("nitricacid", 8000))
+            .fluidOutputs(MyMaterial.thoriumNitrate.getFluidOrGas(1000), Materials.NitrogenDioxide.getGas(4000))
+            .duration(2 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        // 4NaOH + Th(NO3)4 = Th(OH)4 + 4NaNO3
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1), Materials.SodiumHydroxide.getDust(12))
+            .fluidInputs(MyMaterial.thoriumNitrate.getFluidOrGas(1000))
+            .itemOutputs(
+                MyMaterial.thoriumHydroxide.get(OrePrefixes.dust, 9),
+                WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 20))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(UniversalChemical);
+
+        // 2 NaNO3 + H2SO4 = Na2SO4 + 2HNO3
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1), WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 10))
+            .fluidInputs(Materials.SulfuricAcid.getFluid(1000))
+            .fluidOutputs(Materials.NitricAcid.getFluid(2000))
+            .itemOutputs(WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 7))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(UniversalChemical);
+
+        // Th(OH)4 + 4HF = ThF4 + 4H2O
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.thoriumHydroxide.get(OrePrefixes.dust, 9), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.HydrofluoricAcid.getFluid(4000))
+            .fluidOutputs(MyMaterial.thoriumTetrafluoride.getFluidOrGas(1000))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        // Zn + 2Cl = ZnCl2
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Zinc, 1),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Chlorine.getGas(2000))
+            .itemOutputs(MyMaterial.zincChloride.get(OrePrefixes.dust, 3))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        // ZnCl2 + 3Ca + ThF4 = ZnTh + CaCl2 + 2CaF2
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.zincChloride.get(OrePrefixes.dust, 3), Materials.Calcium.getDust(3))
+            .fluidInputs(MyMaterial.thorium232Tetrafluoride.getFluidOrGas(1000))
+            .fluidOutputs(WerkstoffLoader.CalciumChloride.getFluidOrGas(3000))
+            .itemOutputs(
+                MyMaterial.zincThoriumAlloy.get(OrePrefixes.ingot, 1),
+                WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 6))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .metadata(COIL_HEAT, 3000)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.zincThoriumAlloy.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(11))
+            .fluidInputs(Materials.Argon.getGas(250))
+            .fluidOutputs(Materials.Zinc.getMolten(144))
+            .itemOutputs(WerkstoffLoader.Thorium232.get(OrePrefixes.dust, 1))
+            .duration(7 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_HV)
+            .metadata(COIL_HEAT, 1900)
+            .addTo(blastFurnaceRecipes);
+
+        // 2V + 5O = V2O5
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Vanadium, 2),
+                GT_Utility.getIntegratedCircuit(24))
+            .fluidInputs(Materials.Oxygen.getGas(5000))
+            .itemOutputs(MyMaterial.vanadiumPentoxide.get(OrePrefixes.dust, 7))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .metadata(COIL_HEAT, 2500)
+            .addTo(blastFurnaceRecipes);
+
+        // Atomic Separation Catalyst
+        ItemStack[] mat1 = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blaze, 32),
+            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Firestone, 4) };
+        ItemStack[] mat2 = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Draconium, 4),
+            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quantium, 4), };
+        ItemStack[] mat3 = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Ardite, 4),
+            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Manyullyn, 4) };
+
+        for (ItemStack m1 : mat1) {
+            for (ItemStack m2 : mat2) {
+                for (ItemStack m3 : mat3) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(m1, m2, m3, GT_Utility.getIntegratedCircuit(4))
+                        .fluidInputs(Materials.Naquadah.getMolten(288))
+                        .itemOutputs(ItemRefer.Raw_Atomic_Separation_Catalyst.get(63))
+                        .duration(15 * SECONDS)
+                        .eut(TierEU.RECIPE_HV)
+                        .addTo(mixerRecipes);
+                }
+            }
+        }
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                WerkstoffLoader.Tiberium.get(OrePrefixes.plate, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 8))
+            .itemOutputs(MyMaterial.orundum.get(OrePrefixes.plate, 1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_IV / 2)
+            .addTo(formingPressRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.orundum.get(OrePrefixes.plate, 2), ItemRefer.Raw_Atomic_Separation_Catalyst.get(4))
+            .fluidInputs(Materials.Plutonium.getMolten(144))
+            .itemOutputs(MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.ingotHot, 1))
+            .duration(3 * MINUTES)
+            .eut(TierEU.RECIPE_HV)
+            .metadata(COIL_HEAT, 5000)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.ingotHot, 1))
+            .itemOutputs(MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.ingot, 1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(vacuumFreezerRecipes);
+
+        CrackRecipeAdder.crackerAdder(
+            MyMaterial.naquadahGas.getFluidOrGas(1000),
+            MyMaterial.atomicSeparationCatalyst.getMolten(4),
+            new FluidStack[] { Materials.Helium.getGas(300), WerkstoffLoader.Neon.getFluidOrGas(50),
+                Materials.Argon.getGas(80), WerkstoffLoader.Krypton.getFluidOrGas(20),
+                WerkstoffLoader.Xenon.getFluidOrGas(40), Materials.Radon.getGas(14000) },
+            GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadah, 1),
+            6,
+            4020,
+            300);
+
+        CrackRecipeAdder.crackerAdder(
+            MyMaterial.lightNaquadahFuel.getFluidOrGas(1000),
+            MyMaterial.atomicSeparationCatalyst.getMolten(4),
+            new FluidStack[] { Materials.Radon.getGas(1400), MyMaterial.naquadahGas.getFluidOrGas(400),
+                Materials.Uranium.getMolten(648), MyMaterial.heavyNaquadahFuel.getFluidOrGas(280),
+                Materials.Plutonium.getMolten(576), MyMaterial.naquadahAsphalt.getFluidOrGas(140) },
+            GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Uranium235, 1),
+            6,
+            4020,
+            450);
+
+        CrackRecipeAdder.crackerAdder(
+            MyMaterial.heavyNaquadahFuel.getFluidOrGas(1000),
+            MyMaterial.atomicSeparationCatalyst.getMolten(6),
+            new FluidStack[] { Materials.Radon.getGas(1000), MyMaterial.naquadahGas.getFluidOrGas(450),
+                MyMaterial.lightNaquadahFuel.getFluidOrGas(560), Materials.Uranium.getMolten(720),
+                Materials.Lutetium.getMolten(648), MyMaterial.naquadahAsphalt.getFluidOrGas(240) },
+            GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plutonium, 1),
+            6,
+            4020,
+            500);
+
+        CrackRecipeAdder.crackerAdder(
+            MyMaterial.naquadahAsphalt.getFluidOrGas(1000),
+            MyMaterial.atomicSeparationCatalyst.getMolten(12),
+            new FluidStack[] { MyMaterial.lightNaquadahFuel.getFluidOrGas(600), Materials.Uranium.getMolten(1152),
+                Materials.Thorium.getMolten(864), Materials.Plutonium.getMolten(792), Materials.Thulium.getMolten(216),
+                MyMaterial.heavyNaquadahFuel.getFluidOrGas(350) },
+            GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadria, 1),
+            6,
+            4020,
+            800);
+
+        // 2C2H6O =H2SO4= C4H10O + H2O
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(Materials.Ethanol.getFluid(1000), Materials.SulfuricAcid.getFluid(1000))
+            .fluidOutputs(MyMaterial.ether.getFluidOrGas(500), Materials.DilutedSulfuricAcid.getFluid(1500))
+            .duration(25 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.GasolineRaw.getCells(9), Materials.Ethanol.getCells(1))
+            .itemOutputs(MyMaterial.ethanolGasoline.get(OrePrefixes.cell, 10))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(UniversalChemical);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ether.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 537)
+            .metadata(FUEL_TYPE, 0)
+            .addTo(GT_RecipeConstants.Fuel);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ether.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 537)
+            .metadata(FUEL_TYPE, 1)
+            .addTo(GT_RecipeConstants.Fuel);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ethanolGasoline.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 1100)
+            .metadata(FUEL_TYPE, 0)
+            .addTo(GT_RecipeConstants.Fuel);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.cyclopentadiene.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 70)
+            .metadata(FUEL_TYPE, 1)
+            .addTo(GT_RecipeConstants.Fuel);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ironedFuel.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 2248)
+            .metadata(FUEL_TYPE, 0)
+            .addTo(GT_RecipeConstants.Fuel);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ironedKerosene.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 1824)
+            .metadata(FUEL_TYPE, 0)
+            .addTo(GT_RecipeConstants.Fuel);
+
+        // Sb + 3Cl = SbCl3
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Antimony, 1))
+            .fluidInputs(MyMaterial.ether.getFluidOrGas(1000), Materials.Chlorine.getGas(3000))
+            .fluidOutputs(MyMaterial.antimonyTrichloride.getFluidOrGas(1000))
+            .duration(3 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        // SbCl3 + 2Cl = SbCl5
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.antimonyTrichloride.getFluidOrGas(1000), Materials.Chlorine.getGas(2000))
+            .fluidOutputs(MyMaterial.antimonyPentachlorideSolution.getFluidOrGas(1000))
+            .duration(9 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            MyMaterial.antimonyPentachlorideSolution.getFluidOrGas(1000),
+            new FluidStack[] { MyMaterial.ether.getFluidOrGas(1000),
+                MyMaterial.antimonyPentachloride.getFluidOrGas(1000) },
+            GT_Values.NI,
+            30 * SECONDS,
+            TierEU.RECIPE_MV);
+
+        // SbCl5 + 5HF = SbF5 + 5HCl
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(
+                MyMaterial.antimonyPentachloride.getFluidOrGas(1000),
+                Materials.HydrofluoricAcid.getFluid(5000))
+            .fluidOutputs(
+                MyMaterial.antimonyPentafluoride.getFluidOrGas(1000),
+                Materials.HydrochloricAcid.getFluid(5000))
+            .duration(21 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        // SbH5 + HF = HSbF6
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(
+                MyMaterial.antimonyPentafluoride.getFluidOrGas(1000),
+                Materials.HydrofluoricAcid.getFluid(1000))
+            .fluidOutputs(MyMaterial.fluoroantimonicAcid.getFluidOrGas(1000))
+            .duration(42 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NaquadahEnriched, 16),
+                GT_Utility.getIntegratedCircuit(16))
+            .fluidInputs(Materials.HydrofluoricAcid.getFluid(3000))
+            .fluidOutputs(MyMaterial.acidNaquadahEmulsion.getFluidOrGas(2000))
+            .itemOutputs(MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 3))
+            .duration(3 * MINUTES)
+            .eut(TierEU.RECIPE_EV)
+            .metadata(COIL_HEAT, 3400)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(3),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 8))
+            .fluidInputs(MyMaterial.acidNaquadahEmulsion.getFluidOrGas(1000))
+            .fluidOutputs(MyMaterial.naquadahEmulsion.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.AntimonyTrioxide, 1),
+                WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 4))
+            .duration(12 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            MyMaterial.naquadahSolution.getFluidOrGas(20),
+            new FluidStack[] { MyMaterial.naquadahAsphalt.getFluidOrGas(2),
+                MyMaterial.heavyNaquadahFuel.getFluidOrGas(5), MyMaterial.lightNaquadahFuel.getFluidOrGas(10),
+                FluidRegistry.getFluidStack("water", 10), MyMaterial.naquadahGas.getFluidOrGas(60) },
+            GT_Values.NI,
+            1 * SECONDS,
+            TierEU.RECIPE_EV);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.naquadahGas.get(OrePrefixes.cell))
+            .metadata(FUEL_VALUE, 1024)
+            .metadata(FUEL_TYPE, 1)
+            .addTo(GT_RecipeConstants.Fuel);
+
+        GT_Values.RA.stdBuilder()
+            .fluidInputs(
+                MyMaterial.lightNaquadahFuel.getFluidOrGas(780),
+                MyMaterial.heavyNaquadahFuel.getFluidOrGas(360))
+            .fluidOutputs(MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(100))
+            .duration(25 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .metadata(FUSION_THRESHOLD, 320000000)
+            .addTo(fusionRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NetherStar, 4),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.ElectrumFlux, 32))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(100), MyMaterial.naquadahGas.getFluidOrGas(1500))
+            .fluidOutputs(MyMaterial.naquadahBasedFuelMkII.getFluidOrGas(100))
+            .duration(25 * SECONDS)
+            .eut(TierEU.RECIPE_UHV / 2)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 32),
+                GT_Utility.getIntegratedCircuit(16))
+            .fluidInputs(MyMaterial.fluoroantimonicAcid.getFluidOrGas(4000))
+            .fluidOutputs(MyMaterial.acidNaquadahEmulsion.getFluidOrGas(8000))
+            .itemOutputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 17))
+            .duration(3 * MINUTES)
+            .eut(TierEU.RECIPE_IV / 2)
+            .metadata(COIL_HEAT, 3400)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(
+                RESEARCH_ITEM,
+                ItemList.Generator_Naquadah_Mark_V.get(1)
+                    .copy())
+            .metadata(RESEARCH_TIME, 7 * HOURS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmiridium, 8),
+                ItemRefer.Advanced_Radiation_Protection_Plate.get(64),
+                ItemList.Field_Generator_UV.get(8),
+                ItemList.Electric_Pump_UHV.get(2),
+                new Object[] { OrePrefixes.circuit.get(Materials.Bio), 4 },
+                GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.MysteriousCrystal, 8),
+                ItemList.Circuit_Wafer_NPIC.get(16),
+                ItemList.UHV_Coil.get(64),
+                new Object[] { "craftingLensYellow", 16 },
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Thulium, 64))
+            .fluidInputs(
+                Materials.Quantium.getMolten(9216L),
+                Materials.DraconiumAwakened.getMolten(4608L),
+                MyMaterial.extremelyUnstableNaquadah.getMolten(1440),
+                new FluidStack(solderIndalloy, 14400))
+            .itemOutputs(ItemRefer.Naquadah_Fuel_Refinery.get(1))
+            .eut(TierEU.RECIPE_UHV)
+            .duration(30 * MINUTES)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Radiation_Protection_Plate.get(1))
+            .metadata(RESEARCH_TIME, 1 * HOURS + 7 * MINUTES)
+            .itemInputs(
+                ItemRefer.Radiation_Protection_Plate.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ElectrumFlux, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Trinium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Osmiridium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VibrantAlloy, 4),
+                ItemRefer.Radiation_Protection_Plate.get(1))
+            .fluidInputs(new FluidStack(solderIndalloy, 1152))
+            .itemOutputs(ItemRefer.Advanced_Radiation_Protection_Plate.get(1))
+            .eut(TierEU.RECIPE_ZPM / 2)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Casing.get(1))
+            .metadata(RESEARCH_TIME, 3 * HOURS + 30 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Thulium, 1),
+                ItemRefer.Advanced_Radiation_Protection_Plate.get(6),
+                ItemList.Field_Generator_IV.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.pipeTiny, Materials.Naquadah, 16),
+                GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.NaquadahAlloy, 32),
+                GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.NaquadahAlloy, 32),
+                GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Manyullyn, 32),
+                GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Manyullyn, 32),
+                MyMaterial.orundum.get(OrePrefixes.plate, 4))
+            .fluidInputs(Materials.TungstenSteel.getMolten(1152), new FluidStack(solderIndalloy, 2304))
+            .itemOutputs(ItemRefer.Naquadah_Fuel_Refinery_Casing.get(1))
+            .eut(TierEU.RECIPE_ZPM / 2)
+            .duration(25 * SECONDS)
+            .addTo(AssemblyLine);
+
+        if (NewHorizonsCoreMod.isModLoaded()) {
+            GT_Values.RA.stdBuilder()
+                .metadata(RESEARCH_ITEM, MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingot))
+                .metadata(RESEARCH_TIME, 4 * HOURS + 10 * MINUTES)
+                .itemInputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmium, 1),
+                    ItemList.Field_Generator_UV.get(2),
+                    ItemList.Electric_Pump_UV.get(8),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorZPM, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorZPM, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Americium, 8),
+                    GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.BlackPlutonium, 16),
+                    ItemList.Circuit_Wafer_PPIC.get(32),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Infinite), 1L })
+                .fluidInputs(
+                    WerkstoffLoader.Krypton.getFluidOrGas(1000),
+                    Materials.ElectrumFlux.getMolten(9216),
+                    Materials.Lubricant.getFluid(128000))
+                .itemOutputs(ItemRefer.Field_Restriction_Coil_T1.get(1))
+                .eut(TierEU.RECIPE_ZPM)
+                .duration(15 * MINUTES)
+                .addTo(AssemblyLine);
+
+            GT_Values.RA.stdBuilder()
+                .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Coil_T1.get(1))
+                .metadata(RESEARCH_TIME, 4 * HOURS + 50 * MINUTES)
+                .itemInputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1),
+                    ItemList.Field_Generator_UHV.get(2),
+                    ItemList.Electric_Pump_UHV.get(8),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorUV, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorUV, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 8),
+                    GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Neutronium, 16),
+                    ItemList.Circuit_Wafer_PPIC.get(48),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1L })
+                .fluidInputs(
+                    Materials.Radon.getPlasma(1000),
+                    Materials.DraconiumAwakened.getMolten(9216),
+                    Materials.Lubricant.getFluid(128000))
+                .itemOutputs(ItemRefer.Field_Restriction_Coil_T2.get(1))
+                .eut(TierEU.RECIPE_ZPM)
+                .duration(30 * MINUTES)
+                .addTo(AssemblyLine);
+
+            GT_Values.RA.stdBuilder()
+                .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Coil_T2.get(1))
+                .metadata(RESEARCH_TIME, 5 * HOURS + 30 * MINUTES)
+                .itemInputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1),
+                    ItemList.Field_Generator_UEV.get(2),
+                    ItemList.Electric_Pump_UEV.get(8),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUHV, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUHV, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 8),
+                    GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Infinity, 16),
+                    ItemList.Circuit_Wafer_PPIC.get(64),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1L })
+                .fluidInputs(
+                    WerkstoffLoader.Oganesson.getFluidOrGas(1000),
+                    Materials.Neutronium.getMolten(9216),
+                    Materials.Lubricant.getFluid(128000))
+                .itemOutputs(ItemRefer.Field_Restriction_Coil_T3.get(1))
+                .eut(TierEU.RECIPE_ZPM)
+                .duration(1 * HOURS)
+                .addTo(AssemblyLine);
+
+            GT_Values.RA.stdBuilder()
+                .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Coil_T3.get(1))
+                .metadata(RESEARCH_TIME, 7 * HOURS)
+                .itemInputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1),
+                    ItemList.Field_Generator_UIV.get(2),
+                    ItemList.Electric_Pump_UIV.get(8),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUEV, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUEV, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 8),
+                    GT_OreDictUnificator.get(OrePrefixes.pipeMedium, MaterialsUEVplus.SpaceTime, 16),
+                    ItemList.Circuit_Wafer_PPIC.get(64),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1L })
+                .fluidInputs(
+                    MyMaterial.metastableOganesson.getMolten(1000),
+                    MaterialsUEVplus.TranscendentMetal.getMolten(9216),
+                    Materials.Lubricant.getFluid(128000))
+                .itemOutputs(ItemRefer.Field_Restriction_Coil_T4.get(1))
+                .eut(TierEU.RECIPE_ZPM)
+                .duration(2 * HOURS)
+                .addTo(AssemblyLine);
+        }
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BorosilicateGlass, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ReinforceGlass, 6),
+                GT_OreDictUnificator.get(OrePrefixes.ring, Materials.NaquadahAlloy, 32),
+                ItemList.Field_Generator_HV.get(4),
+                GT_Utility.getIntegratedCircuit(6))
+            .fluidInputs(Materials.Naquadria.getMolten(288))
+            .itemOutputs(ItemRefer.Field_Restriction_Glass.get(1))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .addTo(assemblerRecipes);
+
+        // Ca + O = CaO
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 1))
+            .fluidInputs(Materials.Oxygen.getGas(1000))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 2))
+            .duration(10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        // AlN = Al + N
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Aluminum_Nitride_Dust.get(2))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 1))
+            .fluidOutputs(Materials.Nitrogen.getGas(1000L))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(electrolyzerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Aluminum_Nitride_Dust.get(4),
+                WerkstoffLoader.YttriumOxide.get(OrePrefixes.dust, 5),
+                GT_Utility.getIntegratedCircuit(9))
+            .fluidInputs(FluidRegistry.getFluidStack("advancedglue", 1000))
+            .itemOutputs(ItemRefer.Special_Ceramics_Dust.get(9))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Aluminum_Nitride_Dust.get(4),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Uraninite, 5),
+                GT_Utility.getIntegratedCircuit(9))
+            .fluidInputs(FluidRegistry.getFluidStack("advancedglue", 1000))
+            .itemOutputs(ItemRefer.Special_Ceramics_Dust.get(9))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Special_Ceramics_Dust.get(2), ItemList.Shape_Extruder_Plate.get(0L))
+            .itemOutputs(ItemRefer.Special_Ceramics_Plate.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(extruderRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Raw_Cylinder.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "PPP", "PFP", "PPP", 'P', ItemRefer.Special_Ceramics_Plate.get(1), 'F',
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1) });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Raw_Cylinder.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Titanium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 6),
+                GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(ItemRefer.Titanium_Plated_Cylinder.get(1))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(16),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 2))
+            .fluidInputs(FluidRegistry.getFluidStack("liquidoxygen", 1000), Materials.NitrogenDioxide.getGas(1000))
+            .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 500))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(16), WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 2))
+            .fluidInputs(FluidRegistry.getFluidStack("liquidoxygen", 1000), Materials.NitrogenDioxide.getGas(1000))
+            .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 500))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        if (GTPlusPlus.isModLoaded()) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    GT_Utility.getIntegratedCircuit(16),
+                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 2))
+                .fluidInputs(
+                    FluidRegistry.getFluidStack("fluid.hydrogenperoxide", 1000),
+                    Materials.NitrogenDioxide.getGas(1000))
+                .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 2000))
+                .duration(10 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(multiblockChemicalReactorRecipes);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(16), WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 2))
+                .fluidInputs(
+                    FluidRegistry.getFluidStack("fluid.hydrogenperoxide", 1000),
+                    Materials.NitrogenDioxide.getGas(1000))
+                .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 2000))
+                .duration(10 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(multiblockChemicalReactorRecipes);
+        }
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Universal_Chemical_Fuel_Engine.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "TZT", "ALB", "WGW", 'T',
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 1), 'Z', "circuitUltimate", 'A',
+                ItemList.Machine_Multi_DieselEngine.get(1), 'B', ItemList.Machine_Multi_ExtremeDieselEngine.get(1), 'L',
+                ItemList.Hull_LuV, 'W', GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 1), 'G',
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Osmium, 1), });
+
+        // neutron activator
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.stick, Materials.PolyvinylChloride, 4),
+                GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Plastic, 4),
+                GT_Utility.getIntegratedCircuit(8))
+            .fluidInputs(FluidRegistry.getFluidStack("dye.chemical.dyecyan", 144))
+            .itemOutputs(ItemRefer.Plastic_Case.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.stick, Materials.PolyvinylChloride, 4),
+                GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Plastic, 4),
+                GT_Utility.getIntegratedCircuit(8))
+            .fluidInputs(FluidRegistry.getFluidStack("dye.watermixed.dyecyan", 144))
+            .itemOutputs(ItemRefer.Plastic_Case.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(assemblerRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Plastic_Case.get(1),
+            new Object[] { "PCP", "CDC", "PCP", 'P',
+                GT_OreDictUnificator.get(OrePrefixes.stick, Materials.PolyvinylChloride, 1), 'C',
+                GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Plastic, 1), 'D', "dyeCyan" });
+
+        MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+            new ItemStack[] { ItemList.Circuit_Board_Coated_Basic.get(1), ItemList.Circuit_Chip_ULPIC.get(1),
+                ItemList.ULV_Coil.get(2), ItemList.Battery_RE_ULV_Tantalum.get(1) },
+            new FluidStack[] { Materials.RedAlloy.getMolten(144), Materials.Aluminium.getMolten(144) },
+            ItemRefer.Micro_Heater.get(1),
+            120,
+            40,
+            1);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Quartzite, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 4))
+            .fluidInputs(Materials.Water.getFluid(1000))
+            .itemOutputs(ItemRefer.Quartz_Wafer.get(1))
+            .outputChances(3333)
+            .requiresCleanRoom()
+            .duration(5 * MINUTES)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(autoclaveRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Quartzite, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 4))
+            .fluidInputs(FluidRegistry.getFluidStack("ic2distilledwater", 1000))
+            .itemOutputs(ItemRefer.Quartz_Wafer.get(1))
+            .requiresCleanRoom()
+            .duration(1 * MINUTES + 15 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(autoclaveRecipes);
+
+        MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+            new ItemStack[] { ItemRefer.Quartz_Wafer.get(1), ItemRefer.Special_Ceramics_Plate.get(2),
+                ItemRefer.Micro_Heater.get(1), ItemList.Circuit_Chip_ILC.get(4) },
+            new FluidStack[] { Materials.EnergeticAlloy.getMolten(72), Materials.Silver.getMolten(18) },
+            ItemRefer.Quartz_Crystal_Resonator.get(1),
+            480,
+            40,
+            1);
+
+        for (Materials tMat : solderingMats) {
+            int tMultiplier = tMat.contains(SubTag.SOLDERING_MATERIAL_GOOD) ? 1
+                : tMat.contains(SubTag.SOLDERING_MATERIAL_BAD) ? 4 : 2;
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemRefer.Quartz_Crystal_Resonator.get(2),
+                    ItemRefer.Plastic_Case.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Good, 1),
+                    ItemList.Cover_Screen.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.componentCircuit, Materials.Diode, 16L),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8))
+                .fluidInputs(tMat.getMolten(144 * tMultiplier))
+                .itemOutputs(ItemRefer.Inverter.get(1))
+                .duration(12 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(assemblerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemRefer.Quartz_Crystal_Resonator.get(2),
+                    ItemRefer.Plastic_Case.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Good, 1),
+                    ItemList.Cover_Screen.get(1),
+                    ItemList.Circuit_Parts_DiodeASMD.get(4),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8))
+                .fluidInputs(tMat.getMolten(144 * tMultiplier))
+                .itemOutputs(ItemRefer.Inverter.get(1))
+                .duration(12 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(assemblerRecipes);
+            if (NewHorizonsCoreMod.isModLoaded()) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(
+                        ItemList.Circuit_Board_Multifiberglass_Elite.get(1),
+                        GT_ModHandler.getModItem("dreamcraft", "item.EngravedGoldChip", 16),
+                        ItemList.Circuit_Chip_SoC2.get(8),
+                        ItemList.Circuit_Chip_NOR.get(32),
+                        MyMaterial.signalium.get(OrePrefixes.bolt, 32),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8),
+                        GT_ModHandler.getIC2Item("reactorVent", 1L, 1))
+                    .fluidInputs(tMat.getMolten(288 * tMultiplier))
+                    .itemOutputs(ItemRefer.HiC_T1.get(1))
+                    .duration(1 * MINUTES)
+                    .eut(TierEU.RECIPE_IV)
+                    .addTo(assemblerRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(
+                        ItemList.Circuit_Board_Multifiberglass_Elite.get(1),
+                        GT_ModHandler.getModItem("dreamcraft", "item.EngravedGoldChip", 16),
+                        ItemList.Circuit_Chip_SoC2.get(8),
+                        ItemList.Circuit_Chip_NOR.get(32),
+                        MyMaterial.signalium.get(OrePrefixes.bolt, 32),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8),
+                        GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.TinAlloy, 1))
+                    .fluidInputs(tMat.getMolten(288 * tMultiplier))
+                    .itemOutputs(ItemRefer.HiC_T1.get(1))
+                    .duration(1 * MINUTES)
+                    .eut(TierEU.RECIPE_IV)
+                    .addTo(assemblerRecipes);
+            }
+        }
+
+        GT_ModHandler.addCraftingRecipe(
+            Loaders.NeutronAccelerators[0].copy(),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "WPM", "CHI", "WPM", 'W', GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Lead, 1),
+                'P', GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lead, 1), 'M',
+                GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Lead, 1), 'C',
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Wood, 1), 'H', ItemList.Hull_ULV, 'I',
+                ItemRefer.Inverter.get(1), });
+
+        GT_ModHandler.addCraftingRecipe(
+            Loaders.NeutronAccelerators[1].copy(),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "WPM", "CHI", "WPM", 'W', GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Tin, 1),
+                'P', GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Lead, 1), 'M',
+                ItemList.Electric_Motor_LV, 'C', "plateAnyRubber", 'H', ItemList.Hull_LV, 'I',
+                ItemRefer.Inverter.get(1), });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Inverter.get(1),
+                ItemList.Hull_MV.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.AnyCopper, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Plastic, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Beryllium, 2),
+                ItemList.Electric_Motor_MV.get(2))
+            .itemOutputs(Loaders.NeutronAccelerators[2].copy())
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Inverter.get(1),
+                ItemList.Hull_HV.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Gold, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.PolyvinylChloride, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Beryllium, 2),
+                ItemList.Electric_Motor_HV.get(2))
+            .itemOutputs(Loaders.NeutronAccelerators[3].copy())
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Loaders.NeutronAccelerators[5].copy())
+            .metadata(RESEARCH_TIME, 16 * MINUTES)
+            .itemInputs(
+                ItemRefer.Inverter.get(2),
+                ItemList.Hull_LuV.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.YttriumBariumCuprate, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NetherStar, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Polybenzimidazole, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NeodymiumMagnetic, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NeodymiumMagnetic, 4),
+                ItemList.Electric_Motor_LuV.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorMV, 4))
+            .fluidInputs(Materials.Argon.getGas(3000))
+            .itemOutputs(Loaders.NeutronAccelerators[6].copy())
+            .eut(TierEU.RECIPE_LuV)
+            .duration(15 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Loaders.NeutronAccelerators[6].copy())
+            .metadata(RESEARCH_TIME, 16 * MINUTES)
+            .itemInputs(
+                ItemRefer.Inverter.get(2),
+                ItemList.Hull_ZPM.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.VanadiumGallium, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NetherStar, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Polybenzimidazole, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.SamariumMagnetic, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.SamariumMagnetic, 4),
+                ItemList.Electric_Motor_ZPM.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorEV, 4))
+            .fluidInputs(WerkstoffLoader.Xenon.getFluidOrGas(3000))
+            .itemOutputs(Loaders.NeutronAccelerators[7].copy())
+            .eut(TierEU.RECIPE_ZPM)
+            .duration(15 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, Loaders.NeutronAccelerators[7].copy())
+            .metadata(RESEARCH_TIME, 16 * MINUTES)
+            .itemInputs(
+                ItemRefer.Inverter.get(4),
+                ItemList.Hull_UV.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.NaquadahAlloy, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NetherStar, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plateTriple, Materials.Polybenzimidazole, 4),
+                ItemList.ZPM_Coil.get(4),
+                GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.NickelZincFerrite, 16),
+                ItemList.ZPM_Coil.get(4),
+                ItemList.Electric_Motor_UV.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorLuV, 4))
+            .fluidInputs(WerkstoffLoader.Oganesson.getFluidOrGas(3000))
+            .itemOutputs(Loaders.NeutronAccelerators[8].copy())
+            .eut(TierEU.RECIPE_UV)
+            .duration(15 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Casing_IV.get(1L),
+                ItemList.Cover_ActivityDetector.get(1L),
+                ItemList.Cover_Screen.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VibrantAlloy, 4),
+                GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 1),
+                ItemList.Sensor_HV.get(2),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Helium.getGas(1000))
+            .itemOutputs(Loaders.NS.copy())
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Neutron_Source.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { " P ", "PUP", " P ", 'P',
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Steel, 1), 'U',
+                ItemRefer.High_Density_Uranium.get(1) });
+
+        MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+            new ItemStack[] { ItemRefer.HiC_T2.get(2), ItemList.Emitter_EV.get(2), ItemRefer.Neutron_Source.get(1) },
+            new FluidStack[] { Materials.StainlessSteel.getMolten(576), Materials.TungstenCarbide.getMolten(144) },
+            Loaders.NA.copy(),
+            7680,
+            100,
+            1);
+    }
+
+    public static void InitLoadRecipe() {
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Inverter.get(1),
+                ItemList.Hull_EV.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Aluminium, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.StyreneButadieneRubber, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.IronMagnetic, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.TungstenCarbide, 2),
+                ItemList.Electric_Motor_EV.get(2))
+            .itemOutputs(Loaders.NeutronAccelerators[4].copy())
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Inverter.get(1),
+                ItemList.Hull_IV.get(1L),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Tungsten, 2),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicone, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.SteelMagnetic, 4),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.TungstenCarbide, 2),
+                ItemList.Electric_Motor_IV.get(2))
+            .itemOutputs(Loaders.NeutronAccelerators[5].copy())
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        // Al2O3 + 2N + 3C = 2AlN + 3CO
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sapphire, 5),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 3))
+            .fluidInputs(FluidRegistry.getFluidStack("liquidnitrogen", 2000))
+            .fluidOutputs(Materials.CarbonMonoxide.getGas(3000))
+            .itemOutputs(ItemRefer.Aluminum_Nitride_Dust.get(2))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .metadata(COIL_HEAT, 4600)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.GreenSapphire, 5),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 3))
+            .fluidInputs(FluidRegistry.getFluidStack("liquidnitrogen", 2000))
+            .fluidOutputs(Materials.CarbonMonoxide.getGas(3000))
+            .itemOutputs(ItemRefer.Aluminum_Nitride_Dust.get(2))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .metadata(COIL_HEAT, 4600)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminiumoxide, 5),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 3))
+            .fluidInputs(FluidRegistry.getFluidStack("liquidnitrogen", 2000))
+            .fluidOutputs(Materials.CarbonMonoxide.getGas(3000))
+            .itemOutputs(ItemRefer.Aluminum_Nitride_Dust.get(2))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .metadata(COIL_HEAT, 4600)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 1),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingotHot))
+            .duration(6 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .metadata(COIL_HEAT, 7000)
+            .addTo(blastFurnaceRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingotHot, 1))
+            .itemOutputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingot, 1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(vacuumFreezerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkVIDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1))
+            .outputChances(1000, 500, 400, 50, 20, 5)
+            .fluidOutputs(MyMaterial.metastableOganesson.getMolten(122))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkVDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1))
+            .outputChances(1000, 500, 400, 50, 20, 5)
+            .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(182))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkIVDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 32))
+            .outputChances(9900, 9500, 9000, 8000, 5000, 3000)
+            .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(864))
+            .duration(2 * MINUTES + 5 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkIIIDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 32))
+            .outputChances(9500, 9000, 8000, 7000, 5000, 4000)
+            .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(720))
+            .duration(1 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkIIDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Americium, 32),
+                WerkstoffLoader.Californium.get(OrePrefixes.dust, 32))
+            .outputChances(9000, 8500, 5000, 4000, 2000)
+            .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(144))
+            .duration(6 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lead, 16L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bismuth, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Barium, 6L))
+            .outputChances(6000, 1000, 5000)
+            .fluidOutputs(WerkstoffLoader.Xenon.getFluidOrGas(10))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_EV / 2)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.thoriumBasedLiquidFuelDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                WerkstoffLoader.Thorium232.get(OrePrefixes.dust, 64),
+                WerkstoffLoader.Thorium232.get(OrePrefixes.dust, 16),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Praseodymium, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Praseodymium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Boron, 2),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Indium, 4))
+            .outputChances(10000, 8000, 10000, 8000, 3000, 5000)
+            .duration(1 * MINUTES + 15 * SECONDS)
+            .eut(TierEU.RECIPE_EV / 2)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 9),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cerium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gold, 2))
+            .outputChances(5000, 8000, 7500)
+            .fluidOutputs(WerkstoffLoader.Krypton.getFluidOrGas(144))
+            .duration(2 * MINUTES + 5 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.thoriumTetrafluoride.getFluidOrGas(1000))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Thorium, 1))
+            .fluidOutputs(MyMaterial.thorium232Tetrafluoride.getFluidOrGas(750))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahEmulsion.getFluidOrGas(1000))
+            .itemOutputs(
+                MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 4),
+                MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 2),
+                MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1),
+                MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1),
+                MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1),
+                MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1))
+            .outputChances(8000, 7500, 5000, 2000, 500, 100)
+            .fluidOutputs(MyMaterial.naquadahSolution.getFluidOrGas(500))
+            .duration(40 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.naquadahBasedFuelMkIDepleted.getFluidOrGas(1000))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 48),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neodymium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Europium, 32))
+            .outputChances(9000, 8500, 5000, 4000, 2000)
+            .fluidOutputs(WerkstoffLoader.Xenon.getFluidOrGas(144))
+            .duration(5 * MINUTES)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 4))
+            .itemOutputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 2),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Uranium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Plutonium, 1),
+                WerkstoffLoader.Tiberium.get(OrePrefixes.dust, 1))
+            .outputChances(10000, 9500, 8000, 2500, 2000, 2000)
+            .fluidOutputs(Materials.Radon.getGas(20))
+            .duration(45 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(centrifugeRecipes);
+    }
+
+    public static void Fixer() {
+        MaterialFix.MaterialFluidExtractionFix(MyMaterial.atomicSeparationCatalyst);
+        MaterialFix.MaterialFluidExtractionFix(MyMaterial.extremelyUnstableNaquadah);
+        MaterialFix.MaterialFluidExtractionFix(MyMaterial.metastableOganesson);
+        MaterialFix.MaterialFluidExtractionFix(MyMaterial.shirabon);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/loader/RecipeLoader_02.java b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader_02.java
new file mode 100644
index 0000000000..70517fe781
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader_02.java
@@ -0,0 +1,1772 @@
+package goodgenerator.loader;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
+import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes;
+import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes;
+import static gregtech.api.recipe.RecipeMaps.cannerRecipes;
+import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes;
+import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes;
+import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes;
+import static gregtech.api.recipe.RecipeMaps.distilleryRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidCannerRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.fusionRecipes;
+import static gregtech.api.recipe.RecipeMaps.mixerRecipes;
+import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes;
+import static gregtech.api.recipe.RecipeMaps.plasmaForgeRecipes;
+import static gregtech.api.recipe.RecipeMaps.unpackagerRecipes;
+import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.HOURS;
+import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeConstants.AssemblyLine;
+import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT;
+import static gregtech.api.util.GT_RecipeConstants.FUSION_THRESHOLD;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME;
+import static gregtech.api.util.GT_RecipeConstants.UniversalChemical;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+import com.github.technus.tectech.recipe.TT_recipeAdder;
+
+import goodgenerator.items.MyMaterial;
+import goodgenerator.util.CrackRecipeAdder;
+import goodgenerator.util.ItemRefer;
+import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.item.chemistry.GenericChem;
+import gtPlusPlus.core.material.ALLOY;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+import ic2.core.Ic2Items;
+
+public class RecipeLoader_02 {
+
+    public static void RecipeLoad() {
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.StainlessSteel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlueAlloy, 1),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorHV, 32),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Beryllium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Elite, 1))
+            .itemOutputs(ItemRefer.Speeding_Pipe.get(1))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        // Compact MK1 Fusion Disassembly Recipe
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Compact_Fusion_Coil_T0.get(1))
+            .itemOutputs(ItemList.Casing_Coil_Superconductor.get(3))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .addTo(assemblerRecipes);
+
+        // Compact MK2 Fusion Disassembly Recipe
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Compact_Fusion_Coil_T1.get(1))
+            .itemOutputs(ItemList.Casing_Fusion_Coil.get(3))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UV)
+            .addTo(assemblerRecipes);
+
+        // Compact MK3 Fusion Disassembly Recipe
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Compact_Fusion_Coil_T2.get(1))
+            .itemOutputs(ItemList.Casing_Fusion_Coil.get(3))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UHV)
+            .addTo(assemblerRecipes);
+
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy2, 500, 480, 2800, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy2, 513, 480, 2800, false);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy4, 500, 480, 2800, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy4, 513, 480, 2800, false);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.incoloy903, 2400, 1920, 3700, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.adamantiumAlloy, 2500, 1920, 5500, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.marM200, 200, 7680, 5000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.marM200, 220, 7680, 5000, false);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.signalium, 1600, 30720, 4000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.lumiium, 1600, 30720, 4000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.artheriumSn, 500, 122880, 6500, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.titaniumBetaC, 400, 7680, 5300, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.dalisenite, 800, 491520, 8700, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.hikarium, 1200, 30720, 5400, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.tairitsu, 1200, 1966080, 7400, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.preciousMetalAlloy, 2400, 7864320, 10000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.enrichedNaquadahAlloy, 2400, 7864320, 11000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.metastableOganesson, 600, 7864320, 12000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.shirabon, 600, 31457280, 13000, true);
+        CrackRecipeAdder.reAddBlastRecipe(MyMaterial.atomicSeparationCatalyst, 35000, 120, 5000, false);
+
+        GT_ModHandler.removeFurnaceSmelting(MyMaterial.dalisenite.get(OrePrefixes.dust)); // :doom:
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.dalisenite.get(OrePrefixes.ingotHot, 1))
+            .itemOutputs(MyMaterial.dalisenite.get(OrePrefixes.ingot, 1))
+            .duration(16 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(vacuumFreezerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.shirabon.get(OrePrefixes.ingotHot, 1))
+            .itemOutputs(MyMaterial.shirabon.get(OrePrefixes.ingot, 1))
+            .duration(2 * MINUTES)
+            .eut(TierEU.RECIPE_UHV)
+            .addTo(vacuumFreezerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.zircaloy4.get(OrePrefixes.plate, 4),
+                MyMaterial.zircaloy2.get(OrePrefixes.ring, 2),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1), ItemRefer.High_Density_Uranium.get(1))
+            .itemOutputs(ItemRefer.Fuel_Rod_U_1.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(cannerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_U_1.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fuel_Rod_U_2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_U_2.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(ItemRefer.Fuel_Rod_U_4.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_U_1.get(4),
+                MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6),
+                GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(ItemRefer.Fuel_Rod_U_4.get(1))
+            .duration(11 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1), ItemRefer.High_Density_Plutonium.get(1))
+            .itemOutputs(ItemRefer.Fuel_Rod_Pu_1.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(cannerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_Pu_1.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fuel_Rod_Pu_2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_Pu_2.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(ItemRefer.Fuel_Rod_Pu_4.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_Pu_1.get(4),
+                MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6),
+                GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(ItemRefer.Fuel_Rod_Pu_4.get(1))
+            .duration(11 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.YOTTank_Casing.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "BPB", "FOF", "BPB", 'B',
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.BlackSteel, 1), 'P',
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.StainlessSteel, 1), 'F',
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Polytetrafluoroethylene, 1), 'O',
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlackSteel, 1), });
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.YOTTank.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "SPS", "ECE", "SLS", 'S',
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.BlueSteel, 1), 'P', ItemList.Cover_Screen.get(1),
+                'E', "circuitData", 'L', GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Enderium, 1), 'C',
+                ItemRefer.YOTTank_Casing.get(1) });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Hatch_Output_IV.get(1),
+                GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiPart", 1, 440),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CertusQuartz, 8),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Plastic.getMolten(144))
+            .itemOutputs(Loaders.YFH)
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Large_Fluid_Cell_Steel.get(12L),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.Tin, 4),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Plastic.getMolten(144))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T1.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Large_Fluid_Cell_Aluminium.get(3L),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.Tin, 4),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Plastic.getMolten(144))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T1.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Large_Fluid_Cell_StainlessSteel.get(2L),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.Tin, 4),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Plastic.getMolten(144))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T1.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Large_Fluid_Cell_Titanium.get(64L),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 8),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.BlackSteel, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Large_Fluid_Cell_TungstenSteel.get(18L),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.BlackSteel, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Large_Fluid_Cell_Chrome.get(4L),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.BlackSteel, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fluid_Storage_Core_T1.get(32),
+                ItemRefer.Fluid_Storage_Core_T1.get(32),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.BlackSteel, 16),
+                GT_Utility.getIntegratedCircuit(10))
+            .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null
+            ? FluidRegistry.getFluid("molten.indalloy140")
+            : FluidRegistry.getFluid("molten.solderingalloy");
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T2.get(1))
+            .metadata(RESEARCH_TIME, 17 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.StainlessSteel, 4),
+                ItemList.Electric_Pump_HV.get(8),
+                ItemList.Quantum_Tank_LV.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmium, 8),
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 1L, 6),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Polycaprolactam, 32))
+            .fluidInputs(new FluidStack(solderIndalloy, 2304), Materials.Lubricant.getFluid(4000))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T3.get(1))
+            .eut(TierEU.RECIPE_LuV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T3.get(1))
+            .metadata(RESEARCH_TIME, 34 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Titanium, 4),
+                ItemList.Electric_Pump_EV.get(8),
+                ItemList.Quantum_Tank_LV.get(4),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Europium, 8),
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 4L, 6),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.StyreneButadieneRubber, 64),
+                GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.TungstenSteel, 64))
+            .fluidInputs(new FluidStack(solderIndalloy, 18432), Materials.Lubricant.getFluid(16000))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T4.get(1))
+            .eut(TierEU.RECIPE_ZPM)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T4.get(1))
+            .metadata(RESEARCH_TIME, 1 * HOURS + 8 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.MysteriousCrystal, 4),
+                ItemList.Electric_Pump_IV.get(8),
+                ItemList.Quantum_Tank_HV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Neutronium, 8),
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 16L, 6),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.Polycaprolactam, 24),
+                GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.Titanium, 64))
+            .fluidInputs(
+                Materials.Draconium.getMolten(2304),
+                Materials.Titanium.getMolten(288),
+                Materials.Lubricant.getFluid(64000))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T5.get(1))
+            .eut(TierEU.RECIPE_UV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T5.get(1))
+            .metadata(RESEARCH_TIME, 2 * HOURS + 15 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 4),
+                ItemList.Electric_Pump_LuV.get(8),
+                ItemList.Quantum_Tank_EV.get(16),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 16),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 16),
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6),
+                ItemList.Machine_IV_Compressor.get(64))
+            .fluidInputs(
+                Materials.Draconium.getMolten(2304),
+                Materials.Titanium.getMolten(288),
+                Materials.Lubricant.getFluid(64000))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T6.get(1))
+            .eut(TierEU.RECIPE_UHV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T6.get(1))
+            .metadata(RESEARCH_TIME, 4 * HOURS + 30 * MINUTES)
+            .itemInputs(
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6),
+                ItemList.Electric_Pump_ZPM.get(8),
+                GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 1L, 0),
+                ItemList.Quantum_Tank_EV.get(32),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 8),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.InfinityCatalyst, 8),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 16))
+            .fluidInputs(
+                Materials.Draconium.getMolten(23040),
+                new FluidStack(solderIndalloy, 2304),
+                Materials.InfinityCatalyst.getMolten(1140))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T7.get(1))
+            .eut(TierEU.RECIPE_UEV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T7.get(1))
+            .metadata(RESEARCH_TIME, 9 * HOURS)
+            .itemInputs(
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6),
+                ItemList.Electric_Pump_UV.get(8),
+                GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 2L, 0),
+                ItemList.Quantum_Tank_EV.get(64),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 16),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.Infinity, 24),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 16))
+            .fluidInputs(
+                Materials.Draconium.getMolten(36864),
+                new FluidStack(solderIndalloy, 30240),
+                Materials.InfinityCatalyst.getMolten(5670))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T8.get(1))
+            .eut(TierEU.RECIPE_UIV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T8.get(1))
+            .metadata(RESEARCH_TIME, 180 * HOURS)
+            .itemInputs(
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6),
+                ItemList.Electric_Pump_UHV.get(8),
+                GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 2L, 0),
+                ItemList.Quantum_Tank_IV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 32),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.Infinity, 36),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 8))
+            .fluidInputs(
+                Materials.Draconium.getMolten(36864),
+                new FluidStack(solderIndalloy, 30240),
+                MaterialsUEVplus.TranscendentMetal.getMolten(1440),
+                Materials.InfinityCatalyst.getMolten(5670))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T9.get(1))
+            .eut(TierEU.RECIPE_UMV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T9.get(1))
+            .metadata(RESEARCH_TIME, 360 * HOURS)
+            .itemInputs(
+                GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6),
+                ItemList.Electric_Pump_UEV.get(8),
+                GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 4L, 0),
+                ItemList.Quantum_Tank_IV.get(16),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 32),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.CosmicNeutronium, 24),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, MaterialsUEVplus.SpaceTime, 4))
+            .fluidInputs(
+                Materials.Draconium.getMolten(36864),
+                new FluidStack(solderIndalloy, 46080),
+                MaterialsUEVplus.TranscendentMetal.getMolten(4320),
+                Materials.InfinityCatalyst.getMolten(17010))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T10.get(1))
+            .eut(TierEU.RECIPE_UXV)
+            .duration(20 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlackSteel, 1),
+                ItemRefer.Fluid_Storage_Core_T1.get(10),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Steel, 4),
+                ItemList.Electric_Pump_HV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.StainlessSteel, 4),
+                GT_Utility.getIntegratedCircuit(5))
+            .fluidInputs(Materials.Plastic.getMolten(144))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T1.get(1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1),
+                ItemRefer.Fluid_Storage_Core_T2.get(10),
+                WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.plate, 4),
+                ItemList.Electric_Pump_EV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Enderium, 4),
+                GT_Utility.getIntegratedCircuit(5))
+            .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(144))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T2.get(1))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T2.get(1))
+            .metadata(RESEARCH_TIME, 17 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Naquadah, 1),
+                ItemRefer.Fluid_Storage_Core_T3.get(10),
+                new Object[] { OrePrefixes.circuit.get(Materials.Master), 8 },
+                ItemList.Electric_Pump_IV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.NiobiumTitanium, 8),
+                MyMaterial.adamantiumAlloy.get(OrePrefixes.plate, 32))
+            .fluidInputs(
+                Materials.Quantium.getMolten(1440),
+                FluidRegistry.getFluidStack("ic2coolant", 8000),
+                Materials.Lubricant.getFluid(8000))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T3.get(1))
+            .eut(TierEU.RECIPE_LuV)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T3.get(1))
+            .metadata(RESEARCH_TIME, 34 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 1),
+                ItemRefer.Fluid_Storage_Core_T4.get(10),
+                new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 8 },
+                ItemList.Electric_Pump_LuV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.MysteriousCrystal, 8),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ElectrumFlux, 32))
+            .fluidInputs(
+                Materials.Draconium.getMolten(1440),
+                FluidRegistry.getFluidStack("ic2coolant", 16000),
+                Materials.Lubricant.getFluid(16000))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T4.get(1))
+            .eut(TierEU.RECIPE_ZPM)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T4.get(1))
+            .metadata(RESEARCH_TIME, 1 * HOURS + 8 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1),
+                ItemRefer.Fluid_Storage_Core_T5.get(10),
+                new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 8 },
+                ItemList.Electric_Pump_ZPM.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.DraconiumAwakened, 8),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 64))
+            .fluidInputs(
+                Materials.Draconium.getMolten(1440),
+                FluidRegistry.getFluidStack("ic2coolant", 16000),
+                Materials.Lubricant.getFluid(16000))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T5.get(1))
+            .eut(TierEU.RECIPE_UV)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T5.get(1))
+            .metadata(RESEARCH_TIME, 2 * HOURS + 15 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1),
+                ItemRefer.Fluid_Storage_Core_T6.get(2),
+                new Object[] { OrePrefixes.circuit.get(Materials.Infinite), 8L },
+                ItemList.Electric_Pump_UV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.NetherStar, 8),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 64))
+            .fluidInputs(
+                Materials.DraconiumAwakened.getMolten(1440),
+                FluidRegistry.getFluidStack("ic2coolant", 46080),
+                Materials.Lubricant.getFluid(32000))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T6.get(1))
+            .eut(TierEU.RECIPE_UHV)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T6.get(1))
+            .metadata(RESEARCH_TIME, 4 * HOURS + 30 * MINUTES)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1),
+                ItemRefer.Fluid_Storage_Core_T7.get(2),
+                new Object[] { OrePrefixes.circuit.get(Materials.Bio), 8L },
+                ItemList.Electric_Pump_UHV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.NetherStar, 16),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CosmicNeutronium, 32),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 32))
+            .fluidInputs(
+                Materials.DraconiumAwakened.getMolten(14400),
+                FluidRegistry.getFluidStack("supercoolant", 46080),
+                Materials.Lubricant.getFluid(46080))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T7.get(1))
+            .eut(TierEU.RECIPE_UEV)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T7.get(1))
+            .metadata(RESEARCH_TIME, 9 * HOURS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1),
+                ItemRefer.Fluid_Storage_Core_T8.get(2),
+                new Object[] { OrePrefixes.circuit.get(Materials.Optical), 8L },
+                ItemList.Electric_Pump_UEV.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.NetherStar, 12),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.CosmicNeutronium, 12),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.DraconiumAwakened, 12),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 64))
+            .fluidInputs(
+                Materials.DraconiumAwakened.getMolten(14400),
+                FluidRegistry.getFluidStack("supercoolant", 46080),
+                Materials.Lubricant.getFluid(46080))
+            .itemOutputs(ItemRefer.YOTTank_Cell_T8.get(1))
+            .eut(TierEU.RECIPE_UIV)
+            .duration(50 * SECONDS)
+            .addTo(AssemblyLine);
+
+        if (NewHorizonsCoreMod.isModLoaded()) {
+            GT_Values.RA.stdBuilder()
+                .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T8.get(1))
+                .metadata(RESEARCH_TIME, 18 * HOURS)
+                .itemInputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 2),
+                    ItemRefer.Fluid_Storage_Core_T9.get(2),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Piko), 8L },
+                    ItemList.Electric_Pump_UIV.get(8),
+                    GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.NetherStar, 12),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.CosmicNeutronium, 12),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.DraconiumAwakened, 12),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 64))
+                .fluidInputs(
+                    Materials.DraconiumAwakened.getMolten(14400),
+                    FluidRegistry.getFluidStack("supercoolant", 46080),
+                    Materials.Lubricant.getFluid(46080))
+                .itemOutputs(ItemRefer.YOTTank_Cell_T9.get(1))
+                .eut(TierEU.RECIPE_UMV)
+                .duration(50 * SECONDS)
+                .addTo(AssemblyLine);
+
+            GT_Values.RA.stdBuilder()
+                .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T9.get(1))
+                .metadata(RESEARCH_TIME, 36 * HOURS)
+                .itemInputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 2),
+                    ItemRefer.Fluid_Storage_Core_T10.get(2),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 12L },
+                    ItemList.Electric_Pump_UMV.get(8),
+                    GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.NetherStar, 64),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.CosmicNeutronium, 12),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.DraconiumAwakened, 12),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, MaterialsUEVplus.SpaceTime, 10))
+                .fluidInputs(
+                    Materials.DraconiumAwakened.getMolten(14400),
+                    MaterialsUEVplus.TranscendentMetal.getMolten(1440),
+                    FluidRegistry.getFluidStack("supercoolant", 46080),
+                    Materials.Lubricant.getFluid(46080))
+                .itemOutputs(ItemRefer.YOTTank_Cell_T10.get(1))
+                .eut(TierEU.RECIPE_UXV)
+                .duration(50 * SECONDS)
+                .addTo(AssemblyLine);
+        }
+
+        // Craft 2x64X Tier to 1X+1 Tier
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fluid_Storage_Core_T6.get(64),
+                ItemRefer.Fluid_Storage_Core_T6.get(64),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T7.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fluid_Storage_Core_T7.get(64),
+                ItemRefer.Fluid_Storage_Core_T7.get(64),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T8.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fluid_Storage_Core_T8.get(64),
+                ItemRefer.Fluid_Storage_Core_T8.get(64),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T9.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fluid_Storage_Core_T9.get(64),
+                ItemRefer.Fluid_Storage_Core_T9.get(64),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fluid_Storage_Core_T10.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T1.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T1.get(10),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlackSteel, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T2.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T2.get(10),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T3.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T3.get(10),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Naquadah, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T4.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T4.get(10),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T5.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T5.get(10),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T6.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T6.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T7.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T7.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T8.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T8.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T9.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T9.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.YOTTank_Cell_T10.get(1))
+            .itemOutputs(
+                ItemRefer.Fluid_Storage_Core_T10.get(2),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(unpackagerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(WerkstoffLoader.Tiberium.get(OrePrefixes.dust, 1))
+            .itemOutputs(
+                WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1),
+                WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1))
+            .outputChances(10000, 2000)
+            .fluidInputs(MyMaterial.naquadahGas.getFluidOrGas(250))
+            .duration(400)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(autoclaveRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Firestone.getGems(1))
+            .fluidInputs(MyMaterial.lightNaquadahFuel.getFluidOrGas(144))
+            .itemOutputs(WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(chemicalBathRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Diamond.getGems(1))
+            .fluidInputs(MyMaterial.heavyNaquadahFuel.getFluidOrGas(144))
+            .itemOutputs(WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(chemicalBathRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .fluidInputs(Materials.HeavyFuel.getFluid(1000))
+            .fluidOutputs(
+                Materials.Toluene.getFluid(400),
+                Materials.Benzene.getFluid(400),
+                Materials.Phenol.getFluid(250))
+            .duration(6 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(distillationTowerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Coal.getGems(1))
+            .itemOutputs(Materials.Ash.getDust(1))
+            .outputChances(10)
+            .fluidOutputs(FluidRegistry.getFluidStack("fluid.coaltar", 250))
+            .duration(3 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(fluidExtractionRecipes);
+
+        if (OreDictionary.getOres("fuelCoke")
+            .size() > 0) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    OreDictionary.getOres("fuelCoke")
+                        .get(0))
+                .itemOutputs(Materials.Ash.getDust(1))
+                .outputChances(10)
+                .fluidOutputs(FluidRegistry.getFluidStack("fluid.coaltar", 250))
+                .duration(3 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(fluidExtractionRecipes);
+        }
+
+        if (GTPlusPlus.isModLoaded()) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(24))
+                .fluidInputs(FluidRegistry.getFluidStack("fluid.coaltaroil", 100))
+                .fluidOutputs(MyMaterial.cyclopentadiene.getFluidOrGas(30))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(distilleryRecipes);
+        }
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(24))
+            .fluidInputs(Materials.WoodTar.getFluid(500))
+            .fluidOutputs(MyMaterial.cyclopentadiene.getFluidOrGas(20))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(distilleryRecipes);
+
+        // FeCl2 + Cl = FeCl3
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ferrousChloride.get(OrePrefixes.cell, 1), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Chlorine.getGas(1000))
+            .itemOutputs(Materials.IronIIIChloride.getCells(1))
+            .duration(2 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        // FeCl3 + H = FeCl2 + HCl
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.IronIIIChloride.getCells(1), GT_Utility.getIntegratedCircuit(7))
+            .fluidInputs(Materials.Hydrogen.getGas(1000))
+            .fluidOutputs(Materials.HydrochloricAcid.getFluid(1000))
+            .itemOutputs(MyMaterial.ferrousChloride.get(OrePrefixes.cell, 1))
+            .duration(4 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(UniversalChemical);
+
+        // NH3 + 2C2H6O = C4H11N + 2H2O
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Ammonia.getCells(1), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Ethanol.getFluid(2000))
+            .fluidOutputs(Materials.Water.getFluid(2000))
+            .itemOutputs(MyMaterial.diethylamine.get(OrePrefixes.cell, 1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(UniversalChemical);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(
+                MyMaterial.cyclopentadiene.getFluidOrGas(2000),
+                MyMaterial.ferrousChloride.getFluidOrGas(1000),
+                MyMaterial.diethylamine.getFluidOrGas(8000),
+                Materials.Ice.getSolid(4000))
+            .fluidOutputs(MyMaterial.impureFerroceneMixture.getFluidOrGas(15000))
+            .duration(2 * MINUTES)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ether.get(OrePrefixes.cell, 1), GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(MyMaterial.impureFerroceneMixture.getFluidOrGas(7500))
+            .itemOutputs(MyMaterial.ferroceneSolution.get(OrePrefixes.cell, 1))
+            .fluidOutputs(MyMaterial.ferroceneWaste.getFluidOrGas(5000))
+            .duration(40 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            MyMaterial.ferroceneWaste.getFluidOrGas(1000),
+            new FluidStack[] { Materials.Water.getFluid(400), MyMaterial.diethylamine.getFluidOrGas(800),
+                MyMaterial.ether.getFluidOrGas(500) },
+            GT_Values.NI,
+            30 * SECONDS,
+            TierEU.RECIPE_MV);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            MyMaterial.ferroceneSolution.getFluidOrGas(2000),
+            new FluidStack[] { MyMaterial.ether.getFluidOrGas(1000) },
+            MyMaterial.ferrocene.get(OrePrefixes.dust, 1),
+            30 * SECONDS,
+            TierEU.RECIPE_MV);
+
+        if (GTPlusPlus.isModLoaded()) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(MyMaterial.ferrocene.get(OrePrefixes.dust, 4), Materials.SodiumHydroxide.getDust(8))
+                .fluidInputs(
+                    FluidRegistry.getFluidStack("fluid.kerosene", 40000),
+                    Materials.Naphtha.getFluid(3000),
+                    MyMaterial.diethylamine.getFluidOrGas(1000))
+                .fluidOutputs(MyMaterial.ironedKerosene.getFluidOrGas(44000))
+                .duration(2 * MINUTES)
+                .eut(TierEU.RECIPE_EV)
+                .addTo(multiblockChemicalReactorRecipes);
+        }
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.ferrocene.get(OrePrefixes.dust, 4))
+            .fluidInputs(
+                FluidRegistry.getFluidStack("combustionpromotor", 4000),
+                Materials.Naphtha.getFluid(40000),
+                Materials.LightFuel.getFluid(3000),
+                Materials.LPG.getFluid(1000),
+                Materials.Tetranitromethane.getFluid(2000))
+            .fluidOutputs(MyMaterial.ironedFuel.getFluidOrGas(50000))
+            .duration(2 * MINUTES)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Combustion_Generator_EV.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "PCP", "MHM", "GWG", 'G',
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 1), 'C', "circuitData", 'W',
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Aluminium, 1), 'P',
+                ItemList.Electric_Piston_EV, 'H', ItemList.Hull_EV, 'M', ItemList.Electric_Motor_EV });
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Combustion_Generator_IV.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "PCP", "MHM", "GWG", 'G',
+                GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.TungstenSteel, 1), 'C', "circuitElite", 'W',
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Tungsten, 1), 'P',
+                ItemList.Electric_Piston_IV, 'H', ItemList.Hull_IV, 'M', ItemList.Electric_Motor_IV });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1))
+            .fluidInputs(MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(250))
+            .itemOutputs(ItemRefer.Fuel_Rod_LU_1.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(fluidCannerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1))
+            .fluidInputs(MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(250))
+            .itemOutputs(ItemRefer.Fuel_Rod_LPu_1.get(1))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(fluidCannerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_LPu_1.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fuel_Rod_LPu_2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_LPu_2.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(ItemRefer.Fuel_Rod_LPu_4.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_LPu_1.get(4),
+                MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6),
+                GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(ItemRefer.Fuel_Rod_LPu_4.get(1))
+            .duration(11 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_LU_1.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemRefer.Fuel_Rod_LU_2.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_LU_2.get(2),
+                MyMaterial.zircaloy2.get(OrePrefixes.stick, 4),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(ItemRefer.Fuel_Rod_LU_4.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemRefer.Fuel_Rod_LU_1.get(4),
+                MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6),
+                GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(ItemRefer.Fuel_Rod_LU_4.get(1))
+            .duration(11 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+
+        MyRecipeAdder.instance.addExtremeHeatExchangerRecipe(
+            FluidRegistry.getFluidStack("lava", 20000),
+            FluidRegistry.getFluidStack("ic2pahoehoelava", 20000),
+            FluidRegistry.getFluidStack("ic2distilledwater", 20000),
+            FluidRegistry.getFluidStack("steam", 3200000),
+            FluidRegistry.getFluidStack("ic2superheatedsteam", 1600000),
+            10000);
+
+        MyRecipeAdder.instance.addExtremeHeatExchangerRecipe(
+            FluidRegistry.getFluidStack("ic2hotcoolant", 16000),
+            FluidRegistry.getFluidStack("ic2coolant", 16000),
+            FluidRegistry.getFluidStack("ic2distilledwater", 20000),
+            FluidRegistry.getFluidStack("ic2superheatedsteam", 3200000),
+            FluidRegistry.getFluidStack("supercriticalsteam", 32000),
+            8000);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushedPurified, Materials.Lepidolite, 1))
+            .fluidInputs(Materials.HydrochloricAcid.getFluid(1000))
+            .itemOutputs(
+                Materials.RockSalt.getDust(1),
+                MyMaterial.lithiumChloride.get(OrePrefixes.dust, 3),
+                Materials.Cryolite.getDust(4))
+            .outputChances(8000, 8000, 8000)
+            .duration(7 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(chemicalBathRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(MyMaterial.marM200.get(OrePrefixes.ingot, 18), Materials.Cerium.getIngots(1))
+            .fluidInputs(MyMaterial.lithiumChloride.getMolten(144))
+            .itemOutputs(MyMaterial.marCeM200.get(OrePrefixes.ingotHot, 19))
+            .duration(4 * MINUTES + 45 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .metadata(COIL_HEAT, 4500)
+            .addTo(blastFurnaceRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.SC_Turbine_Casing.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "PhP", "GCG", "PwP", 'G', MyMaterial.marM200.get(OrePrefixes.gearGt, 1), 'C',
+                ItemList.Casing_Turbine.get(1), 'P', MyMaterial.marCeM200.get(OrePrefixes.plate, 1), });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.marM200.get(OrePrefixes.gearGt, 2),
+                MyMaterial.marCeM200.get(OrePrefixes.plate, 4),
+                ItemList.Casing_Turbine.get(1))
+            .itemOutputs(ItemRefer.SC_Turbine_Casing.get(1))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.SC_Fluid_Turbine.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "NPN", "GHG", "IPI", 'N', "circuitMaster", 'P', MyMaterial.marM200.get(OrePrefixes.plate, 1),
+                'H', ItemList.Hull_IV.get(1), 'G', MyMaterial.marCeM200.get(OrePrefixes.gearGt, 1), 'I',
+                MyMaterial.incoloy903.get(OrePrefixes.pipeLarge, 1) });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.marM200.get(OrePrefixes.plate, 2),
+                MyMaterial.marCeM200.get(OrePrefixes.gearGt, 2),
+                MyMaterial.incoloy903.get(OrePrefixes.pipeLarge, 2),
+                GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Master, 2),
+                ItemList.Hull_IV.get(1))
+            .itemOutputs(ItemRefer.SC_Fluid_Turbine.get(1))
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                MyMaterial.incoloy903.get(OrePrefixes.plate, 4),
+                MyMaterial.marCeM200.get(OrePrefixes.plate, 4),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NiobiumTitanium, 1),
+                GT_Utility.getIntegratedCircuit(8))
+            .itemOutputs(ItemRefer.Pressure_Resistant_Wall.get(1))
+            .duration(50 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+
+        GT_ModHandler.addCraftingRecipe(
+            ItemRefer.Extreme_Heat_Exchanger.get(1),
+            GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE,
+            new Object[] { "EPE", "PHP", "SPS", 'P',
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.TungstenSteel, 1), 'H',
+                ItemList.Hull_IV.get(1), 'S', MyMaterial.marM200.get(OrePrefixes.plate, 1), 'E',
+                GT_ModHandler.getIC2Item("reactorHeatSwitchDiamond", 1L, 1) });
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Salty_Root.get(1))
+            .fluidInputs(GT_ModHandler.getWater(100))
+            .itemOutputs(Materials.Salt.getDust(1), Materials.RockSalt.getDust(1), Materials.Saltpeter.getDust(1))
+            .outputChances(9500, 8000, 5000)
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(chemicalBathRecipes);
+
+        if (NewHorizonsCoreMod.isModLoaded()) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemList.Robot_Arm_IV.get(4),
+                    ItemRefer.HiC_T1.get(4),
+                    ItemList.Tool_DataOrb.get(3),
+                    GT_OreDictUnificator.get(OrePrefixes.cableGt08, Materials.Titanium, 4),
+                    MyMaterial.hikarium.get(OrePrefixes.gearGt, 4),
+                    MyMaterial.marM200.get(OrePrefixes.plateDouble, 2),
+                    ItemRefer.IC2_Ir_Plate.get(2),
+                    MyMaterial.lumiium.get(OrePrefixes.bolt, 48))
+                .fluidInputs(Materials.Palladium.getMolten(1152))
+                .itemOutputs(ItemRefer.Precise_Assembler.get(1))
+                .duration(1 * MINUTES + 30 * SECONDS)
+                .eut(TierEU.RECIPE_IV)
+                .addTo(assemblerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemList.Casing_ZPM.get(3),
+                    ItemList.Robot_Arm_EV.get(2),
+                    GT_OreDictUnificator.get(OrePrefixes.cableGt04, MyMaterial.lumiium.getBridgeMaterial(), 2),
+                    MyMaterial.marCeM200.get(OrePrefixes.plateDouble, 2),
+                    ItemRefer.HiC_T1.get(1),
+                    MyMaterial.signalium.get(OrePrefixes.bolt, 32),
+                    MyMaterial.titaniumBetaC.get(OrePrefixes.gearGtSmall, 8))
+                .fluidInputs(Materials.BlackSteel.getMolten(576))
+                .itemOutputs(ItemRefer.Precise_Electronic_Unit_T1.get(2))
+                .duration(40 * SECONDS)
+                .eut(TierEU.RECIPE_IV)
+                .addTo(assemblerRecipes);
+
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T1.get(2),
+                    GT_ModHandler.getModItem("dreamcraft", "item.EngravedDiamondCrystalChip", 8),
+                    ItemList.Circuit_Chip_NAND.get(16), GT_ModHandler.getIC2Item("reactorVentCore", 1L, 1) },
+                new FluidStack[] { Materials.Plastic.getMolten(288), MyMaterial.signalium.getMolten(144),
+                    MyMaterial.lumiium.getMolten(72), Materials.Enderium.getMolten(72) },
+                ItemRefer.HiC_T2.get(1),
+                30720,
+                100,
+                1);
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T1.get(2),
+                    GT_ModHandler.getModItem("dreamcraft", "item.EngravedDiamondCrystalChip", 8),
+                    ItemList.Circuit_Chip_NAND.get(16),
+                    GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Aluminium, 2) },
+                new FluidStack[] { Materials.Plastic.getMolten(288), MyMaterial.signalium.getMolten(144),
+                    MyMaterial.lumiium.getMolten(72), Materials.Enderium.getMolten(72) },
+                ItemRefer.HiC_T2.get(1),
+                30720,
+                100,
+                1);
+
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T2.get(2), ItemList.Circuit_Parts_Crystal_Chip_Master.get(8),
+                    ItemList.Circuit_Chip_CrystalSoC2.get(1), GT_ModHandler.getIC2Item("reactorVentDiamond", 1L, 1) },
+                new FluidStack[] { MyMaterial.adamantiumAlloy.getMolten(576), MyMaterial.signalium.getMolten(288),
+                    MyMaterial.lumiium.getMolten(144), Materials.TungstenCarbide.getMolten(72) },
+                ItemRefer.HiC_T3.get(1),
+                122880,
+                100,
+                2);
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T2.get(2), ItemList.Circuit_Parts_Crystal_Chip_Master.get(8),
+                    ItemList.Circuit_Chip_CrystalSoC2.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 2) },
+                new FluidStack[] { MyMaterial.adamantiumAlloy.getMolten(576), MyMaterial.signalium.getMolten(288),
+                    MyMaterial.lumiium.getMolten(144), Materials.TungstenCarbide.getMolten(72) },
+                ItemRefer.HiC_T3.get(1),
+                122880,
+                100,
+                2);
+
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T3.get(2),
+                    GT_ModHandler.getModItem("dreamcraft", "item.EngravedEnergyChip", 8),
+                    ItemList.Circuit_Chip_QuantumCPU.get(16), GT_ModHandler.getIC2Item("reactorVentGold", 1L, 1) },
+                new FluidStack[] { MyMaterial.marM200.getMolten(1152), MyMaterial.signalium.getMolten(576),
+                    MyMaterial.lumiium.getMolten(288), MyMaterial.artheriumSn.getMolten(144) },
+                ItemRefer.HiC_T4.get(1),
+                491520,
+                100,
+                3);
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T3.get(2),
+                    GT_ModHandler.getModItem("dreamcraft", "item.EngravedEnergyChip", 8),
+                    ItemList.Circuit_Chip_QuantumCPU.get(16),
+                    GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.EnergeticAlloy, 2) },
+                new FluidStack[] { MyMaterial.marM200.getMolten(1152), MyMaterial.signalium.getMolten(576),
+                    MyMaterial.lumiium.getMolten(288), MyMaterial.artheriumSn.getMolten(144) },
+                ItemRefer.HiC_T4.get(1),
+                491520,
+                100,
+                3);
+
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T4.get(2),
+                    GT_ModHandler.getModItem("dreamcraft", "item.EngravedManyullynCrystalChip", 8),
+                    ItemList.Circuit_Chip_BioCPU.get(1), Ic2Items.reactorVentSpread },
+                new FluidStack[] { MyMaterial.titaniumBetaC.getMolten(1728), MyMaterial.signalium.getMolten(1152),
+                    MyMaterial.lumiium.getMolten(576), MyMaterial.dalisenite.getMolten(288) },
+                ItemRefer.HiC_T5.get(1),
+                1966080,
+                100,
+                3);
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { ItemRefer.HiC_T4.get(2),
+                    GT_ModHandler.getModItem("dreamcraft", "item.EngravedManyullynCrystalChip", 8),
+                    ItemList.Circuit_Chip_BioCPU.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.TungstenCarbide, 2) },
+                new FluidStack[] { MyMaterial.titaniumBetaC.getMolten(1728), MyMaterial.signalium.getMolten(1152),
+                    MyMaterial.lumiium.getMolten(576), MyMaterial.dalisenite.getMolten(288) },
+                ItemRefer.HiC_T5.get(1),
+                1966080,
+                100,
+                3);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemList.Casing_UV.get(3),
+                    ItemList.Robot_Arm_LuV.get(2),
+                    GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.ElectrumFlux, 4),
+                    ItemRefer.HiC_T2.get(1),
+                    ItemRefer.Precise_Electronic_Unit_T1.get(1),
+                    MyMaterial.marCeM200.get(OrePrefixes.bolt, 32),
+                    MyMaterial.artheriumSn.get(OrePrefixes.gearGtSmall, 8))
+                .fluidInputs(MyMaterial.adamantiumAlloy.getMolten(1152))
+                .itemOutputs(ItemRefer.Precise_Electronic_Unit_T2.get(4))
+                .duration(4 * MINUTES)
+                .eut(TierEU.RECIPE_ZPM)
+                .addTo(assemblerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemList.Casing_MAX.get(3),
+                    ItemList.Field_Generator_ZPM.get(2),
+                    GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Bedrockium, 4),
+                    ItemRefer.HiC_T3.get(1),
+                    ItemRefer.Precise_Electronic_Unit_T2.get(1),
+                    MyMaterial.titaniumBetaC.get(OrePrefixes.bolt, 32),
+                    MyMaterial.dalisenite.get(OrePrefixes.gearGtSmall, 8))
+                .fluidInputs(MyMaterial.artheriumSn.getMolten(1152))
+                .itemOutputs(ItemRefer.Precise_Electronic_Unit_T3.get(4))
+                .duration(4 * MINUTES)
+                .eut(TierEU.RECIPE_UV)
+                .addTo(assemblerRecipes);
+        }
+
+        // Compact MK1 Fusion Coil
+        MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+            new ItemStack[] { ItemList.Casing_Coil_Superconductor.get(3), ItemRefer.HiC_T2.get(1),
+                ItemRefer.Special_Ceramics_Plate.get(2) },
+            new FluidStack[] { MyMaterial.marM200.getMolten(1152), MyMaterial.zircaloy4.getMolten(288) },
+            ItemRefer.Compact_Fusion_Coil_T0.get(1),
+            9001,
+            1200,
+            1);
+
+        // Compact MK2 Fusion Coil
+        MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+            new ItemStack[] { ItemList.Casing_Fusion_Coil.get(3), ItemRefer.Quartz_Crystal_Resonator.get(2),
+                ItemRefer.HiC_T3.get(1), },
+            new FluidStack[] { MyMaterial.artheriumSn.getMolten(576), MyMaterial.titaniumBetaC.getMolten(144) },
+            ItemRefer.Compact_Fusion_Coil_T1.get(1),
+            14000,
+            800,
+            2);
+
+        // Compact MK3 Fusion Coil
+        MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+            new ItemStack[] { ItemList.Casing_Fusion_Coil.get(3), ItemRefer.Radiation_Protection_Plate.get(2),
+                ItemList.QuantumStar.get(4), ItemRefer.HiC_T4.get(1) },
+            new FluidStack[] { MyMaterial.dalisenite.getMolten(576), MyMaterial.hikarium.getMolten(144) },
+            ItemRefer.Compact_Fusion_Coil_T2.get(1),
+            114514,
+            800,
+            3);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.FusionComputer_LuV.get(48),
+                ItemRefer.HiC_T1.get(8),
+                MyMaterial.marCeM200.get(OrePrefixes.plate, 32),
+                GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Master, 8),
+                ItemList.Circuit_Wafer_HPIC.get(16),
+                ItemList.Field_Generator_LuV.get(4),
+                MyMaterial.marM200.get(OrePrefixes.stickLong, 8))
+            .fluidInputs(MyMaterial.adamantiumAlloy.getMolten(9216))
+            .itemOutputs(ItemRefer.Compact_Fusion_MK1.get(1))
+            .duration(1 * MINUTES)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(assemblerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Compact_Fusion_MK1.get(1))
+            .metadata(RESEARCH_TIME, 20 * MINUTES)
+            .itemInputs(
+                ItemList.FusionComputer_ZPMV.get(48),
+                new Object[] { "circuitUltimate", 1 },
+                new Object[] { "circuitUltimate", 1 },
+                new Object[] { "circuitUltimate", 1 },
+                new Object[] { "circuitUltimate", 1 },
+                ItemList.Circuit_Wafer_UHPIC.get(32),
+                ItemList.ZPM_Coil.get(16),
+                ItemList.Neutron_Reflector.get(4),
+                ItemRefer.HiC_T2.get(8),
+                ItemList.Field_Generator_ZPM.get(8),
+                MyMaterial.artheriumSn.get(OrePrefixes.gearGtSmall, 32))
+            .fluidInputs(
+                MyMaterial.marCeM200.getMolten(2304),
+                WerkstoffLoader.HDCS.getMolten(1152),
+                MyMaterial.artheriumSn.getMolten(288))
+            .itemOutputs(ItemRefer.Compact_Fusion_MK2.get(1))
+            .eut(TierEU.RECIPE_ZPM / 2)
+            .duration(5 * MINUTES)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, ItemRefer.Compact_Fusion_MK2.get(1))
+            .metadata(RESEARCH_TIME, 20 * MINUTES)
+            .itemInputs(
+                ItemList.FusionComputer_UV.get(48),
+                new Object[] { "circuitSuperconductor", 1 },
+                new Object[] { "circuitSuperconductor", 1 },
+                new Object[] { "circuitSuperconductor", 1 },
+                new Object[] { "circuitSuperconductor", 1 },
+                ItemList.Circuit_Wafer_NPIC.get(64),
+                ItemList.UV_Coil.get(16),
+                ItemRefer.Advanced_Radiation_Protection_Plate.get(8),
+                ItemRefer.HiC_T3.get(8),
+                ItemList.Field_Generator_UV.get(8),
+                WerkstoffLoader.HDCS.get(OrePrefixes.gearGtSmall, 64))
+            .fluidInputs(
+                MyMaterial.titaniumBetaC.getMolten(2304),
+                MyMaterial.dalisenite.getMolten(1152),
+                Materials.Americium.getMolten(288))
+            .itemOutputs(ItemRefer.Compact_Fusion_MK3.get(1))
+            .eut(TierEU.RECIPE_ZPM)
+            .duration(5 * MINUTES)
+            .addTo(AssemblyLine);
+
+        // Compact MK4 Fusion Coil
+        if (GTPlusPlus.isModLoaded()) {
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { GT_ModHandler.getModItem("miscutils", "gtplusplus.blockcasings.3", 3, 13),
+                    ItemRefer.HiC_T5.get(1), GT_ModHandler.getModItem("miscutils", "item.itemBufferCore4", 1), },
+                new FluidStack[] { FluidRegistry.getFluidStack("molten.energycrystal", 1152),
+                    FluidRegistry.getFluidStack("molten.laurenium", 144) },
+                ItemRefer.Compact_Fusion_Coil_T3.get(1),
+                520000,
+                2000,
+                3);
+
+            // Compact MK4 Fusion Disassembly Recipe
+            GT_Values.RA.stdBuilder()
+                .itemInputs(ItemRefer.Compact_Fusion_Coil_T3.get(1))
+                .itemOutputs(GregtechItemList.Casing_Fusion_Internal.get(3))
+                .duration(30 * SECONDS)
+                .eut(TierEU.RECIPE_UEV)
+                .addTo(assemblerRecipes);
+
+            TT_recipeAdder.addResearchableAssemblylineRecipe(
+                ItemRefer.Compact_Fusion_MK3.get(1),
+                2_560_000,
+                4_096,
+                (int) TierEU.RECIPE_UHV,
+                256,
+                new Object[] { GregtechItemList.FusionComputer_UV2.get(48), new Object[] { "circuitInfinite", 1 },
+                    new Object[] { "circuitInfinite", 1 }, new Object[] { "circuitInfinite", 1 },
+                    new Object[] { "circuitInfinite", 1 }, ItemList.Circuit_Wafer_PPIC.get(64),
+                    ItemList.UHV_Coil.get(16), ALLOY.TITANSTEEL.getPlateDense(8), ItemRefer.HiC_T4.get(8),
+                    ItemList.Field_Generator_UHV.get(8),
+                    MyMaterial.enrichedNaquadahAlloy.get(OrePrefixes.gearGtSmall, 64) },
+                new FluidStack[] { GenericChem.TEFLON.getFluidStack(2304), MyMaterial.dalisenite.getMolten(1152),
+                    ALLOY.BOTMIUM.getFluidStack(288) },
+                ItemRefer.Compact_Fusion_MK4.get(1),
+                6000,
+                (int) TierEU.RECIPE_UV);
+
+            // Compact MK5 Fusion Coil
+            MyRecipeAdder.instance.addPreciseAssemblerRecipe(
+                new ItemStack[] { GregtechItemList.Casing_Fusion_Internal2.get(3),
+                    GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Bio, 1), ItemRefer.HiC_T5.get(4),
+                    CI.getEnergyCore(5, 1), },
+                new FluidStack[] { ALLOY.BLACK_TITANIUM.getFluidStack(1152),
+                    MyMaterial.metastableOganesson.getMolten(576) },
+                ItemRefer.Compact_Fusion_Coil_T4.get(1),
+                (int) TierEU.RECIPE_UHV,
+                2000,
+                3);
+
+            // Compact MK5 Computer
+            TT_recipeAdder.addResearchableAssemblylineRecipe(
+                ItemRefer.Compact_Fusion_MK4.get(1),
+                10_240_000,
+                16_384,
+                (int) TierEU.RECIPE_UEV,
+                256,
+                new Object[] { GregtechItemList.FusionComputer_UV3.get(48), new Object[] { "circuitBio", 1 },
+                    new Object[] { "circuitBio", 1 }, new Object[] { "circuitBio", 1 },
+                    new Object[] { "circuitBio", 1 }, ItemList.Circuit_Wafer_QPIC.get(64), ItemList.UHV_Coil.get(64),
+                    ELEMENT.STANDALONE.HYPOGEN.getPlateDense(8), ItemRefer.HiC_T5.get(8),
+                    ItemList.Field_Generator_UEV.get(8),
+                    MyMaterial.metastableOganesson.get(OrePrefixes.gearGtSmall, 64) },
+                new FluidStack[] { MyMaterial.tairitsu.getMolten(2304), ALLOY.OCTIRON.getFluidStack(1152),
+                    ELEMENT.STANDALONE.RHUGNOR.getFluidStack(288) },
+                ItemRefer.Compact_Fusion_MK5.get(1),
+                6000,
+                (int) TierEU.RECIPE_UHV);
+
+            // Compact MK5 Fusion Disassembly Recipe
+            GT_Values.RA.stdBuilder()
+                .itemInputs(ItemRefer.Compact_Fusion_Coil_T4.get(1))
+                .itemOutputs(GregtechItemList.Casing_Fusion_Internal2.get(3))
+                .duration(1 * MINUTES)
+                .eut(TierEU.RECIPE_UIV)
+                .addTo(assemblerRecipes);
+        }
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Antimony.getDust(8), GT_Utility.getIntegratedCircuit(24))
+            .fluidInputs(
+                MyMaterial.ether.getFluidOrGas(1000),
+                Materials.Fluorine.getGas(40000),
+                Materials.Ice.getSolid(8000))
+            .fluidOutputs(MyMaterial.antimonyPentafluorideSolution.getFluidOrGas(8000))
+            .duration(40 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        CrackRecipeAdder.addUniversalDistillationRecipe(
+            MyMaterial.antimonyPentafluorideSolution.getFluidOrGas(4000),
+            new FluidStack[] { MyMaterial.antimonyPentafluoride.getFluidOrGas(4000),
+                MyMaterial.ether.getFluidOrGas(500) },
+            GT_Values.NI,
+            5 * SECONDS,
+            TierEU.RECIPE_MV);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.Plastic, 2),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1),
+                GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(Materials.Concrete.getMolten(2304))
+            .itemOutputs(ItemRefer.Coolant_Tower.get(1))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(assemblerRecipes);
+    }
+
+    public static void InitLoadRecipe() {
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_U_Depleted_1.get(1))
+            .itemOutputs(
+                ItemRefer.Advanced_Fuel_Rod.get(1),
+                Materials.Uranium.getDust(8),
+                Materials.Plutonium.getDust(2),
+                Materials.Graphite.getDust(8),
+                Materials.Uranium235.getDust(1),
+                Materials.Plutonium241.getDust(1))
+            .outputChances(10000, 10000, 10000, 9000, 5000, 3000)
+            .fluidOutputs(WerkstoffLoader.Neon.getFluidOrGas(32))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_U_Depleted_2.get(1))
+            .itemOutputs(
+                ItemRefer.Advanced_Fuel_Rod.get(2),
+                Materials.Uranium.getDust(16),
+                Materials.Plutonium.getDust(4),
+                Materials.Graphite.getDust(16),
+                Materials.Uranium235.getDust(2),
+                Materials.Plutonium241.getDust(2))
+            .outputChances(10000, 10000, 10000, 9000, 5000, 3000)
+            .fluidOutputs(WerkstoffLoader.Neon.getFluidOrGas(64))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_U_Depleted_4.get(1))
+            .itemOutputs(
+                ItemRefer.Advanced_Fuel_Rod.get(4),
+                Materials.Uranium.getDust(32),
+                Materials.Plutonium.getDust(8),
+                Materials.Graphite.getDust(32),
+                Materials.Uranium235.getDust(4),
+                Materials.Plutonium241.getDust(4))
+            .outputChances(10000, 10000, 10000, 9000, 5000, 3000)
+            .fluidOutputs(WerkstoffLoader.Neon.getFluidOrGas(128))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_Pu_Depleted_1.get(1))
+            .itemOutputs(
+                ItemRefer.Advanced_Fuel_Rod.get(1),
+                Materials.Plutonium.getDust(5),
+                Materials.Plutonium241.getDust(2),
+                Materials.Carbon.getDust(2),
+                Materials.Uranium.getDust(1),
+                Materials.Uranium235.getDust(1))
+            .outputChances(10000, 10000, 10000, 9000, 5000, 3000)
+            .fluidOutputs(Materials.Argon.getGas(32))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_Pu_Depleted_2.get(1))
+            .itemOutputs(
+                ItemRefer.Advanced_Fuel_Rod.get(2),
+                Materials.Plutonium.getDust(10),
+                Materials.Plutonium241.getDust(4),
+                Materials.Carbon.getDust(4),
+                Materials.Uranium.getDust(2),
+                Materials.Uranium235.getDust(2))
+            .outputChances(10000, 10000, 10000, 9000, 5000, 3000)
+            .fluidOutputs(Materials.Argon.getGas(64))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_Pu_Depleted_4.get(1))
+            .itemOutputs(
+                ItemRefer.Advanced_Fuel_Rod.get(4),
+                Materials.Plutonium.getDust(20),
+                Materials.Plutonium241.getDust(8),
+                Materials.Carbon.getDust(8),
+                Materials.Uranium.getDust(4),
+                Materials.Uranium235.getDust(4))
+            .outputChances(10000, 10000, 10000, 9000, 5000, 3000)
+            .fluidOutputs(Materials.Argon.getGas(128))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_LPu_Depleted_1.get(1))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(1))
+            .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(250))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_LPu_Depleted_2.get(1))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(2))
+            .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(500))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_LPu_Depleted_4.get(1))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(4))
+            .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1000))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_LU_Depleted_1.get(1))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(1))
+            .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(250))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_LU_Depleted_2.get(1))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(2))
+            .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(500))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.Fuel_Rod_LU_Depleted_4.get(1))
+            .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(4))
+            .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1000))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(centrifugeRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                Materials.Glowstone.getDust(4),
+                Materials.Redstone.getDust(2),
+                Materials.Aluminium.getDust(1),
+                GT_Utility.getIntegratedCircuit(3))
+            .itemOutputs(ItemRefer.High_Energy_Mixture.get(4))
+            .duration(12 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.High_Energy_Mixture.get(2))
+            .fluidInputs(Materials.PhosphoricAcid.getFluid(4000))
+            .itemOutputs(MyMaterial.lumiinessence.get(OrePrefixes.dust, 1))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_HV / 2)
+            .addTo(fluidSolidifierRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                Materials.AnnealedCopper.getDust(4),
+                Materials.Ardite.getDust(2),
+                Materials.RedAlloy.getDust(2),
+                GT_Utility.getIntegratedCircuit(4))
+            .fluidInputs(Materials.Redstone.getMolten(288))
+            .itemOutputs(MyMaterial.signalium.get(OrePrefixes.dust, 1))
+            .duration(12 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                Materials.TinAlloy.getDust(4),
+                Materials.SterlingSilver.getDust(2),
+                MyMaterial.lumiinessence.get(OrePrefixes.dust, 2),
+                GT_Utility.getIntegratedCircuit(4))
+            .fluidInputs(Materials.Glowstone.getMolten(288))
+            .itemOutputs(MyMaterial.lumiium.get(OrePrefixes.dust, 1))
+            .duration(12 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .fluidInputs(MyMaterial.enrichedNaquadahAlloy.getMolten(144), WerkstoffLoader.Oganesson.getFluidOrGas(250))
+            .fluidOutputs(MyMaterial.metastableOganesson.getMolten(36))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UV)
+            .metadata(FUSION_THRESHOLD, 1000000000)
+            .addTo(fusionRecipes);
+
+        MyRecipeAdder.instance.addNeutronActivatorRecipe(
+            null,
+            new ItemStack[] { MyMaterial.metastableOganesson.get(OrePrefixes.dust) },
+            new FluidStack[] { WerkstoffLoader.Oganesson.getFluidOrGas(250) },
+            null,
+            2000,
+            1100,
+            1000);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemRefer.HiC_T5.get(0))
+            .fluidInputs(
+                MyMaterial.metastableOganesson.getMolten(1152),
+                MyMaterial.preciousMetalAlloy.getMolten(2304),
+                MaterialsUEVplus.SpaceTime.getMolten(288),
+                MaterialsUEVplus.DimensionallyTranscendentResidue.getFluid(5000))
+            .fluidOutputs(MyMaterial.shirabon.getMolten(144))
+            .duration(10 * SECONDS)
+            .eut(1500000000)
+            .metadata(COIL_HEAT, 13500)
+            .addTo(plasmaForgeRecipes);
+    }
+
+    public static void FinishLoadRecipe() {
+        for (GT_Recipe plasmaFuel : RecipeMaps.plasmaFuels.getAllRecipes()) {
+            FluidStack tPlasma = GT_Utility.getFluidForFilledItem(plasmaFuel.mInputs[0], true);
+            if (tPlasma == null) {
+                continue;
+            }
+            int tUnit = plasmaFuel.mSpecialValue;
+            if (tUnit > 200_000) {
+                tPlasma.amount = 1500;
+            } else if (tUnit > 100_000) {
+                tPlasma.amount = 1000;
+            } else if (tUnit > 50_000) {
+                tPlasma.amount = 800;
+            } else if (tUnit > 10_000) {
+                tPlasma.amount = 500;
+            } else {
+                tPlasma.amount = 100;
+            }
+
+            String tPlasmaName = FluidRegistry.getFluidName(tPlasma);
+
+            if (tPlasmaName.split("\\.", 2).length == 2) {
+                String tOutName = tPlasmaName.split("\\.", 2)[1];
+                FluidStack output = FluidRegistry.getFluidStack(tOutName, tPlasma.amount);
+                if (output == null) output = FluidRegistry.getFluidStack("molten." + tOutName, tPlasma.amount);
+                if (output != null) {
+                    long waterAmount = (long) tUnit * 3 * tPlasma.amount / 160;
+                    long criticalSteamAmount = (long) tUnit * 3 * tPlasma.amount / 100;
+                    MyRecipeAdder.instance.addExtremeHeatExchangerRecipe(
+                        tPlasma,
+                        output,
+                        FluidRegistry.getFluidStack("ic2distilledwater", (int) waterAmount),
+                        FluidRegistry.getFluidStack("ic2superheatedsteam", 0), // Plasma always outputs SC steam.
+                        FluidRegistry.getFluidStack("supercriticalsteam", (int) criticalSteamAmount),
+                        1);
+                }
+            }
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/main/GG_Config_Loader.java b/goodgen/src/main/java/goodgenerator/main/GG_Config_Loader.java
new file mode 100644
index 0000000000..bfa4526167
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/main/GG_Config_Loader.java
@@ -0,0 +1,118 @@
+package goodgenerator.main;
+
+import java.io.File;
+
+import net.minecraftforge.common.config.Configuration;
+
+import cpw.mods.fml.relauncher.FMLInjectionData;
+
+public class GG_Config_Loader {
+
+    public static final Configuration GG_Config = new Configuration(
+        new File(new File((File) FMLInjectionData.data()[6], "config"), "GoodGenerator.cfg"));
+
+    public static int LiquidAirConsumptionPerSecond = 2400;
+    public static int[] NaquadahFuelVoltage = new int[] { 12960, 2200, 32400, 975000, 2300000, 9511000, 88540000,
+        399576000, 2077795200 };
+    public static int[] NaquadahFuelTime = new int[] { 100, 500, 150, 60, 70, 80, 100, 160, 240 };
+    public static int[] CoolantEfficiency = new int[] { 500, 275, 150, 105 };
+    public static int[] ExcitedLiquidCoe = new int[] { 64, 16, 4, 3, 2 };
+    public static boolean EnableNaquadahRework = true;
+
+    public static void run() {
+        loadCategory();
+        loadProperty();
+    }
+
+    private static void loadProperty() {
+        NaquadahFuelVoltage[0] = GG_Config
+            .get("LargeNaquadahReactor", "Uranium Based Liquid Fuel Basic Output Voltage", NaquadahFuelVoltage[0])
+            .getInt();
+        NaquadahFuelTime[0] = GG_Config
+            .get("LargeNaquadahReactor", "Uranium Based Liquid Fuel Burning Time", NaquadahFuelTime[0])
+            .getInt();
+        NaquadahFuelVoltage[1] = GG_Config
+            .get("LargeNaquadahReactor", "Thorium Based Liquid Fuel Basic Output Voltage", NaquadahFuelVoltage[1])
+            .getInt();
+        NaquadahFuelTime[1] = GG_Config
+            .get("LargeNaquadahReactor", "Thorium Based Liquid Fuel Burning Time", NaquadahFuelTime[1])
+            .getInt();
+        NaquadahFuelVoltage[2] = GG_Config
+            .get("LargeNaquadahReactor", "Plutonium Based Liquid Fuel Basic Output Voltage", NaquadahFuelVoltage[2])
+            .getInt();
+        NaquadahFuelTime[2] = GG_Config
+            .get("LargeNaquadahReactor", "Plutonium Based Liquid Fuel Burning Time", NaquadahFuelTime[2])
+            .getInt();
+        NaquadahFuelVoltage[3] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkI Basic Output Voltage", NaquadahFuelVoltage[3])
+            .getInt();
+        NaquadahFuelTime[3] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkI Burning Time", NaquadahFuelTime[3])
+            .getInt();
+        NaquadahFuelVoltage[4] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkII Basic Output Voltage", NaquadahFuelVoltage[4])
+            .getInt();
+        NaquadahFuelTime[4] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkII Burning Time", NaquadahFuelTime[4])
+            .getInt();
+        NaquadahFuelVoltage[5] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkIII Basic Output Voltage", NaquadahFuelVoltage[5])
+            .getInt();
+        NaquadahFuelTime[5] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkIII Burning Time", NaquadahFuelTime[5])
+            .getInt();
+        NaquadahFuelVoltage[6] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkIV Basic Output Voltage", NaquadahFuelVoltage[6])
+            .getInt();
+        NaquadahFuelTime[6] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkIV Burning Time", NaquadahFuelTime[6])
+            .getInt();
+        NaquadahFuelVoltage[7] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkV Basic Output Voltage", NaquadahFuelVoltage[7])
+            .getInt();
+        NaquadahFuelTime[7] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkV Burning Time", NaquadahFuelTime[7])
+            .getInt();
+        NaquadahFuelVoltage[8] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkVI Basic Output Voltage", NaquadahFuelVoltage[8])
+            .getInt();
+        NaquadahFuelTime[8] = GG_Config
+            .get("LargeNaquadahReactor", "Naquadah Fuel MkVI Burning Time", NaquadahFuelTime[8])
+            .getInt();
+        CoolantEfficiency[0] = GG_Config.get("LargeNaquadahReactor", "Tachyon Fluid Efficiency", CoolantEfficiency[0])
+            .getInt();
+        CoolantEfficiency[1] = GG_Config.get("LargeNaquadahReactor", "Cryotheum Efficiency", CoolantEfficiency[1])
+            .getInt();
+        CoolantEfficiency[2] = GG_Config.get("LargeNaquadahReactor", "Super Coolant Efficiency", CoolantEfficiency[2])
+            .getInt();
+        CoolantEfficiency[3] = GG_Config.get("LargeNaquadahReactor", "IC2 Coolant Efficiency", CoolantEfficiency[3])
+            .getInt();
+        ExcitedLiquidCoe[0] = GG_Config
+            .get("LargeNaquadahReactor", "Spatially Enlarged Fluid Magnification", ExcitedLiquidCoe[0])
+            .getInt();
+        ExcitedLiquidCoe[1] = GG_Config
+            .get("LargeNaquadahReactor", "Atomic Separation Catalyst Magnification", ExcitedLiquidCoe[1])
+            .getInt();
+        ExcitedLiquidCoe[2] = GG_Config.get("LargeNaquadahReactor", "Naquadah Magnification", ExcitedLiquidCoe[2])
+            .getInt();
+        ExcitedLiquidCoe[3] = GG_Config.get("LargeNaquadahReactor", "Uranium-235 Magnification", ExcitedLiquidCoe[3])
+            .getInt();
+        ExcitedLiquidCoe[4] = GG_Config.get("LargeNaquadahReactor", "Caesium Magnification", ExcitedLiquidCoe[4])
+            .getInt();
+        LiquidAirConsumptionPerSecond = Math.max(
+            GG_Config.get("LargeNaquadahReactor", "Liquid Air Consumption Per Second", LiquidAirConsumptionPerSecond)
+                .getInt(),
+            0);
+
+        EnableNaquadahRework = GG_Config.get("NaquadahRework", "Enable Naquadah Rework", EnableNaquadahRework)
+            .getBoolean();
+
+        if (GG_Config.hasChanged()) GG_Config.save();
+    }
+
+    private static void loadCategory() {
+        GG_Config
+            .addCustomCategoryComment("LargeNaquadahReactor", "Set fuel value, coolant or excited liquid property.");
+        GG_Config.addCustomCategoryComment("NaquadahRework", "About the naquadah line");
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/main/GoodGenerator.java b/goodgen/src/main/java/goodgenerator/main/GoodGenerator.java
new file mode 100644
index 0000000000..ad2c3eb0e9
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/main/GoodGenerator.java
@@ -0,0 +1,86 @@
+package goodgenerator.main;
+
+import net.minecraft.creativetab.CreativeTabs;
+
+import com.github.bartimaeusnek.bartworks.API.WerkstoffAdderRegistry;
+
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.SidedProxy;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper;
+import goodgenerator.Tags;
+import goodgenerator.common.CommonProxy;
+import goodgenerator.crossmod.thaumcraft.Research;
+import goodgenerator.items.MyMaterial;
+import goodgenerator.loader.Loaders;
+import goodgenerator.loader.NaquadahReworkRecipeLoader;
+import goodgenerator.tabs.MyTabs;
+
+@SuppressWarnings("ALL")
+@Mod(
+    modid = GoodGenerator.MOD_ID,
+    version = GoodGenerator.VERSION,
+    dependencies = "required-after:IC2; " + "required-after:gregtech; "
+        + "required-after:bartworks; "
+        + "required-after:tectech; "
+        + "required-after:structurelib; "
+        + "before:miscutils; "
+        + "after:dreamcraft;")
+public final class GoodGenerator {
+
+    public static final String MOD_ID = "GoodGenerator";
+    public static final String MOD_NAME = "Good Generator";
+    public static final String VERSION = Tags.VERSION;
+
+    public static final CreativeTabs GG = new MyTabs("Good Generator");
+
+    @SidedProxy(clientSide = "goodgenerator.client.ClientProxy", serverSide = "goodgenerator.common.CommonProxy")
+    public static CommonProxy proxy;
+
+    public static SimpleNetworkWrapper CHANNEL = NetworkRegistry.INSTANCE.newSimpleChannel(MOD_ID);
+
+    static {}
+
+    @Mod.Instance(GoodGenerator.MOD_ID)
+    public static GoodGenerator instance;
+
+    @Mod.EventHandler
+    public static void preInit(FMLPreInitializationEvent event) {
+        GG_Config_Loader.run();
+        WerkstoffAdderRegistry.addWerkstoffAdder(new MyMaterial());
+        // WerkstoffAdderRegistry.addWerkstoffAdder(new IsotopeMaterialLoader());
+        Loaders.preInitLoad();
+        proxy.preInit(event);
+    }
+
+    @Mod.EventHandler
+    public static void init(FMLInitializationEvent event) {
+        Loaders.initLoad();
+        proxy.init(event);
+    }
+
+    @Mod.EventHandler
+    public static void postInit(FMLPostInitializationEvent event) {
+        Loaders.postInitLoad();
+        crossMod();
+        proxy.postInit(event);
+    }
+
+    @Mod.EventHandler
+    public void onLoadComplete(FMLLoadCompleteEvent event) {
+        // NaquadahReworkRecipeLoader.SmallRecipeChange();
+        NaquadahReworkRecipeLoader.Remover();
+        Loaders.completeLoad();
+    }
+
+    public static void crossMod() {
+        if (Loader.isModLoaded("Thaumcraft")) {
+            Research.addResearch();
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/network/MessageMTEBase.java b/goodgen/src/main/java/goodgenerator/network/MessageMTEBase.java
new file mode 100644
index 0000000000..4a9982d8d8
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/network/MessageMTEBase.java
@@ -0,0 +1,88 @@
+/*
+ * MIT License Copyright (c) 2021 Glease Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+package goodgenerator.network;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+
+import com.github.technus.tectech.TecTech;
+
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import cpw.mods.fml.relauncher.Side;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import io.netty.buffer.ByteBuf;
+
+public abstract class MessageMTEBase implements IMessage {
+
+    protected int w;
+    protected int x;
+    protected short y;
+    protected int z;
+
+    public MessageMTEBase() {}
+
+    public MessageMTEBase(IGregTechTileEntity tile) {
+        this.w = tile.getWorld().provider.dimensionId;
+        this.x = tile.getXCoord();
+        this.y = tile.getYCoord();
+        this.z = tile.getZCoord();
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        x = buf.readInt();
+        y = buf.readShort();
+        z = buf.readInt();
+        w = buf.readInt();
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(x);
+        buf.writeShort(y);
+        buf.writeInt(z);
+        buf.writeInt(w);
+    }
+
+    public abstract static class Handler<REQ extends MessageMTEBase, REPLY extends IMessage>
+        implements IMessageHandler<REQ, REPLY> {
+
+        protected abstract REPLY onError(REQ message, MessageContext ctx);
+
+        protected abstract REPLY onSuccess(REQ message, MessageContext ctx, IMetaTileEntity mte);
+
+        @Override
+        public REPLY onMessage(REQ message, MessageContext ctx) {
+            World world;
+            if (ctx.side == Side.SERVER) {
+                world = DimensionManager.getWorld(message.w);
+            } else {
+                world = TecTech.proxy.getClientWorld();
+                if (world.provider.dimensionId != message.w) return onError(message, ctx);
+            }
+            if (world == null) return onError(message, ctx);
+            if (world.blockExists(message.x, message.y, message.z)) {
+                TileEntity te = world.getTileEntity(message.x, message.y, message.z);
+                if (te instanceof IGregTechTileEntity && !((IGregTechTileEntity) te).isInvalidTileEntity()) {
+                    IMetaTileEntity mte = ((IGregTechTileEntity) te).getMetaTileEntity();
+                    if (mte != null) return onSuccess(message, ctx, mte);
+                }
+            }
+            return onError(message, ctx);
+        }
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/tabs/MyTabs.java b/goodgen/src/main/java/goodgenerator/tabs/MyTabs.java
new file mode 100644
index 0000000000..3493abbe3b
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/tabs/MyTabs.java
@@ -0,0 +1,18 @@
+package goodgenerator.tabs;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+
+import goodgenerator.loader.Loaders;
+
+public class MyTabs extends CreativeTabs {
+
+    public MyTabs(String name) {
+        super(name);
+    }
+
+    @Override
+    public Item getTabIconItem() {
+        return Loaders.radiationProtectionPlate;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/tabs/NuclearTab.java b/goodgen/src/main/java/goodgenerator/tabs/NuclearTab.java
new file mode 100644
index 0000000000..867e1c9141
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/tabs/NuclearTab.java
@@ -0,0 +1,16 @@
+package goodgenerator.tabs;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+
+public class NuclearTab extends CreativeTabs {
+
+    public NuclearTab() {
+        super("Nuclear Items");
+    }
+
+    @Override
+    public Item getTabIconItem() {
+        return null;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/CharExchanger.java b/goodgen/src/main/java/goodgenerator/util/CharExchanger.java
new file mode 100644
index 0000000000..96019eecd1
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/CharExchanger.java
@@ -0,0 +1,52 @@
+package goodgenerator.util;
+
+import net.minecraft.util.EnumChatFormatting;
+
+public class CharExchanger {
+
+    public static final String[] tierName = new String[] { EnumChatFormatting.RED + "ULV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.GRAY + "LV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.AQUA + "MV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.GOLD + "HV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_PURPLE + "EV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_BLUE + "IV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.LIGHT_PURPLE + "LuV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.WHITE + "ZPM" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_AQUA + "UV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_RED + "UHV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.GREEN + "UEV" + EnumChatFormatting.RESET, };
+
+    public static char shifter(int unicode) {
+        return (char) unicode;
+    }
+
+    public static String formatNumber(String exp) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < exp.length(); ++i) {
+            if (Character.isDigit(exp.charAt(i))) {
+                int cnt = 0, prt = i;
+                while (i < exp.length() && Character.isDigit(exp.charAt(i))) {
+                    i++;
+                    cnt++;
+                }
+                while (prt < exp.length() && Character.isDigit(exp.charAt(prt))) {
+                    sb.append(exp.charAt(prt));
+                    prt++;
+                    cnt--;
+                    if (cnt % 3 == 0 && cnt != 0) sb.append(",");
+                }
+            }
+            if (i < exp.length()) sb.append(exp.charAt(i));
+        }
+        return sb.toString();
+    }
+
+    public static String[] genString(String content, int len) {
+        String[] ret = new String[len];
+        while (len > 0) {
+            len--;
+            ret[len] = content;
+        }
+        return ret;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/CrackRecipeAdder.java b/goodgen/src/main/java/goodgenerator/util/CrackRecipeAdder.java
new file mode 100644
index 0000000000..dddb7fe69d
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/CrackRecipeAdder.java
@@ -0,0 +1,624 @@
+package goodgenerator.util;
+
+import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes;
+import static gregtech.api.recipe.RecipeMaps.crackingRecipes;
+import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes;
+import static gregtech.api.recipe.RecipeMaps.distilleryRecipes;
+import static gregtech.api.recipe.RecipeMaps.extruderRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.wiremillRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Fluid;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_RecipeBuilder;
+import gregtech.api.util.GT_Utility;
+
+public class CrackRecipeAdder {
+
+    static float[] coe1 = { 1.25f, 1.2f, 1.1f, 0.9f, 0.85f, 0.8f, 0.75f };
+    static float[] coe2 = { 1.4f, 1.25f, 1.2f, 0.8f, 0.75f, 0.7f, 0.65f };
+    static float[] coe3 = { 1.6f, 1.5f, 1.45f, 0.7f, 0.6f, 0.55f, 0.45f };
+
+    public static void crackerAdder(FluidStack inputFluid, FluidStack cracker, FluidStack[] outputFluids,
+        ItemStack outputItem, int num, int EUt, int Duration) {
+
+        String name;
+        FluidStack[] actOutput = new FluidStack[num];
+        name = inputFluid.getFluid()
+            .getName()
+            .replaceAll(" ", "");
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(inputFluid, cracker)
+            .fluidOutputs(FluidRegistry.getFluidStack("lightlycracked" + name, 1000))
+            .duration(Math.max((long) (Duration * 0.8), 1L) * TICKS)
+            .eut(EUt)
+            .addTo(crackingRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(inputFluid, cracker)
+            .fluidOutputs(FluidRegistry.getFluidStack("moderatelycracked" + name, 1000))
+            .duration(Math.max((long) (Duration), 1L) * TICKS)
+            .eut(EUt)
+            .addTo(crackingRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(3))
+            .fluidInputs(inputFluid, cracker)
+            .fluidOutputs(FluidRegistry.getFluidStack("heavilycracked" + name, 1000))
+            .duration(Math.max((long) (Duration * 1.2), 1L) * TICKS)
+            .eut(EUt)
+            .addTo(crackingRecipes);
+
+        for (int i = num - 1, j = 0; i >= 0; i--, j++) {
+            Fluid tmp1 = outputFluids[i].getFluid();
+            int tmp2 = (int) (outputFluids[i].amount * coe1[i]);
+            actOutput[j] = new FluidStack(tmp1, tmp2);
+        }
+
+        addUniversalDistillationRecipe(
+            FluidRegistry.getFluidStack("lightlycracked" + name, 1000),
+            actOutput,
+            outputItem,
+            Duration / 2,
+            EUt / 3);
+
+        for (int i = num - 1, j = 0; i >= 0; i--, j++) {
+            Fluid tmp1 = outputFluids[i].getFluid();
+            int tmp2 = (int) (outputFluids[i].amount * coe2[i]);
+            actOutput[j] = new FluidStack(tmp1, tmp2);
+        }
+
+        addUniversalDistillationRecipe(
+            FluidRegistry.getFluidStack("moderatelycracked" + name, 1000),
+            actOutput,
+            outputItem,
+            Duration / 2,
+            EUt / 3);
+
+        for (int i = num - 1, j = 0; i >= 0; i--, j++) {
+            Fluid tmp1 = outputFluids[i].getFluid();
+            int tmp2 = (int) (outputFluids[i].amount * coe3[i]);
+            actOutput[j] = new FluidStack(tmp1, tmp2);
+        }
+
+        addUniversalDistillationRecipe(
+            FluidRegistry.getFluidStack("heavilycracked" + name, 1000),
+            actOutput,
+            outputItem,
+            Duration / 2,
+            EUt / 3);
+    }
+
+    public static void reAddBlastRecipe(Werkstoff material, int duration, int EUt, int level, boolean gas) {
+        ItemStack input = material.get(OrePrefixes.dust, 1);
+        ItemStack output = level > 1750 ? material.get(OrePrefixes.ingotHot, 1) : material.get(OrePrefixes.ingot, 1);
+        if (gas) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(input, GT_Utility.getIntegratedCircuit(11))
+                .fluidInputs(Materials.Helium.getGas(1000))
+                .itemOutputs(output)
+                .duration(duration * TICKS)
+                .eut(EUt)
+                .metadata(COIL_HEAT, level)
+                .addTo(blastFurnaceRecipes);
+        } else {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(input, GT_Utility.getIntegratedCircuit(1))
+                .itemOutputs(output)
+                .duration(duration * TICKS)
+                .eut(EUt)
+                .metadata(COIL_HEAT, level)
+                .addTo(blastFurnaceRecipes);
+        }
+    }
+
+    public static void addUniversalDistillationRecipewithCircuit(FluidStack aInput, ItemStack[] aCircuit,
+        FluidStack[] aOutputs, ItemStack aOutput2, int aDuration, long aEUt) {
+        for (int i = 0; i < Math.min(aOutputs.length, 11); i++) {
+            GT_RecipeBuilder buildDistillation = GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(i + 1));
+            if (aOutput2 != GT_Values.NI) {
+                buildDistillation.itemOutputs(aOutput2);
+            }
+            buildDistillation.fluidInputs(aInput)
+                .fluidOutputs(aOutputs[i])
+                .duration(2 * aDuration)
+                .eut(aEUt / 4)
+                .addTo(distilleryRecipes);
+        }
+        GT_RecipeBuilder buildDT = GT_Values.RA.stdBuilder()
+            .itemInputs(aCircuit);
+        if (aOutput2 != GT_Values.NI) {
+            buildDT.itemOutputs(aOutput2);
+        }
+        buildDT.fluidInputs(aInput)
+            .fluidOutputs(aOutputs)
+            .duration(aDuration)
+            .eut(aEUt)
+            .addTo(distillationTowerRecipes);
+    }
+
+    public static void addUniversalDistillationRecipe(FluidStack aInput, FluidStack[] aOutputs, ItemStack aOutput2,
+        int aDuration, long aEUt) {
+        for (int i = 0; i < Math.min(aOutputs.length, 11); i++) {
+            GT_RecipeBuilder buildDistillation = GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(i + 1));
+            if (aOutput2 != GT_Values.NI) {
+                buildDistillation.itemOutputs(aOutput2);
+            }
+            buildDistillation.fluidInputs(aInput)
+                .fluidOutputs(aOutputs[i])
+                .duration(2 * aDuration)
+                .eut(aEUt / 4)
+                .addTo(distilleryRecipes);
+        }
+        GT_RecipeBuilder buildDT = GT_Values.RA.stdBuilder();
+        if (aOutput2 != GT_Values.NI) {
+            buildDT.itemOutputs(aOutput2);
+        }
+        buildDT.fluidInputs(aInput)
+            .fluidOutputs(aOutputs)
+            .duration(aDuration)
+            .eut(aEUt)
+            .addTo(distillationTowerRecipes);
+    }
+
+    public static FluidStack copyFluidWithAmount(FluidStack fluid, int amount) {
+        if (fluid == null || amount <= 0) return null;
+        return new FluidStack(fluid.getFluid(), amount);
+    }
+
+    public static void registerPipe(int ID, Werkstoff material, int flow, int temp, boolean gas) {
+        String unName = material.getDefaultName()
+            .replace(" ", "_");
+        String Name = material.getDefaultName();
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeTiny.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID,
+                "GT_Pipe_" + unName + "_Tiny",
+                "Tiny " + Name + " Fluid Pipe",
+                0.25F,
+                material.getBridgeMaterial(),
+                flow / 6,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeSmall.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 1,
+                "GT_Pipe_" + unName + "_Small",
+                "Small " + Name + " Fluid Pipe",
+                0.375F,
+                material.getBridgeMaterial(),
+                flow / 3,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeMedium.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 2,
+                "GT_Pipe_" + unName,
+                Name + " Fluid Pipe",
+                0.5F,
+                material.getBridgeMaterial(),
+                flow,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeLarge.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 3,
+                "GT_Pipe_" + unName + "_Large",
+                "Large " + Name + " Fluid Pipe",
+                0.75F,
+                material.getBridgeMaterial(),
+                flow * 2,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeHuge.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 4,
+                "GT_Pipe_" + unName + "_Huge",
+                "Huge " + Name + " Fluid Pipe",
+                0.875F,
+                material.getBridgeMaterial(),
+                flow * 4,
+                temp,
+                gas).getStackForm(1L));
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Pipe_Tiny.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeTiny, 2))
+            .duration(
+                material.getStats()
+                    .getMass() * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Pipe_Small.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeSmall, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 2
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 3), ItemList.Shape_Extruder_Pipe_Medium.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeMedium, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 6
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 6), ItemList.Shape_Extruder_Pipe_Large.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeLarge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 12
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 12), ItemList.Shape_Extruder_Pipe_Huge.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeHuge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 24
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Tiny.get(0))
+            .fluidInputs(material.getMolten(72))
+            .itemOutputs(material.get(OrePrefixes.pipeTiny, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Small.get(0))
+            .fluidInputs(material.getMolten(144))
+            .itemOutputs(material.get(OrePrefixes.pipeSmall, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 2
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Medium.get(0))
+            .fluidInputs(material.getMolten(432))
+            .itemOutputs(material.get(OrePrefixes.pipeMedium, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 6
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Large.get(0))
+            .fluidInputs(material.getMolten(864))
+            .itemOutputs(material.get(OrePrefixes.pipeLarge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 12
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Huge.get(0))
+            .fluidInputs(material.getMolten(1728))
+            .itemOutputs(material.get(OrePrefixes.pipeHuge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 24
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+    }
+
+    public static void registerWire(int ID, Werkstoff material, int aAmperage, int aVoltage, int aLoss, boolean cover) {
+        String unName = material.getDefaultName()
+            .replace(" ", "_")
+            .toLowerCase();
+        String Name = material.getDefaultName();
+        String aTextWire1 = "wire.";
+        String aTextCable1 = "cable.";
+        String aTextWire2 = " Wire";
+        String aTextCable2 = " Cable";
+        int aLossInsulated = aLoss / 4;
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt01,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 0,
+                aTextWire1 + unName + ".01",
+                "1x " + Name + aTextWire2,
+                0.125F,
+                material.getBridgeMaterial(),
+                aLoss,
+                1L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt02,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 1,
+                aTextWire1 + unName + ".02",
+                "2x " + Name + aTextWire2,
+                0.25F,
+                material.getBridgeMaterial(),
+                aLoss,
+                2L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt04,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 2,
+                aTextWire1 + unName + ".04",
+                "4x " + Name + aTextWire2,
+                0.375F,
+                material.getBridgeMaterial(),
+                aLoss,
+                4L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt08,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 3,
+                aTextWire1 + unName + ".08",
+                "8x " + Name + aTextWire2,
+                0.5F,
+                material.getBridgeMaterial(),
+                aLoss,
+                8L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt12,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 4,
+                aTextWire1 + unName + ".12",
+                "12x " + Name + aTextWire2,
+                0.625F,
+                material.getBridgeMaterial(),
+                aLoss,
+                12L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt16,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 5,
+                aTextWire1 + unName + ".16",
+                "16x " + Name + aTextWire2,
+                0.75F,
+                material.getBridgeMaterial(),
+                aLoss,
+                16L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        if (cover) {
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt01,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 6,
+                    aTextCable1 + unName + ".01",
+                    "1x " + Name + aTextCable2,
+                    0.25F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    1L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt02,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 7,
+                    aTextCable1 + unName + ".02",
+                    "2x " + Name + aTextCable2,
+                    0.375F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    2L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt04,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 8,
+                    aTextCable1 + unName + ".04",
+                    "4x " + Name + aTextCable2,
+                    0.5F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    4L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt08,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 9,
+                    aTextCable1 + unName + ".08",
+                    "8x " + Name + aTextCable2,
+                    0.625F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    8L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt12,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 10,
+                    aTextCable1 + unName + ".12",
+                    "12x " + Name + aTextCable2,
+                    0.75F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    12L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt16,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 11,
+                    aTextCable1 + unName + ".16",
+                    "16x " + Name + aTextCable2,
+                    0.875F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    16L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+        }
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(material.get(OrePrefixes.wireGt01, 2))
+            .duration(5 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(material.get(OrePrefixes.wireGt02, 1))
+            .duration(7 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 2), GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(material.get(OrePrefixes.wireGt04, 1))
+            .duration(10 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 4), GT_Utility.getIntegratedCircuit(8))
+            .itemOutputs(material.get(OrePrefixes.wireGt08, 1))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 6), GT_Utility.getIntegratedCircuit(12))
+            .itemOutputs(material.get(OrePrefixes.wireGt12, 1))
+            .duration(15 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 8), GT_Utility.getIntegratedCircuit(16))
+            .itemOutputs(material.get(OrePrefixes.wireGt16, 1))
+            .duration(17 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(material.get(OrePrefixes.wireGt01, 1))
+            .duration(2 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 2), GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(material.get(OrePrefixes.wireGt02, 1))
+            .duration(5 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 4), GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(material.get(OrePrefixes.wireGt04, 1))
+            .duration(7 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 8), GT_Utility.getIntegratedCircuit(8))
+            .itemOutputs(material.get(OrePrefixes.wireGt08, 1))
+            .duration(10 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 12), GT_Utility.getIntegratedCircuit(12))
+            .itemOutputs(material.get(OrePrefixes.wireGt12, 1))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 16), GT_Utility.getIntegratedCircuit(16))
+            .itemOutputs(material.get(OrePrefixes.wireGt16, 1))
+            .duration(15 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(3))
+            .itemOutputs(material.get(OrePrefixes.wireFine, 8))
+            .duration(5 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(3))
+            .itemOutputs(material.get(OrePrefixes.wireFine, 4))
+            .duration(2 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.wireGt01, 1), GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(material.get(OrePrefixes.wireFine, 4))
+            .duration(10 * SECONDS)
+            .eut(8)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Wire.get(0))
+            .itemOutputs(material.get(OrePrefixes.wireGt01, 2))
+            .duration(
+                material.getStats()
+                    .getMass() * 8
+                    * TICKS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(extruderRecipes);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/DescTextLocalization.java b/goodgen/src/main/java/goodgenerator/util/DescTextLocalization.java
new file mode 100644
index 0000000000..3470737d6b
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/DescTextLocalization.java
@@ -0,0 +1,22 @@
+package goodgenerator.util;
+
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+
+public class DescTextLocalization {
+
+    public static final String BLUE_PRINT_INFO = "Follow the" + EnumChatFormatting.BLUE
+        + " Structure"
+        + EnumChatFormatting.DARK_BLUE
+        + "Lib"
+        + EnumChatFormatting.GRAY
+        + " hologram projector to build the main structure.";
+
+    public static String[] addText(String preFix, int length) {
+        String[] text = new String[length];
+        for (int i = 0; i < length; i++) {
+            text[i] = StatCollector.translateToLocal(preFix + "." + i);
+        }
+        return text;
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/ItemRefer.java b/goodgen/src/main/java/goodgenerator/util/ItemRefer.java
new file mode 100644
index 0000000000..400199ef03
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/ItemRefer.java
@@ -0,0 +1,221 @@
+package goodgenerator.util;
+
+import static goodgenerator.loader.FuelRodLoader.*;
+import static goodgenerator.loader.Loaders.*;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.util.GT_Utility;
+import ic2.core.Ic2Items;
+
+public final class ItemRefer {
+
+    public static ItemRefer NULL = getItemStack(_null_);
+
+    public static ItemRefer Radiation_Protection_Plate = getItemStack(radiationProtectionPlate);
+    public static ItemRefer Wrapped_Uranium_Ingot = getItemStack(wrappedUraniumIngot);
+    public static ItemRefer High_Density_Uranium_Nugget = getItemStack(highDensityUraniumNugget);
+    public static ItemRefer High_Density_Uranium = getItemStack(highDensityUranium);
+    public static ItemRefer Wrapped_Thorium_Ingot = getItemStack(wrappedThoriumIngot);
+    public static ItemRefer High_Density_Thorium_Nugget = getItemStack(highDensityThoriumNugget);
+    public static ItemRefer High_Density_Thorium = getItemStack(highDensityThorium);
+    public static ItemRefer Wrapped_Plutonium_Ingot = getItemStack(wrappedPlutoniumIngot);
+    public static ItemRefer High_Density_Plutonium_Nugget = getItemStack(highDensityPlutoniumNugget);
+    public static ItemRefer High_Density_Plutonium = getItemStack(highDensityPlutonium);
+    public static ItemRefer Raw_Atomic_Separation_Catalyst = getItemStack(rawAtomicSeparationCatalyst);
+    public static ItemRefer Advanced_Radiation_Protection_Plate = getItemStack(advancedRadiationProtectionPlate);
+    public static ItemRefer Aluminum_Nitride_Dust = getItemStack(aluminumNitride);
+    public static ItemRefer Special_Ceramics_Dust = getItemStack(specialCeramics);
+    public static ItemRefer Special_Ceramics_Plate = getItemStack(specialCeramicsPlate);
+    public static ItemRefer Radioactive_Waste = getItemStack(radioactiveWaste);
+    public static ItemRefer Plastic_Case = getItemStack(plasticCase);
+    public static ItemRefer Quartz_Wafer = getItemStack(quartzWafer);
+    public static ItemRefer Micro_Heater = getItemStack(microHeater);
+    public static ItemRefer Quartz_Crystal_Resonator = getItemStack(quartzCrystalResonator);
+    public static ItemRefer Inverter = getItemStack(inverter);
+    public static ItemRefer Neutron_Source = getItemStack(neutronSource);
+    public static ItemRefer Naquadah_Mass = getItemStack(naquadahMass);
+    public static ItemRefer Enriched_Naquadah_Mass = getItemStack(enrichedNaquadahMass);
+    public static ItemRefer Naquadria_Mass = getItemStack(naquadriaMass);
+    public static ItemRefer Advanced_Fuel_Rod = getItemStack(advancedFuelRod);
+    public static ItemRefer Fuel_Rod_U_Depleted_1 = getItemStack(rodCompressedUraniumDepleted);
+    public static ItemRefer Fuel_Rod_U_Depleted_2 = getItemStack(rodCompressedUraniumDepleted_2);
+    public static ItemRefer Fuel_Rod_U_Depleted_4 = getItemStack(rodCompressedUraniumDepleted_4);
+    public static ItemRefer Fuel_Rod_U_1 = getItemStack(rodCompressedUranium);
+    public static ItemRefer Fuel_Rod_U_2 = getItemStack(rodCompressedUranium_2);
+    public static ItemRefer Fuel_Rod_U_4 = getItemStack(rodCompressedUranium_4);
+    public static ItemRefer Fuel_Rod_Pu_Depleted_1 = getItemStack(rodCompressedPlutoniumDepleted);
+    public static ItemRefer Fuel_Rod_Pu_Depleted_2 = getItemStack(rodCompressedPlutoniumDepleted_2);
+    public static ItemRefer Fuel_Rod_Pu_Depleted_4 = getItemStack(rodCompressedPlutoniumDepleted_4);
+    public static ItemRefer Fuel_Rod_Pu_1 = getItemStack(rodCompressedPlutonium);
+    public static ItemRefer Fuel_Rod_Pu_2 = getItemStack(rodCompressedPlutonium_2);
+    public static ItemRefer Fuel_Rod_Pu_4 = getItemStack(rodCompressedPlutonium_4);
+    public static ItemRefer Fuel_Rod_LU_Depleted_1 = getItemStack(rodLiquidUraniumDepleted);
+    public static ItemRefer Fuel_Rod_LU_Depleted_2 = getItemStack(rodLiquidUraniumDepleted_2);
+    public static ItemRefer Fuel_Rod_LU_Depleted_4 = getItemStack(rodLiquidUraniumDepleted_4);
+    public static ItemRefer Fuel_Rod_LU_1 = getItemStack(rodLiquidUranium);
+    public static ItemRefer Fuel_Rod_LU_2 = getItemStack(rodLiquidUranium_2);
+    public static ItemRefer Fuel_Rod_LU_4 = getItemStack(rodLiquidUranium_4);
+    public static ItemRefer Fuel_Rod_LPu_Depleted_1 = getItemStack(rodLiquidPlutoniumDepleted);
+    public static ItemRefer Fuel_Rod_LPu_Depleted_2 = getItemStack(rodLiquidPlutoniumDepleted_2);
+    public static ItemRefer Fuel_Rod_LPu_Depleted_4 = getItemStack(rodLiquidPlutoniumDepleted_4);
+    public static ItemRefer Fuel_Rod_LPu_1 = getItemStack(rodLiquidPlutonium);
+    public static ItemRefer Fuel_Rod_LPu_2 = getItemStack(rodLiquidPlutonium_2);
+    public static ItemRefer Fuel_Rod_LPu_4 = getItemStack(rodLiquidPlutonium_4);
+    public static ItemRefer Fluid_Storage_Core_T1 = getItemStack(fluidCore, 0);
+    public static ItemRefer Fluid_Storage_Core_T2 = getItemStack(fluidCore, 1);
+    public static ItemRefer Fluid_Storage_Core_T3 = getItemStack(fluidCore, 2);
+    public static ItemRefer Fluid_Storage_Core_T4 = getItemStack(fluidCore, 3);
+    public static ItemRefer Fluid_Storage_Core_T5 = getItemStack(fluidCore, 4);
+    public static ItemRefer Fluid_Storage_Core_T6 = getItemStack(fluidCore, 5);
+    public static ItemRefer Fluid_Storage_Core_T7 = getItemStack(fluidCore, 6);
+    public static ItemRefer Fluid_Storage_Core_T8 = getItemStack(fluidCore, 7);
+    public static ItemRefer Fluid_Storage_Core_T9 = getItemStack(fluidCore, 8);
+    public static ItemRefer Fluid_Storage_Core_T10 = getItemStack(fluidCore, 9);
+    public static ItemRefer Essentia_Upgrade_Empty = getItemStack(upgradeEssentia, 0);
+    public static ItemRefer Essentia_Upgrade_Air = getItemStack(upgradeEssentia, 1);
+    public static ItemRefer Essentia_Upgrade_Thermal = getItemStack(upgradeEssentia, 2);
+    public static ItemRefer Essentia_Upgrade_Unstable = getItemStack(upgradeEssentia, 3);
+    public static ItemRefer Essentia_Upgrade_Victus = getItemStack(upgradeEssentia, 4);
+    public static ItemRefer Essentia_Upgrade_Tainted = getItemStack(upgradeEssentia, 5);
+    public static ItemRefer Essentia_Upgrade_Mechanics = getItemStack(upgradeEssentia, 6);
+    public static ItemRefer Essentia_Upgrade_Spirit = getItemStack(upgradeEssentia, 7);
+    public static ItemRefer Essentia_Upgrade_Radiation = getItemStack(upgradeEssentia, 8);
+    public static ItemRefer Essentia_Upgrade_Electric = getItemStack(upgradeEssentia, 9);
+    public static ItemRefer High_Energy_Mixture = getItemStack(highEnergyMixture);
+    public static ItemRefer Salty_Root = getItemStack(saltyRoot);
+    public static ItemRefer HiC_T1 = getItemStack(huiCircuit, 0);
+    public static ItemRefer HiC_T2 = getItemStack(huiCircuit, 1);
+    public static ItemRefer HiC_T3 = getItemStack(huiCircuit, 2);
+    public static ItemRefer HiC_T4 = getItemStack(huiCircuit, 3);
+    public static ItemRefer HiC_T5 = getItemStack(huiCircuit, 4);
+    public static ItemRefer IC2_Ir_Plate = getItemStack(Ic2Items.iridiumPlate);
+    public static ItemRefer IC2_Glass = getItemStack(Ic2Items.reinforcedGlass);
+
+    public static ItemRefer Field_Restriction_Casing = getItemStack(MAR_Casing);
+    public static ItemRefer Naquadah_Fuel_Refinery_Casing = getItemStack(FRF_Casings);
+    public static ItemRefer Field_Restriction_Coil_T1 = getItemStack(FRF_Coil_1);
+    public static ItemRefer Field_Restriction_Coil_T2 = getItemStack(FRF_Coil_2);
+    public static ItemRefer Field_Restriction_Coil_T3 = getItemStack(FRF_Coil_3);
+    public static ItemRefer Field_Restriction_Coil_T4 = getItemStack(FRF_Coil_4);
+    public static ItemRefer Radiation_Proof_Steel_Frame_Box = getItemStack(radiationProtectionSteelFrame);
+    public static ItemRefer Field_Restriction_Glass = getItemStack(fieldRestrictingGlass);
+    public static ItemRefer Raw_Cylinder = getItemStack(rawCylinder);
+    public static ItemRefer Titanium_Plated_Cylinder = getItemStack(titaniumPlatedCylinder);
+    public static ItemRefer Magic_Casing = getItemStack(magicCasing);
+    public static ItemRefer Speeding_Pipe = getItemStack(speedingPipe);
+    public static ItemRefer Essentia_Cell_T1 = getItemStack(essentiaCell, 0);
+    public static ItemRefer Essentia_Cell_T2 = getItemStack(essentiaCell, 1);
+    public static ItemRefer Essentia_Cell_T3 = getItemStack(essentiaCell, 2);
+    public static ItemRefer Essentia_Cell_T4 = getItemStack(essentiaCell, 3);
+    public static ItemRefer Essentia_Hatch = getItemStack(essentiaHatch);
+    public static ItemRefer YOTTank_Casing = getItemStack(yottaFluidTankCasing);
+    public static ItemRefer YOTTank_Cell_T1 = getItemStack(yottaFluidTankCell, 0);
+    public static ItemRefer YOTTank_Cell_T2 = getItemStack(yottaFluidTankCell, 1);
+    public static ItemRefer YOTTank_Cell_T3 = getItemStack(yottaFluidTankCell, 2);
+    public static ItemRefer YOTTank_Cell_T4 = getItemStack(yottaFluidTankCell, 3);
+    public static ItemRefer YOTTank_Cell_T5 = getItemStack(yottaFluidTankCell, 4);
+    public static ItemRefer YOTTank_Cell_T6 = getItemStack(yottaFluidTankCell, 5);
+    public static ItemRefer YOTTank_Cell_T7 = getItemStack(yottaFluidTankCell, 6);
+    public static ItemRefer YOTTank_Cell_T8 = getItemStack(yottaFluidTankCell, 7);
+    public static ItemRefer YOTTank_Cell_T9 = getItemStack(yottaFluidTankCell, 8);
+    public static ItemRefer YOTTank_Cell_T10 = getItemStack(yottaFluidTankCell, 9);
+    public static ItemRefer SC_Turbine_Casing = getItemStack(supercriticalFluidTurbineCasing);
+    public static ItemRefer Pressure_Resistant_Wall = getItemStack(pressureResistantWalls);
+    public static ItemRefer Precise_Electronic_Unit_T1 = getItemStack(preciseUnitCasing, 0);
+    public static ItemRefer Precise_Electronic_Unit_T2 = getItemStack(preciseUnitCasing, 1);
+    public static ItemRefer Precise_Electronic_Unit_T3 = getItemStack(preciseUnitCasing, 2);
+    public static ItemRefer Compact_Fusion_Coil_T0 = getItemStack(compactFusionCoil, 0);
+    public static ItemRefer Compact_Fusion_Coil_T1 = getItemStack(compactFusionCoil, 1);
+    public static ItemRefer Compact_Fusion_Coil_T2 = getItemStack(compactFusionCoil, 2);
+    public static ItemRefer Compact_Fusion_Coil_T3 = getItemStack(compactFusionCoil, 3);
+    public static ItemRefer Compact_Fusion_Coil_T4 = getItemStack(compactFusionCoil, 4);
+    public static ItemRefer Essentia_Filter_Casing = getItemStack(essentiaFilterCasing);
+    public static ItemRefer Essentia_Output_Hatch = getItemStack(essentiaOutputHatch);
+    public static ItemRefer Essentia_Output_Hatch_ME = getItemStack(essentiaOutputHatch_ME);
+
+    public static ItemRefer Large_Naquadah_Reactor = getItemStack(MAR);
+    public static ItemRefer Naquadah_Fuel_Refinery = getItemStack(FRF);
+    public static ItemRefer Universal_Chemical_Fuel_Engine = getItemStack(UCFE);
+    public static ItemRefer Large_Essentia_Generator = getItemStack(LEG);
+    public static ItemRefer YOTTank = getItemStack(YFT);
+    public static ItemRefer Combustion_Generator_EV = getItemStack(Generator_Diesel[0]);
+    public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]);
+    public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine);
+    public static ItemRefer Extreme_Heat_Exchanger = getItemStack(XHE);
+    public static ItemRefer Precise_Assembler = getItemStack(PA);
+    public static ItemRefer Compact_Fusion_MK1 = getItemStack(LFC[0]);
+    public static ItemRefer Compact_Fusion_MK2 = getItemStack(LFC[1]);
+    public static ItemRefer Compact_Fusion_MK3 = getItemStack(LFC[2]);
+    public static ItemRefer Compact_Fusion_MK4 = getItemStack(LFC[3]);
+    public static ItemRefer Compact_Fusion_MK5 = getItemStack(LFC[4]);
+    public static ItemRefer Large_Essentia_Smeltery = getItemStack(LES);
+    public static ItemRefer Coolant_Tower = getItemStack(CT);
+    public static ItemRefer Component_Assembly_Line = getItemStack(CompAssline);
+
+    public static ItemRefer Compassline_Casing_LV = getItemStack(componentAssemblylineCasing, 0);
+    public static ItemRefer Compassline_Casing_MV = getItemStack(componentAssemblylineCasing, 1);
+    public static ItemRefer Compassline_Casing_HV = getItemStack(componentAssemblylineCasing, 2);
+    public static ItemRefer Compassline_Casing_EV = getItemStack(componentAssemblylineCasing, 3);
+    public static ItemRefer Compassline_Casing_IV = getItemStack(componentAssemblylineCasing, 4);
+    public static ItemRefer Compassline_Casing_LuV = getItemStack(componentAssemblylineCasing, 5);
+    public static ItemRefer Compassline_Casing_ZPM = getItemStack(componentAssemblylineCasing, 6);
+    public static ItemRefer Compassline_Casing_UV = getItemStack(componentAssemblylineCasing, 7);
+    public static ItemRefer Compassline_Casing_UHV = getItemStack(componentAssemblylineCasing, 8);
+    public static ItemRefer Compassline_Casing_UEV = getItemStack(componentAssemblylineCasing, 9);
+    public static ItemRefer Compassline_Casing_UIV = getItemStack(componentAssemblylineCasing, 10);
+    public static ItemRefer Compassline_Casing_UMV = getItemStack(componentAssemblylineCasing, 11);
+    public static ItemRefer Compassline_Casing_UXV = getItemStack(componentAssemblylineCasing, 12);
+    public static ItemRefer Compassline_Casing_MAX = getItemStack(componentAssemblylineCasing, 13);
+
+    private Item mItem = null;
+    private Block mBlock = null;
+    private ItemStack mItemStack = null;
+    private int mMeta = 0;
+
+    private static ItemRefer getItemStack(ItemStack itemStack) {
+        if (itemStack == null) return NULL;
+        return new ItemRefer(itemStack);
+    }
+
+    private static ItemRefer getItemStack(Item item) {
+        return getItemStack(item, 0);
+    }
+
+    private static ItemRefer getItemStack(Item item, int meta) {
+        if (item == null) return NULL;
+        return new ItemRefer(item, meta);
+    }
+
+    private static ItemRefer getItemStack(Block block) {
+        return getItemStack(block, 0);
+    }
+
+    private static ItemRefer getItemStack(Block block, int meta) {
+        if (block == null) return NULL;
+        return new ItemRefer(block, meta);
+    }
+
+    private ItemRefer(Item item, int meta) {
+        mItem = item;
+        mMeta = meta;
+    }
+
+    private ItemRefer(Block block, int meta) {
+        mBlock = block;
+        mMeta = meta;
+    }
+
+    private ItemRefer(ItemStack itemStack) {
+        mItemStack = itemStack;
+    }
+
+    public ItemStack get(int amount) {
+        if (mItem != null) return new ItemStack(mItem, amount, mMeta);
+        if (mBlock != null) return new ItemStack(mBlock, amount, mMeta);
+        if (mItemStack != null) return GT_Utility.copyAmount(amount, mItemStack);
+        return new ItemStack(_null_, amount, 0);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/Log.java b/goodgen/src/main/java/goodgenerator/util/Log.java
new file mode 100644
index 0000000000..4cf9e40484
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/Log.java
@@ -0,0 +1,9 @@
+package goodgenerator.util;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class Log {
+
+    public static final Logger LOGGER = LogManager.getLogger("GoodGenerator");
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/MaterialFix.java b/goodgen/src/main/java/goodgenerator/util/MaterialFix.java
new file mode 100644
index 0000000000..32827b18b2
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/MaterialFix.java
@@ -0,0 +1,393 @@
+package goodgenerator.util;
+
+import static gregtech.api.recipe.RecipeMaps.benderRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.hammerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+
+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+
+public class MaterialFix {
+
+    public static void MaterialFluidExtractionFix(Werkstoff material) {
+        if (material.hasItemType(OrePrefixes.ingot)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.ingot))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(ItemList.Shape_Mold_Ingot.get(0))
+                .fluidInputs(material.getMolten(144))
+                .itemOutputs(material.get(OrePrefixes.ingot))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(TierEU.RECIPE_MV / 2)
+                .addTo(fluidSolidifierRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.plate)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.plate))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(ItemList.Shape_Mold_Plate.get(0))
+                .fluidInputs(material.getMolten(144))
+                .itemOutputs(material.get(OrePrefixes.plate))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(TierEU.RECIPE_MV / 2)
+                .addTo(fluidSolidifierRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.gearGtSmall)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.gearGtSmall))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.stickLong)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.stickLong))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.spring)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.spring))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.stick)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.stick))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.itemCasing)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.itemCasing))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.wireGt01)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.wireGt01))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.cableGt01)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.cableGt01))
+                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Ash, 2))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.foil)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.foil))
+                .fluidOutputs(material.getMolten(36))
+                .duration(8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.springSmall)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.springSmall))
+                .fluidOutputs(material.getMolten(36))
+                .duration(8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.ring)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.ring))
+                .fluidOutputs(material.getMolten(36))
+                .duration(8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.bolt)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.bolt))
+                .fluidOutputs(material.getMolten(18))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.wireFine)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.wireFine))
+                .fluidOutputs(material.getMolten(18))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.round)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.round))
+                .fluidOutputs(material.getMolten(16))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.screw)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.screw))
+                .fluidOutputs(material.getMolten(16))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.nugget)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.nugget))
+                .fluidOutputs(material.getMolten(16))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.rotor)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.rotor))
+                .fluidOutputs(material.getMolten(612))
+                .duration(136 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.gearGt)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.gearGt))
+                .fluidOutputs(material.getMolten(576))
+                .duration(128 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+    }
+
+    public static void addRecipeForMultiItems() {
+        for (Werkstoff tMaterial : Werkstoff.werkstoffHashSet) {
+            if (tMaterial == null) continue;
+            if (tMaterial.hasItemType(OrePrefixes.plateDouble) && tMaterial.hasItemType(OrePrefixes.ingotDouble)) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.plate, 2), GT_Utility.getIntegratedCircuit(2))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDouble, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 2,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingotDouble, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDouble, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass(),
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.plateDouble, 1),
+                    new Object[] { "P", "P", "h", 'P', tMaterial.get(OrePrefixes.plate, 1) });
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.ingotDouble, 1),
+                    new Object[] { "P", "P", "h", 'P', tMaterial.get(OrePrefixes.ingot, 1) });
+            }
+            if (tMaterial.hasItemType(OrePrefixes.plateTriple) && tMaterial.hasItemType(OrePrefixes.ingotTriple)) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.plate, 3), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 3,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingot, 3), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 3,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingotTriple, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass(),
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.plateTriple, 1),
+                    new Object[] { "B", "P", "h", 'P', tMaterial.get(OrePrefixes.plate, 1), 'B',
+                        tMaterial.get(OrePrefixes.plateDouble, 1) });
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.ingotTriple, 1),
+                    new Object[] { "B", "P", "h", 'P', tMaterial.get(OrePrefixes.ingot, 1), 'B',
+                        tMaterial.get(OrePrefixes.ingotDouble, 1) });
+            }
+            if (tMaterial.hasItemType(OrePrefixes.plateDense)) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.plate, 9), GT_Utility.getIntegratedCircuit(9))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 9,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingot, 9), GT_Utility.getIntegratedCircuit(9))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 9,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+
+                if (tMaterial.hasItemType(OrePrefixes.plateTriple) && tMaterial.hasItemType(OrePrefixes.ingotTriple)) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(tMaterial.get(OrePrefixes.plateTriple, 3), GT_Utility.getIntegratedCircuit(3))
+                        .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass() * 3,
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_MV / 2)
+                        .addTo(benderRecipes);
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(tMaterial.get(OrePrefixes.ingotTriple, 3), GT_Utility.getIntegratedCircuit(3))
+                        .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass() * 3,
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_MV / 2)
+                        .addTo(benderRecipes);
+                }
+            }
+            if (tMaterial.hasItemType(OrePrefixes.stick)) {
+                if (tMaterial.hasItemType(OrePrefixes.cellMolten)) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(ItemList.Shape_Mold_Rod.get(0))
+                        .fluidInputs(tMaterial.getMolten(72))
+                        .itemOutputs(tMaterial.get(OrePrefixes.stick, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass() >> 1,
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_HV)
+                        .addTo(fluidSolidifierRecipes);
+                }
+            }
+            if (tMaterial.hasItemType(OrePrefixes.stickLong)) {
+                if (tMaterial.hasItemType(OrePrefixes.cellMolten)) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(ItemList.Shape_Mold_Rod_Long.get(0))
+                        .fluidInputs(tMaterial.getMolten(144))
+                        .itemOutputs(tMaterial.get(OrePrefixes.stickLong, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass(),
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_HV)
+                        .addTo(fluidSolidifierRecipes);
+                }
+                if (tMaterial.hasItemType(OrePrefixes.stick)) {
+                    GT_ModHandler.addCraftingRecipe(
+                        tMaterial.get(OrePrefixes.stickLong, 1),
+                        new Object[] { "PhP", 'P', tMaterial.get(OrePrefixes.stick, 1) });
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(tMaterial.get(OrePrefixes.stick, 2))
+                        .itemOutputs(tMaterial.get(OrePrefixes.stickLong, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass(),
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_LV / 2)
+                        .addTo(hammerRecipes);
+                }
+            }
+            if (tMaterial.hasItemType(OrePrefixes.spring)) {
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.spring, 1),
+                    new Object[] { " s ", "fPx", " P ", 'P', tMaterial.get(OrePrefixes.stickLong, 1) });
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.stickLong, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.spring, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 2,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_LV / 2)
+                    .addTo(benderRecipes);
+            }
+            if (tMaterial.hasItemType(OrePrefixes.springSmall)) {
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.springSmall, 1),
+                    new Object[] { " s ", "fPx", 'P', tMaterial.get(OrePrefixes.stick, 1) });
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.springSmall, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass(),
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_LV / 2)
+                    .addTo(benderRecipes);
+            }
+        }
+        Materials tUHV = Materials.Longasssuperconductornameforuhvwire;
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.stick, tUHV, 2))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stickLong, tUHV, 1))
+            .duration(Math.max(tUHV.getMass(), 1L) * TICKS)
+            .eut(TierEU.RECIPE_LV / 2)
+            .addTo(hammerRecipes);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/MyRecipeAdder.java b/goodgen/src/main/java/goodgenerator/util/MyRecipeAdder.java
new file mode 100644
index 0000000000..6cc0eb585c
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/MyRecipeAdder.java
@@ -0,0 +1,72 @@
+package goodgenerator.util;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import goodgenerator.api.recipe.ExtremeHeatExchangerRecipe;
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+
+public class MyRecipeAdder {
+
+    public static final MyRecipeAdder instance = new MyRecipeAdder();
+
+    public void addLiquidMentalFuel(FluidStack input, FluidStack output, int EUt, int ticks) {
+        GoodGeneratorRecipeMaps.naquadahReactorFuels
+            .addRecipe(true, null, null, null, new FluidStack[] { input }, new FluidStack[] { output }, ticks, 0, EUt);
+    }
+
+    public void addNaquadahFuelRefineRecipe(FluidStack[] input1, ItemStack[] input2, FluidStack output, int EUt,
+        int ticks, int tier) {
+        GoodGeneratorRecipeMaps.naquadahFuelRefineFactoryRecipes
+            .addRecipe(false, input2, null, null, input1, new FluidStack[] { output }, ticks, EUt, tier);
+    }
+
+    public void addNeutronActivatorRecipe(FluidStack[] input1, ItemStack[] input2, FluidStack[] output1,
+        ItemStack[] output2, int ticks, int maxNKE, int minNKE) {
+        if (maxNKE <= 0) maxNKE = 1;
+        if (maxNKE >= 1100) maxNKE = 1100;
+        if (minNKE < 0) minNKE = 0;
+        if (minNKE >= maxNKE) minNKE = maxNKE - 1;
+        GoodGeneratorRecipeMaps.neutronActivatorRecipes
+            .addRecipe(false, input2, output2, null, input1, output1, ticks, 0, maxNKE * 10000 + minNKE);
+    }
+
+    public void addExtremeHeatExchangerRecipe(FluidStack HotFluid, FluidStack ColdFluid, FluidStack WorkFluid,
+        FluidStack HeatedWorkFluid, FluidStack OverHeatedWorkFluid, int Threshold) {
+        GoodGeneratorRecipeMaps.extremeHeatExchangerFuels.addRecipe(
+            new ExtremeHeatExchangerRecipe(
+                new FluidStack[] { HotFluid, WorkFluid },
+                new FluidStack[] { HeatedWorkFluid, OverHeatedWorkFluid, ColdFluid },
+                Threshold));
+    }
+
+    public void addPreciseAssemblerRecipe(ItemStack[] aItemInputs, FluidStack[] aFluidInputs, ItemStack aOutput,
+        int aEUt, int aDuration, int aTier) {
+        if (aOutput == null) return;
+        GoodGeneratorRecipeMaps.preciseAssemblerRecipes.addRecipe(
+            false,
+            aItemInputs,
+            new ItemStack[] { aOutput },
+            null,
+            null,
+            aFluidInputs,
+            null,
+            aDuration,
+            aEUt,
+            aTier);
+    }
+
+    public void addComponentAssemblyLineRecipe(ItemStack[] ItemInputArray, FluidStack[] FluidInputArray,
+        ItemStack OutputItem, int aDuration, int aEUt, int casingLevel) {
+        GoodGeneratorRecipeMaps.componentAssemblyLineRecipes.addRecipe(
+            false,
+            ItemInputArray,
+            new ItemStack[] { OutputItem },
+            null,
+            FluidInputArray,
+            null,
+            aDuration,
+            aEUt,
+            casingLevel);
+    }
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/StackUtils.java b/goodgen/src/main/java/goodgenerator/util/StackUtils.java
new file mode 100644
index 0000000000..2784828117
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/StackUtils.java
@@ -0,0 +1,143 @@
+package goodgenerator.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import appeng.api.AEApi;
+import appeng.api.storage.data.IAEFluidStack;
+import goodgenerator.items.MyMaterial;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.util.GT_Utility;
+
+public class StackUtils {
+
+    /**
+     * Multiplies one ItemStack by a multiplier, and splits it into as many full stacks as it needs to.
+     *
+     * @param stack      The ItemStack you want to multiply
+     * @param multiplier The number the stack is multiplied by
+     * @return A List of stacks that, in total, are the same as the input ItemStack after it has been multiplied.
+     */
+    public static List<ItemStack> multiplyAndSplitIntoStacks(ItemStack stack, int multiplier) {
+        int totalItems = stack.stackSize * multiplier;
+        ArrayList<ItemStack> stacks = new ArrayList<>();
+        if (totalItems >= 64) {
+            for (int i = 0; i < totalItems / 64; i++) {
+                stacks.add(GT_Utility.copyAmount(64, stack));
+            }
+        }
+        if (totalItems % 64 > 0) {
+            stacks.add(GT_Utility.copyAmount(totalItems % 64, stack));
+        }
+        return stacks;
+    }
+
+    /**
+     * Merges the ItemStacks in the array into full stacks.
+     */
+    public static ArrayList<ItemStack> mergeStacks(List<ItemStack> stacks) {
+        ArrayList<ItemStack> output = new ArrayList<>();
+        for (int index = 0; index < stacks.size(); index++) {
+            ItemStack i = stacks.get(index);
+            int newSize = i.stackSize;
+            for (int j = index + 1; j < stacks.size(); j++) {
+                ItemStack is2 = stacks.get(j);
+                if (GT_Utility.areStacksEqual(i, is2)) {
+                    newSize += is2.stackSize;
+                    stacks.remove(j);
+                    j--;
+                }
+            }
+            output.add(GT_Utility.copyAmountUnsafe(newSize, i));
+        }
+        return output;
+    }
+
+    /**
+     * Turns the {@code items} List into a {@code HashMap} containing each unique {@code ItemStack} as the key, and a
+     * value representing the total amount of the respective {@code ItemStack} in the List.
+     */
+    public static HashMap<ItemStack, Integer> getTotalItems(List<ItemStack> items) {
+        HashMap<ItemStack, Integer> totals = new HashMap<>();
+        itemLoop: for (ItemStack item : items) {
+            int t = items.stream()
+                .filter(i2 -> GT_Utility.areStacksEqual(item, i2))
+                .mapToInt(i -> i.stackSize)
+                .sum();
+            for (ItemStack i2 : totals.keySet()) if (GT_Utility.areStacksEqual(item, i2)) continue itemLoop;
+            totals.put(GT_Utility.copyAmount(1, item), t);
+        }
+        return totals;
+    }
+
+    /**
+     * Turns the {@code items} Array into a {@code HashMap} containing each unique {@code ItemStack} as the key, and a
+     * value representing the total amount of the respective {@code ItemStack} in the Array.
+     */
+    public static HashMap<ItemStack, Integer> getTotalItems(ItemStack[] items) {
+        return getTotalItems(Arrays.asList(items));
+    }
+
+    public static FluidStack getTieredFluid(int aTier, int aAmount) {
+        switch (aTier) {
+            case 0: // ULV
+                return Materials.RedAlloy.getMolten(aAmount);
+            case 1: // LV
+                return Materials.TinAlloy.getMolten(aAmount);
+            case 2: // MV
+                return Materials.RoseGold.getMolten(aAmount);
+            case 3: // HV
+                return MyMaterial.zircaloy4.getMolten(aAmount);
+            case 4: // EV
+                return MyMaterial.incoloy903.getMolten(aAmount);
+            case 5: // IV
+                return MyMaterial.titaniumBetaC.getMolten(aAmount);
+            case 6: // LuV
+                return MyMaterial.artheriumSn.getMolten(aAmount);
+            case 7: // ZPM
+                return MyMaterial.dalisenite.getMolten(aAmount);
+            case 8: // UV
+                return MyMaterial.tairitsu.getMolten(aAmount);
+            case 9: // UHV
+                return MyMaterial.preciousMetalAlloy.getMolten(aAmount);
+            case 10: // UEV
+                return MyMaterial.enrichedNaquadahAlloy.getMolten(aAmount);
+            case 11: // UIV
+                return MyMaterial.metastableOganesson.getMolten(aAmount);
+            case 12: // UMV
+                return MaterialsUEVplus.SpaceTime.getMolten(aAmount);
+            default:
+                return MyMaterial.shirabon.getMolten(aAmount);
+        }
+    }
+
+    // === Copied from AE2FC to avoid hard dep ===
+
+    public static IAEFluidStack createAEFluidStack(Fluid fluid) {
+        return createAEFluidStack(new FluidStack(fluid, FluidContainerRegistry.BUCKET_VOLUME));
+    }
+
+    public static IAEFluidStack createAEFluidStack(Fluid fluid, long amount) {
+        return createAEFluidStack(fluid.getID(), amount);
+    }
+
+    public static IAEFluidStack createAEFluidStack(FluidStack fluid) {
+        return AEApi.instance()
+            .storage()
+            .createFluidStack(fluid);
+    }
+
+    public static IAEFluidStack createAEFluidStack(int fluidId, long amount) {
+        return createAEFluidStack(new FluidStack(FluidRegistry.getFluid(fluidId), 1)).setStackSize(amount);
+    }
+
+}
diff --git a/goodgen/src/main/java/goodgenerator/util/StructureHelper.java b/goodgen/src/main/java/goodgenerator/util/StructureHelper.java
new file mode 100644
index 0000000000..e66ac9f9ee
--- /dev/null
+++ b/goodgen/src/main/java/goodgenerator/util/StructureHelper.java
@@ -0,0 +1,117 @@
+package goodgenerator.util;
+
+import java.util.Arrays;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.structure.IStructureElement;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Frame;
+import gregtech.api.util.GT_OreDictUnificator;
+
+public class StructureHelper {
+
+    public static <T> IStructureElement<T> addFrame(Materials aMaterials) {
+        return new IStructureElement<T>() {
+
+            private IIcon[] mIcons;
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                TileEntity tBlock = world.getTileEntity(x, y, z);
+                if (tBlock instanceof BaseMetaPipeEntity) {
+                    BaseMetaPipeEntity tFrame = (BaseMetaPipeEntity) tBlock;
+                    if (tFrame.isInvalidTileEntity()) return false;
+                    if (tFrame.getMetaTileEntity() instanceof GT_MetaPipeEntity_Frame) {
+                        return ((GT_MetaPipeEntity_Frame) tFrame.getMetaTileEntity()).mMaterial == aMaterials;
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                if (mIcons == null) {
+                    mIcons = new IIcon[6];
+                    Arrays.fill(mIcons, aMaterials.mIconSet.mTextures[OrePrefixes.frameGt.mTextureIndex].getIcon());
+                }
+                StructureLibAPI.hintParticleTinted(world, x, y, z, mIcons, aMaterials.mRGBa);
+                return true;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                ItemStack tFrame = GT_OreDictUnificator.get(OrePrefixes.frameGt, aMaterials, 1);
+                if (tFrame.getItem() instanceof ItemBlock) {
+                    ItemBlock tFrameStackItem = (ItemBlock) tFrame.getItem();
+                    return tFrameStackItem
+                        .placeBlockAt(tFrame, null, world, x, y, z, 6, 0, 0, 0, Items.feather.getDamage(tFrame));
+                }
+                return false;
+            }
+        };
+    }
+
+    // Only support to use meta to tier
+    public static <T> IStructureElement<T> addTieredBlock(Block aBlock, BiConsumer<T, Integer> aSetTheFuckingMeta,
+        Function<T, Integer> aGetTheFuckingMeta, int maxMeta) {
+        return addTieredBlock(aBlock, (t, i) -> {
+            aSetTheFuckingMeta.accept(t, i);
+            return true;
+        }, aGetTheFuckingMeta, maxMeta);
+    }
+
+    public static <T> IStructureElement<T> addTieredBlock(Block aBlock, BiPredicate<T, Integer> aSetTheFuckingMeta,
+        Function<T, Integer> aGetTheFuckingMeta, int maxMeta) {
+
+        return new IStructureElement<T>() {
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                Block tBlock = world.getBlock(x, y, z);
+                if (aBlock == tBlock) {
+                    Integer currentMeta = aGetTheFuckingMeta.apply(t);
+                    int newMeta = tBlock.getDamageValue(world, x, y, z) + 1;
+                    if (newMeta > maxMeta) return false;
+                    if (currentMeta == 0) {
+                        return aSetTheFuckingMeta.test(t, newMeta);
+                    } else {
+                        return currentMeta == newMeta;
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                StructureLibAPI.hintParticle(world, x, y, z, aBlock, getMeta(trigger));
+                return true;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return world.setBlock(x, y, z, aBlock, getMeta(trigger), 3);
+            }
+
+            private int getMeta(ItemStack trigger) {
+                int meta = trigger.stackSize - 1;
+                if (meta <= 0) meta = 0;
+                if (meta >= maxMeta) meta = maxMeta - 1;
+                return meta;
+            }
+        };
+    }
+}