GT recipe.cfg cleanup (#2579)

* ichorium block fixes

* alu ingot fix

* iridium ore fix

* gt vanilla assembling fixes

* ic2 assembler recipe fix

* forestry assembler recipe fixes

* spotless

* electrolyzer

* more iridium ore fixes

* another ichorium block fix

* obsidian stick fix

* remove unused railcraft obsidian recipes

* remove disabled melon recipe

* bring custom plasma fuel values to code

* spotless

* remove most recipe config uses

* fully remove recipe.cfg

* dont change recipemapbackend for now

11 files changed, 306 insertions, 230 deletions

diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java
index b948f251f0..b9926b188b 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java
@@ -1,6 +1,5 @@
 package gregtech.loaders.oreprocessing;
 
-import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
 import static gregtech.api.recipe.RecipeMaps.compressorRecipes;
 import static gregtech.api.recipe.RecipeMaps.cutterRecipes;
 import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
@@ -11,8 +10,6 @@ import static gregtech.api.util.GT_Utility.calculateRecipeEU;
 
 import net.minecraft.item.ItemStack;
 
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
@@ -33,6 +30,10 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist
     public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName,
         ItemStack aStack) {
 
+        if (aMaterial == Materials.Ichorium) {
+            return;
+        }
+
         if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV
             && GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) {
 
@@ -146,23 +147,7 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist
                 }
             }
         }
-        if (GregTech_API.sRecipeFile.get(
-            ConfigCategories.Recipes.storageblockcrafting,
-            OrePrefixes.block.get(aMaterial)
-                .toString(),
-            false)) {
-            if ((tStack1 == null) && (tStack2 == null) && (tStack3 != null)) GT_ModHandler.addCraftingRecipe(
-                GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L),
-                new Object[] { "XXX", "XXX", "XXX", 'X', OrePrefixes.dust.get(aMaterial) });
-            if (tStack2 != null) GT_ModHandler.addCraftingRecipe(
-                GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L),
-                new Object[] { "XXX", "XXX", "XXX", 'X', OrePrefixes.gem.get(aMaterial) });
-            if (tStack1 != null) {
-                GT_ModHandler.addCraftingRecipe(
-                    GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L),
-                    new Object[] { "XXX", "XXX", "XXX", 'X', OrePrefixes.ingot.get(aMaterial) });
-            }
-        }
+
         if (tStack1 != null) tStack1.stackSize = 9;
         if (tStack2 != null) tStack2.stackSize = 9;
         if (tStack3 != null) tStack3.stackSize = 9;
@@ -176,15 +161,10 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist
                 .addTo(hammerRecipes);
         }
 
