Recipes ra2 (#1872)

* Recipes RA2 fixes

* Use \uXXXX for non-ASCII characters

* Misc cleanup (#1888)

* migrate away from addThermalCentrifugeRecipe

* split recipes of GT_Block_Stones_Abstract

* migrate away from addForgeHammerRecipe

* migrate away from addChemicalBathRecipe

* remove "DisableOldChemicalRecipes" and its usage, as it's disabled by default in NH and it increases recipe complexity for nothing

* Remove underground biomes ore classes, as it's not present in NH

* migrate away from addFluidCannerRecipe

* migrate away from addFluidExtractionRecipe

* migrate away from addChemicalRecipe

* migrate away from addMultiblockChemicalRecipe

* deprecate addChemicalRecipeForBasicMachineOnly

* migrate away from addCentrifugeRecipe

* spotlessApply

* fixing wrong merge conflict solving

* Add Tengam materials (#1891)

* Add Tengam materials

* Change new recipes to consume 15/16 Amp

* Remove now redundant `break` statements

* fix comb chances?

* fix centrifuge code not working

---------

Co-authored-by: glowredman <35727266+glowredman@users.noreply.github.com>
Co-authored-by: Martin Robertz <dream-master@gmx.net>

1 files changed, 196 insertions, 202 deletions

diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java
index 8c4ce4953c..e420017b79 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java
@@ -1,5 +1,7 @@
 package gregtech.loaders.oreprocessing;
 
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sBenderRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_Utility.calculateRecipeEU;
 
 import java.util.ArrayList;
@@ -18,9 +20,8 @@ import gregtech.common.GT_Proxy;
 
 public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistrator {
 
-    private Materials[] dielectrics = { Materials.PolyvinylChloride, Materials.Polydimethylsiloxane };
-    private Materials[] rubbers = { Materials.Rubber, Materials.StyreneButadieneRubber, Materials.Silicone };
-    private Materials[] syntheticRubbers = { Materials.StyreneButadieneRubber, Materials.Silicone };
+    private final Materials[] dielectrics = { Materials.PolyvinylChloride, Materials.Polydimethylsiloxane };
+    private final Materials[] syntheticRubbers = { Materials.StyreneButadieneRubber, Materials.Silicone };
 
     private static Object tt;
 
@@ -48,135 +49,167 @@ public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistr
 
         int cableWidth;
         OrePrefixes correspondingCable;
+
         switch (aPrefix) {
             case wireGt01 -> {
                 cableWidth = 1;
                 correspondingCable = OrePrefixes.cableGt01;
                 if (!aMaterial.contains(SubTag.NO_SMASHING)) {
-                    GT_Values.RA.addBenderRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 2L),
-                        100,
+                    // Bender recipes
+                    {
+                        GT_Values.RA.stdBuilder()
+                            .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 2L))
+                            .noFluidInputs()
+                            .noFluidOutputs()
+                            .duration(5 * SECONDS)
+                            .eut(calculateRecipeEU(aMaterial, 8))
+                            .addTo(sBenderRecipes);
+                    }
+
+                    // Wiremill Recipes
+                    {
+                        GT_Values.RA.addWiremillRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            GT_Utility.getIntegratedCircuit(1),
+                            GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 4L),
+                            200,
+                            calculateRecipeEU(aMaterial, 8));
+                    }
+                }
+
+                // crafting recipe
+                if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)
+                    && !aMaterial.contains(SubTag.NO_WORKING)
+                    && (aMaterial.getProcessingMaterialTierEU() < TierEU.IV)) {
+                    GT_ModHandler.addCraftingRecipe(
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 1L),
+                        GT_Proxy.tBits,
+                        new Object[] { "Xx", 'X', OrePrefixes.plate.get(aMaterial) });
+
+                }
+
+                // Assembler recipes
+                {
+                    GT_Values.RA.addAssemblerRecipe(
+                        GT_Utility.copyAmount(2L, aStack),
+                        GT_Utility.getIntegratedCircuit(2),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt02, aMaterial, 1L),
+                        150,
                         calculateRecipeEU(aMaterial, 8));
-                    GT_Values.RA.addWiremillRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        GT_Utility.getIntegratedCircuit(1),
-                        GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 4L),
+                    GT_Values.RA.addAssemblerRecipe(
+                        GT_Utility.copyAmount(4L, aStack),
+                        GT_Utility.getIntegratedCircuit(4),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt04, aMaterial, 1L),
                         200,
                         calculateRecipeEU(aMaterial, 8));