-        if (GregTech_API.sRecipeFile.get(
-            ConfigCategories.Recipes.storageblockdecrafting,
-            OrePrefixes.block.get(aMaterial)
-                .toString(),
-            tStack2 != null)) {
+        if (tStack2 != null && aMaterial != Materials.NetherQuartz) {
             if (tStack3 != null)
                 GT_ModHandler.addShapelessCraftingRecipe(tStack3, new Object[] { OrePrefixes.block.get(aMaterial) });
-            if (tStack2 != null)
-                GT_ModHandler.addShapelessCraftingRecipe(tStack2, new Object[] { OrePrefixes.block.get(aMaterial) });
+            GT_ModHandler.addShapelessCraftingRecipe(tStack2, new Object[] { OrePrefixes.block.get(aMaterial) });
             if (tStack1 != null)
                 GT_ModHandler.addShapelessCraftingRecipe(tStack1, new Object[] { OrePrefixes.block.get(aMaterial) });
         }
@@ -202,12 +182,6 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist
         switch (aMaterial.mName) {
             case "Mercury" -> System.err.println(
                 "'blockQuickSilver'?, In which Ice Desert can you actually place this as a solid Block? On Pluto Greg :)");
-            case "Iron", "WroughtIron", "Steel" -> GT_Values.RA.stdBuilder()
-                .itemInputs(ItemList.IC2_Compressed_Coal_Ball.get(8L), GT_Utility.copyAmount(1, aStack))
-                .itemOutputs(ItemList.IC2_Compressed_Coal_Chunk.get(1L))
-                .duration(20 * SECONDS)
-                .eut(4)
-                .addTo(assemblerRecipes);
         }
     }
 }
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java
index a7b14e1d69..5a6bdfcf13 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java
@@ -189,18 +189,241 @@ public class ProcessingCell implements IOreRecipeRegistrator {
                     // Switch case to set manual values for specific plasmas and escape the formula based on mass
                     // when it doesn't make sense for powergen balance.
                     switch (aMaterial.mName) {
-                        case "Tin":
-                            recipeBuilder.metadata(FUEL_VALUE, 150_000)
-                                .metadata(FUEL_TYPE, 4)
-                                .addTo(GT_RecipeConstants.Fuel);
-                        case "Force":
-                            recipeBuilder.metadata(FUEL_VALUE, 150_000)
-                                .metadata(FUEL_TYPE, 4)
-                                .addTo(GT_RecipeConstants.Fuel);
-                        default:
-                            recipeBuilder.metadata(FUEL_VALUE, (int) Math.max(1024L, 1024L * aMaterial.getMass()))
-                                .metadata(FUEL_TYPE, 4)
-                                .addTo(GT_RecipeConstants.Fuel);
+                        case "Aluminium" -> recipeBuilder.metadata(FUEL_VALUE, 159_744)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Americium" -> recipeBuilder.metadata(FUEL_VALUE, 501_760)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Antimony" -> recipeBuilder.metadata(FUEL_VALUE, 309_760)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Argon" -> recipeBuilder.metadata(FUEL_VALUE, 188_416)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Arsenic" -> recipeBuilder.metadata(FUEL_VALUE, 230_400)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Barium" -> recipeBuilder.metadata(FUEL_VALUE, 342_302)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Beryllium" -> recipeBuilder.metadata(FUEL_VALUE, 110_592)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Bismuth" -> recipeBuilder.metadata(FUEL_VALUE, 425_984)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Boron" -> recipeBuilder.metadata(FUEL_VALUE, 112_640)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Cadmium" -> recipeBuilder.metadata(FUEL_VALUE, 293_601)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Caesium" -> recipeBuilder.metadata(FUEL_VALUE, 332_513)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Calcium" -> recipeBuilder.metadata(FUEL_VALUE, 188_416)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Cerium" -> recipeBuilder.metadata(FUEL_VALUE, 346_931)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Chlorine" -> recipeBuilder.metadata(FUEL_VALUE, 172_032)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Chrome" -> recipeBuilder.metadata(FUEL_VALUE, 202_342)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Cobalt" -> recipeBuilder.metadata(FUEL_VALUE, 217_497)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Copper" -> recipeBuilder.metadata(FUEL_VALUE, 219_340)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Deuterium" -> recipeBuilder.metadata(FUEL_VALUE, 40_960)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Erbium" -> recipeBuilder.metadata(FUEL_VALUE, 376_217)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Europium" -> recipeBuilder.metadata(FUEL_VALUE, 355_635)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Fluorine" -> recipeBuilder.metadata(FUEL_VALUE, 147_456)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Force" -> recipeBuilder.metadata(FUEL_VALUE, 150_000)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Gadolinium" -> recipeBuilder.metadata(FUEL_VALUE, 366_551)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Gallium" -> recipeBuilder.metadata(FUEL_VALUE, 229_376)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Gold" -> recipeBuilder.metadata(FUEL_VALUE, 401_408)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Helium_3" -> recipeBuilder.metadata(FUEL_VALUE, 61_440)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Helium" -> recipeBuilder.metadata(FUEL_VALUE, 81_920)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Holmium" -> recipeBuilder.metadata(FUEL_VALUE, 376_176)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Hydrogen" -> recipeBuilder.metadata(FUEL_VALUE, 20_480)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Indium" -> recipeBuilder.metadata(FUEL_VALUE, 296_509)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Iridium" -> recipeBuilder.metadata(FUEL_VALUE, 397_148)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Iron" -> recipeBuilder.metadata(FUEL_VALUE, 206_438)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Lanthanum" -> recipeBuilder.metadata(FUEL_VALUE, 344_801)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Lead" -> recipeBuilder.metadata(FUEL_VALUE, 423_936)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Lithium" -> recipeBuilder.metadata(FUEL_VALUE, 100_352)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Lutetium" -> recipeBuilder.metadata(FUEL_VALUE, 381_296)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Magnesium" -> recipeBuilder.metadata(FUEL_VALUE, 152_371)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Manganese" -> recipeBuilder.metadata(FUEL_VALUE, 202_752)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Mercury" -> recipeBuilder.metadata(FUEL_VALUE, 409_600)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Molybdenum" -> recipeBuilder.metadata(FUEL_VALUE, 272_384)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Neodymium" -> recipeBuilder.metadata(FUEL_VALUE, 347_996)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Nickel" -> recipeBuilder.metadata(FUEL_VALUE, 213_811)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Niobium" -> recipeBuilder.metadata(FUEL_VALUE, 269_516)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Nitrogen" -> recipeBuilder.metadata(FUEL_VALUE, 129_024)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Osmium" -> recipeBuilder.metadata(FUEL_VALUE, 393_659)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Oxygen" -> recipeBuilder.metadata(FUEL_VALUE, 131_072)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Palladium" -> recipeBuilder.metadata(FUEL_VALUE, 282_214)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Phosphor" -> recipeBuilder.metadata(FUEL_VALUE, 165_888)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Platinum" -> recipeBuilder.metadata(FUEL_VALUE, 399_360)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Plutonium241" -> recipeBuilder.metadata(FUEL_VALUE, 497_664)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Plutonium" -> recipeBuilder.metadata(FUEL_VALUE, 503_808)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Potassium" -> recipeBuilder.metadata(FUEL_VALUE, 183_705)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Praseodymium" -> recipeBuilder.metadata(FUEL_VALUE, 346_931)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Promethium" -> recipeBuilder.metadata(FUEL_VALUE, 347_996)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Radon" -> recipeBuilder.metadata(FUEL_VALUE, 450_560)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Rubidium" -> recipeBuilder.metadata(FUEL_VALUE, 243_712)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Samarium" -> recipeBuilder.metadata(FUEL_VALUE, 353_280)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Scandium" -> recipeBuilder.metadata(FUEL_VALUE, 193_536)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Silicon" -> recipeBuilder.metadata(FUEL_VALUE, 160_563)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Silver" -> recipeBuilder.metadata(FUEL_VALUE, 282_685)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Sodium" -> recipeBuilder.metadata(FUEL_VALUE, 148_684)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Strontium" -> recipeBuilder.metadata(FUEL_VALUE, 249_446)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Sulfur" -> recipeBuilder.metadata(FUEL_VALUE, 170_393)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Tantalum" -> recipeBuilder.metadata(FUEL_VALUE, 384_000)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Terbium" -> recipeBuilder.metadata(FUEL_VALUE, 368_885)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Thorium" -> recipeBuilder.metadata(FUEL_VALUE, 471_040)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Thulium" -> recipeBuilder.metadata(FUEL_VALUE, 378_470)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Tin" -> recipeBuilder.metadata(FUEL_VALUE, 150_000)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Titanium" -> recipeBuilder.metadata(FUEL_VALUE, 196_608)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Tritium" -> recipeBuilder.metadata(FUEL_VALUE, 61_440)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Tungsten" -> recipeBuilder.metadata(FUEL_VALUE, 384_778)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Uranium235" -> recipeBuilder.metadata(FUEL_VALUE, 481_280)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Uranium" -> recipeBuilder.metadata(FUEL_VALUE, 487_424)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Vanadium" -> recipeBuilder.metadata(FUEL_VALUE, 198_451)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Ytterbium" -> recipeBuilder.metadata(FUEL_VALUE, 379_695)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Yttrium" -> recipeBuilder.metadata(FUEL_VALUE, 255_180)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        case "Zinc" -> recipeBuilder.metadata(FUEL_VALUE, 226_304)
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
+                        default -> recipeBuilder
+                            .metadata(FUEL_VALUE, (int) Math.max(1024L, 1024L * aMaterial.getMass()))
+                            .metadata(FUEL_TYPE, 4)
+                            .addTo(GT_RecipeConstants.Fuel);
                     }
                     if (GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L) != null) {
                         GT_Values.RA.stdBuilder()
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java
index f0f8aef8ba..7cb26f7c36 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java
@@ -282,10 +282,7 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     case "NetherQuartz":
                     case "Quartz":
                     case "CertusQuartz":
-                        if (gregtech.api.GregTech_API.sRecipeFile.get(
-                            gregtech.api.enums.ConfigCategories.Recipes.disabledrecipes,
-                            "QuartzDustSmeltingIntoAESilicon",
-                            true)) GT_ModHandler.removeFurnaceSmelting(aStack);
+                        GT_ModHandler.removeFurnaceSmelting(aStack);
                         break;
                     case "MeatRaw":
                         GT_ModHandler.addSmeltingRecipe(
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
index 0efa58a3c7..35bd3b8cfd 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
@@ -1,9 +1,7 @@
 package gregtech.loaders.oreprocessing;
 
-import static gregtech.api.enums.Mods.AppliedEnergistics2;
 import static gregtech.api.recipe.RecipeMaps.benderRecipes;
 import static gregtech.api.recipe.RecipeMaps.compressorRecipes;
-import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes;
 import static gregtech.api.recipe.RecipeMaps.hammerRecipes;
 import static gregtech.api.recipe.RecipeMaps.implosionRecipes;
 import static gregtech.api.recipe.RecipeMaps.laserEngraverRecipes;
@@ -19,8 +17,6 @@ import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.oredict.OreDictionary;
 
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
@@ -51,8 +47,7 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
         boolean aNoSmashing = aMaterial.contains(SubTag.NO_SMASHING);
         boolean aNoWorking = aMaterial.contains(SubTag.NO_WORKING);
         boolean aNoSmelting = aMaterial.contains(SubTag.NO_SMELTING);
-        boolean aSpecialRecipeReq = (aMaterial.contains(SubTag.MORTAR_GRINDABLE))
-            && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.mortar, aMaterial.mName, true));
+        boolean aSpecialRecipeReq = aMaterial.contains(SubTag.MORTAR_GRINDABLE);
         boolean aFuelPower = aMaterial.mFuelPower > 0;
 
         switch (aPrefix) {
@@ -115,7 +110,7 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
                     }
 
                     // Bender recipes
-                    {
+                    if (aMaterial != Materials.Iridium) {
                         if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) {
                             // Plate
                             GT_Values.RA.stdBuilder()
@@ -260,32 +255,6 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
                     }
                 }
 
-                switch (aMaterial.mName) {
-                    case "NULL":
-                        break;
-                    case "Coal", "Charcoal":
-                        if (GregTech_API.sRecipeFile
-                            .get(ConfigCategories.Recipes.disabledrecipes, "torchesFromCoal", false)) {
-                            GT_ModHandler.removeRecipeDelayed(
-                                GT_Utility.copyAmount(1, aStack),
-                                null,
-                                null,
-                                new ItemStack(net.minecraft.init.Items.stick, 1, 0));
-                        }
-                        break;
-                    case "CertusQuartz":
-                    // Electrolyzer recipe
-                    {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(aStack)
-                            .itemOutputs(
-                                GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 1))
-                            .duration(100 * SECONDS)
-                            .eut(TierEU.RECIPE_LV)
-                            .addTo(electrolyzerRecipes);
-                    }
-                }
-
                 for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver
                     // Laser engraver recipes
                     {
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java
index 48879067a8..0be31a7e1d 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java
@@ -12,8 +12,6 @@ import static gregtech.api.util.GT_Utility.calculateRecipeEU;
 
 import net.minecraft.item.ItemStack;
 
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
@@ -93,8 +91,7 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist
                 if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)
                     && !aMaterial.contains(SubTag.NO_WORKING)
                     && !aMaterial.contains(SubTag.SMELTING_TO_GEM)