+                    GT_Values.RA.addAssemblerRecipe(
+                        GT_Utility.copyAmount(8L, aStack),
+                        GT_Utility.getIntegratedCircuit(8),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt08, aMaterial, 1L),
+                        300,
+                        calculateRecipeEU(aMaterial, 8));
+                    GT_Values.RA.addAssemblerRecipe(
+                        GT_Utility.copyAmount(12L, aStack),
+                        GT_Utility.getIntegratedCircuit(12),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt12, aMaterial, 1L),
+                        400,
+                        calculateRecipeEU(aMaterial, 8));
+                    GT_Values.RA.addAssemblerRecipe(
+                        GT_Utility.copyAmount(16L, aStack),
+                        GT_Utility.getIntegratedCircuit(16),
+                        GT_OreDictUnificator.get(OrePrefixes.wireGt16, aMaterial, 1L),
+                        500,
+                        calculateRecipeEU(aMaterial, 8));
                 }
-                if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)
-                    && !aMaterial.contains(SubTag.NO_WORKING)) {
-                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                        GT_ModHandler.addCraftingRecipe(
-                            GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 1L),
-                            GT_Proxy.tBits,
-                            new Object[] { "Xx", 'X', OrePrefixes.plate.get(aMaterial) });
-                    }
-                }
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(2L, aStack),
-                    GT_Utility.getIntegratedCircuit(2),
-                    GT_OreDictUnificator.get(OrePrefixes.wireGt02, aMaterial, 1L),
-                    150,
-                    calculateRecipeEU(aMaterial, 8));
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(4L, aStack),
-                    GT_Utility.getIntegratedCircuit(4),
-                    GT_OreDictUnificator.get(OrePrefixes.wireGt04, aMaterial, 1L),
-                    200,
-                    calculateRecipeEU(aMaterial, 8));
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(8L, aStack),
-                    GT_Utility.getIntegratedCircuit(8),
-                    GT_OreDictUnificator.get(OrePrefixes.wireGt08, aMaterial, 1L),
-                    300,
-                    calculateRecipeEU(aMaterial, 8));
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(12L, aStack),
-                    GT_Utility.getIntegratedCircuit(12),
-                    GT_OreDictUnificator.get(OrePrefixes.wireGt12, aMaterial, 1L),
-                    400,
-                    calculateRecipeEU(aMaterial, 8));
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(16L, aStack),
-                    GT_Utility.getIntegratedCircuit(16),
-                    GT_OreDictUnificator.get(OrePrefixes.wireGt16, aMaterial, 1L),
-                    500,
-                    calculateRecipeEU(aMaterial, 8));
             }
             case wireGt02 -> {
                 cableWidth = 2;
                 correspondingCable = OrePrefixes.cableGt02;
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 2L),
-                        new Object[] { aOreDictName });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) });
+                    // Shapeless crafting recipes
+                    {
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 2L),
+                            new Object[] { aOreDictName });
+
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) });
+                    }
                 }
             }
             case wireGt04 -> {
                 cableWidth = 4;
                 correspondingCable = OrePrefixes.cableGt04;
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 4L),
-                        new Object[] { aOreDictName });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
-                            OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt02.get(aMaterial), OrePrefixes.wireGt02.get(aMaterial) });
+                    // Shapeless crafting recipes
+                    {
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 4L),
+                            new Object[] { aOreDictName });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
+                                OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt02.get(aMaterial), OrePrefixes.wireGt02.get(aMaterial) });
+                    }
                 }
             }
             case wireGt08 -> {
                 cableWidth = 8;
                 correspondingCable = OrePrefixes.cableGt08;
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 8L),
-                        new Object[] { aOreDictName });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
-                            OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
-                            OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
-                            OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt04.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) });
+                    // Shapeless crafting recipes
+                    {
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 8L),
+                            new Object[] { aOreDictName });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
+                                OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
+                                OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial),
+                                OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt04.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) });
+                    }
                 }
             }
             case wireGt12 -> {
                 cableWidth = 12;
                 correspondingCable = OrePrefixes.cableGt12;
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 12L),
-                        new Object[] { aOreDictName });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) });
+                    // Shapeless crafting recipes
+                    {
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 12L),
+                            new Object[] { aOreDictName });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) });
+                    }
                 }
             }
             case wireGt16 -> {
                 cableWidth = 16;
                 correspondingCable = OrePrefixes.cableGt16;
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 16L),
-                        new Object[] { aOreDictName });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt08.get(aMaterial) });
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1L, aStack),
-                        new Object[] { OrePrefixes.wireGt12.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) });
+                    // Shapeless crafting recipes
+                    {
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 16L),
+                            new Object[] { aOreDictName });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt08.get(aMaterial) });
+                        GT_ModHandler.addShapelessCraftingRecipe(
+                            GT_Utility.copyAmount(1L, aStack),
+                            new Object[] { OrePrefixes.wireGt12.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) });
+                    }
 
                     if (GT_Mod.gregtechproxy.mAE2Integration) {
                         AE2addNewAttunement(aStack);
@@ -193,26 +226,32 @@ public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistr
         int costMultiplier = cableWidth / 4 + 1;
 
         switch (aMaterial.mName) {
-            case "RedAlloy":
-            case "Cobalt":
-            case "Lead":
-            case "Tin":
-            case "Zinc":
-            case "SolderingAlloy":
+            case "RedAlloy", "Cobalt", "Lead", "Tin", "Zinc", "SolderingAlloy":
                 ArrayList<Object> craftingListRubber = new ArrayList<>();
                 craftingListRubber.add(aOreDictName);
                 for (int i = 0; i < costMultiplier; i++) {
                     craftingListRubber.add(OrePrefixes.plate.get(Materials.Rubber));
                 }
+
+            // shapeless crafting
+            {
                 GT_ModHandler.addShapelessCraftingRecipe(
                     GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
                     craftingListRubber.toArray());
+            }
+
+            // Packer recipe
+            {
                 GT_Values.RA.addBoxingRecipe(
                     GT_Utility.copyAmount(1L, aStack),
                     GT_OreDictUnificator.get(OrePrefixes.plate.get(Materials.Rubber), costMultiplier),
                     GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
                     100,
                     8);
+            }
+
+            // alloy smelter recipes
+            {
                 GT_Values.RA.addAlloySmelterRecipe(
                     GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Rubber, 2L),
                     GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 1L),
@@ -231,22 +270,10 @@ public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistr
                     GT_OreDictUnificator.get(OrePrefixes.cableGt04, aMaterial, 1L),
                     300,
                     30);
-            case "Iron":
-            case "Nickel":
-            case "Cupronickel":
-            case "Copper":
-            case "AnnealedCopper":
-            case "Kanthal":
-            case "Gold":
-            case "Electrum":
-            case "Silver":
-            case "Blue Alloy":
-            case "Nichrome":
-            case "Steel":
-            case "BlackSteel":
-            case "Titanium":
-            case "Aluminium":
-            case "BlueAlloy":
+            }
+            case "Iron", "Nickel", "Cupronickel", "Copper", "AnnealedCopper", "Kanthal", "Gold", "Electrum", "Silver", "Blue Alloy", "Nichrome", "Steel", "BlackSteel", "Titanium", "Aluminium", "BlueAlloy":
+            // Assembler recipes
+            {
                 GT_Values.RA.addAssemblerRecipe(
                     aStack,
                     GT_Utility.getIntegratedCircuit(24),
@@ -284,7 +311,11 @@ public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistr
                             8);
                     }
                 }