-                    && aMaterial.contains(SubTag.MORTAR_GRINDABLE)
-                    && GregTech_API.sRecipeFile.get(ConfigCategories.Tools.mortar, aMaterial.mName, true)) {
+                    && aMaterial.contains(SubTag.MORTAR_GRINDABLE)) {
                     GT_ModHandler.addShapelessCraftingRecipe(
                         GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
                         GT_Proxy.tBits,
@@ -201,9 +198,7 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist
                     }
 
                     // Enable crafting with hammer if tier is < IV.
-                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq
-                        && GregTech_API.sRecipeFile
-                            .get(ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) {
+                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) {
                         GT_ModHandler.addCraftingRecipe(
                             GT_OreDictUnificator.get(OrePrefixes.ingotDouble, aMaterial, 1L),
                             GT_Proxy.tBits,
@@ -230,9 +225,7 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist
                             .addTo(benderRecipes);
                     }
 
-                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq
-                        && GregTech_API.sRecipeFile
-                            .get(ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) {
+                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) {
                         GT_ModHandler.addCraftingRecipe(
                             GT_OreDictUnificator.get(OrePrefixes.ingotTriple, aMaterial, 1L),
                             GT_Proxy.tBits,
@@ -254,9 +247,7 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist
                     }
 
                     // If tier < IV add manual crafting.
-                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq
-                        && GregTech_API.sRecipeFile
-                            .get(ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) {
+                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) {
                         GT_ModHandler.addCraftingRecipe(
                             GT_OreDictUnificator.get(OrePrefixes.ingotQuadruple, aMaterial, 1L),
                             GT_Proxy.tBits,
@@ -278,9 +269,7 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist
                     }
 
                     // Crafting recipes
-                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq
-                        && GregTech_API.sRecipeFile
-                            .get(ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) {
+                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) {
                         GT_ModHandler.addCraftingRecipe(
                             GT_OreDictUnificator.get(OrePrefixes.ingotQuintuple, aMaterial, 1L),
                             GT_Proxy.tBits,
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java
index 7d36af7de3..737ef4682a 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java
@@ -16,8 +16,6 @@ import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 
 import gregtech.GT_Mod;
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
@@ -129,20 +127,14 @@ public class ProcessingLog implements gregtech.api.interfaces.IOreRecipeRegistra
                 GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1, aStack), false, null),
                 new ItemStack(Items.coal, 1, 1)))) {
                 addPyrolyeOvenRecipes(aStack);
-                if (GregTech_API.sRecipeFile
-                    .get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", true)) {
-                    GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack));
-                }
+                GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack));
             }
             for (int i = 0; i < 32767; i++) {
                 if ((GT_Utility.areStacksEqual(
                     GT_ModHandler.getSmeltingOutput(new ItemStack(aStack.getItem(), 1, i), false, null),
                     new ItemStack(Items.coal, 1, 1)))) {
                     addPyrolyeOvenRecipes(aStack);
-                    if (GregTech_API.sRecipeFile
-                        .get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", true)) {
-                        GT_ModHandler.removeFurnaceSmelting(new ItemStack(aStack.getItem(), 1, i));
-                    }
+                    GT_ModHandler.removeFurnaceSmelting(new ItemStack(aStack.getItem(), 1, i));
                 }
                 ItemStack tStack = GT_ModHandler.getRecipeOutput(new ItemStack(aStack.getItem(), 1, i));
                 if (tStack == null) {
@@ -219,10 +211,7 @@ public class ProcessingLog implements gregtech.api.interfaces.IOreRecipeRegistra
                 GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1, aStack), false, null),
                 new ItemStack(Items.coal, 1, 1)))) {
                 addPyrolyeOvenRecipes(aStack);
-                if (GregTech_API.sRecipeFile
-                    .get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", true)) {
-                    GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack));
-                }
+                GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack));
             }
             ItemStack tStack = GT_ModHandler.getRecipeOutput(GT_Utility.copyAmount(1, aStack));
             if (tStack != null) {
@@ -293,8 +282,7 @@ public class ProcessingLog implements gregtech.api.interfaces.IOreRecipeRegistra
             GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1, aStack), false, null),
             new ItemStack(Items.coal, 1, 1)))) {
             addPyrolyeOvenRecipes(aStack);
-            if (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", true))
-                GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack));
+            GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack));
         }
     }
 
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java
index 380d42f360..8d7ca9e518 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java
@@ -41,7 +41,8 @@ public class ProcessingNugget implements gregtech.api.interfaces.IOreRecipeRegis
         }
 
         if ((!aMaterial.contains(SubTag.SMELTING_TO_GEM))
-            && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L) != null) {
+            && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L) != null
+            && aMaterial != Materials.Aluminium) {
             GT_Values.RA.stdBuilder()
                 .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Shape_Mold_Ingot.get(0L))
                 .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L))
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java
index b28b997a93..3b06babee6 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java
@@ -7,7 +7,6 @@ import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeBuilder.TICKS;
 
 import net.minecraft.init.Blocks;
-import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 
 import gregtech.api.enums.GT_Values;
@@ -64,12 +63,6 @@ public class ProcessingPlank implements gregtech.api.interfaces.IOreRecipeRegist
                 .duration(40 * SECONDS)
                 .eut(4)
                 .addTo(assemblerRecipes);
-            GT_Values.RA.stdBuilder()
-                .itemInputs(GT_Utility.copyAmount(6, aStack), new ItemStack(Items.book, 3))
-                .itemOutputs(new ItemStack(Blocks.bookshelf, 1))
-                .duration(20 * SECONDS)
-                .eut(4)
-                .addTo(assemblerRecipes);
 
             if (aStack.getItemDamage() == 32767) {
                 for (byte i = 0; i < 64; i = (byte) (i + 1)) {
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java
index 88f39309cf..be8322f30c 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java
@@ -1,6 +1,5 @@
 package gregtech.loaders.oreprocessing;
 
-import static gregtech.api.enums.ConfigCategories.Recipes.harderrecipes;
 import static gregtech.api.enums.GT_Values.L;
 import static gregtech.api.enums.GT_Values.NI;
 import static gregtech.api.enums.GT_Values.W;
@@ -27,7 +26,6 @@ import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 
 import gregtech.api.GregTech_API;
-import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
@@ -125,17 +123,15 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
             new Object[] { "hX", 'X', OrePrefixes.plate.get(aMaterial) });
 
         if (aMaterial == Materials.Paper) {
-
             GT_ModHandler.addCraftingRecipe(
-                GT_Utility.copyAmount(GregTech_API.sRecipeFile.get(harderrecipes, aStack, true) ? 2 : 3, aStack),
+                GT_Utility.copyAmount(2, aStack),
                 BUFFERED,
                 new Object[] { "XXX", 'X', new ItemStack(Items.reeds, 1, W) });
         }
 
         if (aMaterial.mUnificatable && aMaterial.mMaterialInto == aMaterial) {
 
-            if (!aNoSmashing
-                && GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammerplating, aMaterial.toString(), true)) {
+            if (!aNoSmashing) {
 
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
                     GT_ModHandler.addCraftingRecipe(
@@ -166,8 +162,7 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
                 }
             }
 
-            if ((aMaterial.contains(SubTag.MORTAR_GRINDABLE))
-                && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.mortar, aMaterial.mName, true))) {
+            if (aMaterial.contains(SubTag.MORTAR_GRINDABLE)) {
 
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
                     GT_ModHandler.addShapelessCraftingRecipe(
@@ -218,21 +213,13 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
         }
 
         if (!aNoSmashing) {
-            if (GregTech_API.sRecipeFile.get(
-                gregtech.api.enums.ConfigCategories.Tools.hammerdoubleplate,
-                OrePrefixes.plate.get(aMaterial)
-                    .toString(),
-                true)) {
-
-                Object aPlateStack = OrePrefixes.plate.get(aMaterial);
-
-                if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    GT_ModHandler.addCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { "I", "B", "h", // craftingToolHardHammer
-                            'I', aPlateStack, 'B', aPlateStack });
-                }
+            Object aPlateStack = OrePrefixes.plate.get(aMaterial);
+            if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
+                GT_ModHandler.addCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { "I", "B", "h", // craftingToolHardHammer
+                        'I', aPlateStack, 'B', aPlateStack });
             }
         }
     }