+            }
+
             case "RedstoneAlloy":
+            // Assembler recipes
+            {
                 GT_Values.RA.addAssemblerRecipe(
                     aStack,
                     GT_Utility.getIntegratedCircuit(24),
@@ -322,102 +353,64 @@ public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistr
                             8);
                     }
                 }
+            }
                 break;
             default:
-                if (GT_Mod.gregtechproxy.mEasierIVPlusCables) {
-                    GT_Values.RA.addAssemblerRecipe(
-                        aStack,
-                        GT_Utility.getIntegratedCircuit(24),
-                        Materials.Rubber.getMolten(144 * costMultiplier),
-                        GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                        100,
-                        calculateRecipeEU(aMaterial, 8));
-                    GT_Values.RA.addAssemblerRecipe(
-                        aStack,
-                        GT_Utility.getIntegratedCircuit(24),
-                        Materials.StyreneButadieneRubber.getMolten(108 * costMultiplier),
-                        GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                        100,
-                        calculateRecipeEU(aMaterial, 8));
-                    GT_Values.RA.addAssemblerRecipe(
-                        aStack,
-                        GT_Utility.getIntegratedCircuit(24),
-                        Materials.Silicone.getMolten(72 * costMultiplier),
-                        GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                        100,
-                        calculateRecipeEU(aMaterial, 8));
-                    for (Materials dielectric : dielectrics) {
-                        for (Materials syntheticRubber : syntheticRubbers) {
-                            GT_Values.RA.addAssemblerRecipe(
-                                new ItemStack[] { GT_Utility.copyAmount(4, aStack),
-                                    dielectric.getDust(costMultiplier) },
-                                syntheticRubber.getMolten(costMultiplier * 144),
-                                GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L),
-                                400,
-                                calculateRecipeEU(aMaterial, 8));
-                            GT_Values.RA.addAssemblerRecipe(
-                                new ItemStack[] { aStack, dielectric.getDustSmall(costMultiplier) },
-                                syntheticRubber.getMolten(costMultiplier * 36),
-                                GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                                100,
-                                calculateRecipeEU(aMaterial, 8));
-                        }
-                    }
-                } else {
-                    GT_Values.RA.addAssemblerRecipe(
-                        new ItemStack[] { aStack, GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier),
-                            GT_Utility.getIntegratedCircuit(24) },
-                        Materials.Silicone.getMolten(costMultiplier * 72),
-                        GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                        100,
-                        calculateRecipeEU(aMaterial, 8));
-                    GT_Values.RA
-                        .addAssemblerRecipe(
-                            new ItemStack[] { aStack,
+            // Assembler recipes
+            {
+                GT_Values.RA.addAssemblerRecipe(
+                    new ItemStack[] { aStack, GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier),
+                        GT_Utility.getIntegratedCircuit(24) },
+                    Materials.Silicone.getMolten(costMultiplier * 72),
+                    GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
+                    100,
+                    calculateRecipeEU(aMaterial, 8));
+                GT_Values.RA.addAssemblerRecipe(
+                    new ItemStack[] { aStack,
+                        GT_OreDictUnificator.get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier),
+                        GT_Utility.getIntegratedCircuit(24) },
+                    Materials.Silicone.getMolten(costMultiplier * 72),
+                    GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
+                    100,
+                    calculateRecipeEU(aMaterial, 8));
+                for (Materials dielectric : dielectrics) {
+                    for (Materials syntheticRubber : syntheticRubbers) {
+                        GT_Values.RA.addAssemblerRecipe(
+                            new ItemStack[] { GT_Utility.copyAmount(4, aStack), dielectric.getDust(costMultiplier),
+                                GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier * 4) },
+                            syntheticRubber.getMolten(costMultiplier * 144),
+                            GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L),
+                            400,
+                            calculateRecipeEU(aMaterial, 8));
+                        GT_Values.RA.addAssemblerRecipe(
+                            new ItemStack[] { GT_Utility.copyAmount(4, aStack), dielectric.getDust(costMultiplier),
                                 GT_OreDictUnificator
-                                    .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier),
-                                GT_Utility.getIntegratedCircuit(24) },
-                            Materials.Silicone.getMolten(costMultiplier * 72),
+                                    .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier * 4) },
+                            syntheticRubber.getMolten(costMultiplier * 144),
+                            GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L),
+                            400,
+                            calculateRecipeEU(aMaterial, 8));
+                        GT_Values.RA.addAssemblerRecipe(
+                            new ItemStack[] { aStack, dielectric.getDustSmall(costMultiplier),
+                                GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier) },
+                            syntheticRubber.getMolten(costMultiplier * 36),
+                            GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
+                            100,
+                            calculateRecipeEU(aMaterial, 8));
+                        GT_Values.RA.addAssemblerRecipe(
+                            new ItemStack[] { aStack, dielectric.getDustSmall(costMultiplier),
+                                GT_OreDictUnificator
+                                    .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier) },
+                            syntheticRubber.getMolten(costMultiplier * 36),
                             GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
                             100,
                             calculateRecipeEU(aMaterial, 8));