@@ -276,28 +263,19 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
         }
 
         if (!aNoSmashing) {
-            if (GregTech_API.sRecipeFile.get(
-                gregtech.api.enums.ConfigCategories.Tools.hammertripleplate,
-                OrePrefixes.plate.get(aMaterial)
-                    .toString(),
-                true)) {
-
-                if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-
-                    Object aPlateStack = OrePrefixes.plate.get(aMaterial);
-
-                    GT_ModHandler.addCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { "I", "B", "h", // craftingToolHardHammer
-                            'I', OrePrefixes.plateDouble.get(aMaterial), 'B', aPlateStack });
+            if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
+                Object aPlateStack = OrePrefixes.plate.get(aMaterial);
+                GT_ModHandler.addCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { "I", "B", "h", // craftingToolHardHammer
+                        'I', OrePrefixes.plateDouble.get(aMaterial), 'B', aPlateStack });
 
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack,
-                            aPlateStack, aPlateStack });
-                }
+                GT_ModHandler.addShapelessCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack,
+                        aPlateStack });
             }
         }
 
@@ -366,27 +344,19 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
                 .addTo(assemblerRecipes);
         }
         if (!aNoSmashing) {
-            if (GregTech_API.sRecipeFile.get(
-                gregtech.api.enums.ConfigCategories.Tools.hammerquadrupleplate,
-                OrePrefixes.plate.get(aMaterial)
-                    .toString(),
-                true)) {
-
-                if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    Object aPlateStack = OrePrefixes.plate.get(aMaterial);
-
-                    GT_ModHandler.addCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { "I", "B", "h", // craftingToolHardHammer
-                            'I', OrePrefixes.plateTriple.get(aMaterial), 'B', aPlateStack });
+            if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
+                Object aPlateStack = OrePrefixes.plate.get(aMaterial);
+                GT_ModHandler.addCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { "I", "B", "h", // craftingToolHardHammer
+                        'I', OrePrefixes.plateTriple.get(aMaterial), 'B', aPlateStack });
 
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack,
-                            aPlateStack, aPlateStack, aPlateStack });
-                }
+                GT_ModHandler.addShapelessCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack,
+                        aPlateStack, aPlateStack });
             }
         }
     }
@@ -420,27 +390,19 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
                 .addTo(assemblerRecipes);
         }
         if (!aNoSmashing) {
-            if (GregTech_API.sRecipeFile.get(
-                gregtech.api.enums.ConfigCategories.Tools.hammerquintupleplate,
-                OrePrefixes.plate.get(aMaterial)
-                    .toString(),
-                true)) {
-
-                if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
-                    Object aPlateStack = OrePrefixes.plate.get(aMaterial);
-
-                    GT_ModHandler.addCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { "I", "B", "h", // craftingToolHardHammer
-                            'I', OrePrefixes.plateQuadruple.get(aMaterial), 'B', aPlateStack });
+            if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
+                Object aPlateStack = OrePrefixes.plate.get(aMaterial);
+                GT_ModHandler.addCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { "I", "B", "h", // craftingToolHardHammer
+                        'I', OrePrefixes.plateQuadruple.get(aMaterial), 'B', aPlateStack });
 
-                    GT_ModHandler.addShapelessCraftingRecipe(
-                        GT_Utility.copyAmount(1, aStack),
-                        DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
-                        new Object[] { ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack, aPlateStack,
-                            aPlateStack, aPlateStack });
-                }
+                GT_ModHandler.addShapelessCraftingRecipe(
+                    GT_Utility.copyAmount(1, aStack),
+                    DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED,
+                    new Object[] { ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack, aPlateStack,
+                        aPlateStack, aPlateStack });
             }
         }
     }