-                    for (Materials dielectric : dielectrics) {
-                        for (Materials syntheticRubber : syntheticRubbers) {
-                            GT_Values.RA.addAssemblerRecipe(
-                                new ItemStack[] { GT_Utility.copyAmount(4, aStack), dielectric.getDust(costMultiplier),
-                                    GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier * 4) },
-                                syntheticRubber.getMolten(costMultiplier * 144),
-                                GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L),
-                                400,
-                                calculateRecipeEU(aMaterial, 8));
-                            GT_Values.RA.addAssemblerRecipe(
-                                new ItemStack[] { GT_Utility.copyAmount(4, aStack), dielectric.getDust(costMultiplier),
-                                    GT_OreDictUnificator
-                                        .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier * 4) },
-                                syntheticRubber.getMolten(costMultiplier * 144),
-                                GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L),
-                                400,
-                                calculateRecipeEU(aMaterial, 8));
-                            GT_Values.RA.addAssemblerRecipe(
-                                new ItemStack[] { aStack, dielectric.getDustSmall(costMultiplier),
-                                    GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier) },
-                                syntheticRubber.getMolten(costMultiplier * 36),
-                                GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                                100,
-                                calculateRecipeEU(aMaterial, 8));
-                            GT_Values.RA.addAssemblerRecipe(
-                                new ItemStack[] { aStack, dielectric.getDustSmall(costMultiplier),
-                                    GT_OreDictUnificator
-                                        .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier) },
-                                syntheticRubber.getMolten(costMultiplier * 36),
-                                GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
-                                100,
-                                calculateRecipeEU(aMaterial, 8));
-                        }
                     }
                 }
+            }
                 break;
         }
+
         // Honestly when can this machine be removed? );
         GT_Values.RA.addUnboxingRecipe(
             GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L),
@@ -425,6 +418,7 @@ public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistr
             null,
             100,
             calculateRecipeEU(aMaterial, 8));
+
         if (GT_Mod.gregtechproxy.mAE2Integration) {
             AE2AddNetAttunementCable(aStack, correspondingCable, aMaterial);
         }