@@ -480,9 +442,7 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist
                 .addTo(fluidSolidifierRecipes);
         }
 
-        if (aMaterial.mUnificatable && aMaterial.mMaterialInto == aMaterial
-            && !aNoSmashing
-            && GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammerplating, aMaterial.toString(), true)) {
+        if (aMaterial.mUnificatable && aMaterial.mMaterialInto == aMaterial && !aNoSmashing) {
 
             if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
                 GT_ModHandler.addCraftingRecipe(
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java
index 3c25574798..5493aa9b8e 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java
@@ -50,7 +50,8 @@ public class ProcessingShaping implements gregtech.api.interfaces.IOreRecipeRegi
                     }
 
                 if (!OrePrefixes.block.isIgnored(aMaterial.mSmeltInto)
-                    && (GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, 1L) != null)) {
+                    && (GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, 1L) != null)
+                    && aMaterial != Materials.Ichorium) {
                     GT_Values.RA.stdBuilder()
                         .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Shape_Extruder_Block.get(0L))
                         .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, tAmount))
@@ -255,7 +256,7 @@ public class ProcessingShaping implements gregtech.api.interfaces.IOreRecipeRegi
                         }
                     }
                 }
-                if (tAmount * 2 <= 64) {
+                if (tAmount * 2 <= 64 && aMaterial != Materials.Obsidian) {
                     if (!(aMaterial == Materials.Aluminium)) {
                         if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mSmeltInto, 1L) != null) {
                             GT_Values.RA.stdBuilder()
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java
index 199feeb08e..840f49b4dd 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java
@@ -1,6 +1,5 @@
 package gregtech.loaders.oreprocessing;
 
-import static gregtech.api.enums.Mods.Railcraft;
 import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
 import static gregtech.api.recipe.RecipeMaps.cutterRecipes;
 import static gregtech.api.recipe.RecipeMaps.maceratorRecipes;
@@ -12,7 +11,6 @@ import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 
 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;
@@ -81,23 +79,6 @@ public class ProcessingStone implements IOreRecipeRegistrator {
                 break;
             case "Obsidian":
                 if (aBlock != Blocks.air) aBlock.setResistance(20.0F);
-
-                GT_Values.RA.stdBuilder()
-                    .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.IC2_Compressed_Coal_Ball.get(8L))
-                    .itemOutputs(ItemList.IC2_Compressed_Coal_Chunk.get(1L))
-                    .duration(20 * SECONDS)
-                    .eut(4)
-                    .addTo(assemblerRecipes);
-
-                GT_Values.RA.stdBuilder()
-                    .itemInputs(GT_Utility.copyAmount(1, aStack))
-                    .itemOutputs(
-                        GT_ModHandler.getModItem(Railcraft.ID, "cube", 1L, 4),
-                        GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
-                    .outputChances(10000, 1000)
-                    .duration(20 * SECONDS)
-                    .eut(2)
-                    .addTo(maceratorRecipes);
                 break;
             case "Concrete":
                 GT_Values.RA.stdBuilder()