The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

1 files changed, 188 insertions, 192 deletions

diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java
index c8a3af1130..3398fda98d 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java
@@ -9,12 +9,12 @@ import static gregtech.api.recipe.RecipeMaps.electroMagneticSeparatorRecipes;
 import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes;
 import static gregtech.api.recipe.RecipeMaps.implosionRecipes;
 import static gregtech.api.recipe.RecipeMaps.packagerRecipes;
-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.FUEL_TYPE;
-import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE;
+import static gregtech.api.util.GTRecipeBuilder.MINUTES;
+import static gregtech.api.util.GTRecipeBuilder.SECONDS;
+import static gregtech.api.util.GTRecipeBuilder.TICKS;
+import static gregtech.api.util.GTRecipeConstants.COIL_HEAT;
+import static gregtech.api.util.GTRecipeConstants.FUEL_TYPE;
+import static gregtech.api.util.GTRecipeConstants.FUEL_VALUE;
 
 import java.util.ArrayList;
 
@@ -22,7 +22,7 @@ import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
-import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.GTValues;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.MaterialsUEVplus;
@@ -30,12 +30,12 @@ import gregtech.api.enums.OrePrefixes;
 import gregtech.api.enums.SubTag;
 import gregtech.api.enums.TierEU;
 import gregtech.api.objects.MaterialStack;
-import gregtech.api.util.GT_ModHandler;
-import gregtech.api.util.GT_OreDictUnificator;
-import gregtech.api.util.GT_RecipeBuilder;
-import gregtech.api.util.GT_RecipeConstants;
-import gregtech.api.util.GT_RecipeRegistrator;
-import gregtech.api.util.GT_Utility;
+import gregtech.api.util.GTModHandler;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTRecipeBuilder;
+import gregtech.api.util.GTRecipeConstants;
+import gregtech.api.util.GTRecipeRegistrator;
+import gregtech.api.util.GTUtility;
 
 public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistrator {
 
@@ -54,26 +54,26 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
         switch (aPrefix) {
             case dust -> {
                 if (aMaterial.mFuelPower > 0) {
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack))
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack))
                         .metadata(FUEL_VALUE, aMaterial.mFuelPower)
                         .metadata(FUEL_TYPE, aMaterial.mFuelType)
-                        .addTo(GT_RecipeConstants.Fuel);
+                        .addTo(GTRecipeConstants.Fuel);
                 }
-                if ((GT_Utility.getFluidForFilledItem(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), true)
-                    == null) && (GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L) != null)) {
-                    GT_Values.RA.stdBuilder()
+                if ((GTUtility.getFluidForFilledItem(GTOreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), true)
+                    == null) && (GTOreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L) != null)) {
+                    GTValues.RA.stdBuilder()
                         .itemInputs(aStack, ItemList.Cell_Empty.get(1L))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L))
                         .duration(5 * SECONDS)
                         .eut(1)
                         .addTo(cannerRecipes);
                 }
                 if (!aMaterial.mBlastFurnaceRequired) {
-                    GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null);
+                    GTRecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null);
                     if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) {
-                        GT_RecipeRegistrator.registerReverseArcSmelting(
-                            GT_Utility.copyAmount(1, aStack),
+                        GTRecipeRegistrator.registerReverseArcSmelting(
+                            GTUtility.copyAmount(1, aStack),
                             aMaterial,
                             aPrefix.mMaterialAmount,
                             null,
@@ -82,20 +82,20 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     }
                 }
                 ItemStack tDustStack;
-                if ((null != (tDustStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L)))
+                if ((null != (tDustStack = GTOreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L)))
                     && (!aMaterial.contains(SubTag.NO_SMELTING))) {
                     if (aMaterial.mBlastFurnaceRequired) {
-                        GT_ModHandler.removeFurnaceSmelting(aStack);
+                        GTModHandler.removeFurnaceSmelting(aStack);
                         if (aMaterial.mAutoGenerateBlastFurnaceRecipes) {
-                            GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder();
+                            GTRecipeBuilder recipeBuilder = GTValues.RA.stdBuilder();
                             recipeBuilder
-                                .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1));
+                                .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(1));
                             if (aMaterial.mBlastFurnaceTemp > 1750) {
                                 recipeBuilder.itemOutputs(
-                                    GT_OreDictUnificator
+                                    GTOreDictUnificator
                                         .get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, tDustStack, 1L));
                             } else {
-                                recipeBuilder.itemOutputs(GT_Utility.copyAmount(1, tDustStack));
+                                recipeBuilder.itemOutputs(GTUtility.copyAmount(1, tDustStack));
                             }
                             recipeBuilder
                                 .duration(
@@ -105,23 +105,23 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                                 .addTo(blastFurnaceRecipes);
                         }
                     } else {
-                        GT_ModHandler.addSmeltingRecipe(aStack, tDustStack);
+                        GTModHandler.addSmeltingRecipe(aStack, tDustStack);
                     }
                 } else if (!aMaterial.contains(SubTag.NO_WORKING)) {
                     if ((!OrePrefixes.block.isIgnored(aMaterial))
-                        && (null == GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
-                        && GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L) != null) {
+                        && (null == GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                        && GTOreDictUnificator.get(OrePrefixes.block, aMaterial, 1L) != null) {
 
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(9, aStack))
-                            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(9, aStack))
+                            .itemOutputs(GTOreDictUnificator.get(OrePrefixes.block, aMaterial, 1L))
                             .duration(15 * SECONDS)
                             .eut(2)
                             .addTo(compressorRecipes);
                     }
                     // This is so disgustingly bad.
                     if (((OrePrefixes.block.isIgnored(aMaterial))
-                        || (null == GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)))
+                        || (null == GTOreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)))
                         && (aMaterial != Materials.GraniteRed)
                         && (aMaterial != Materials.GraniteBlack)
                         && (aMaterial != Materials.Basalt)
@@ -134,10 +134,10 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                         && (aMaterial != Materials.Clay)) {
                         // compressor recipe
                         {
-                            if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) {
-                                GT_Values.RA.stdBuilder()
-                                    .itemInputs(GT_Utility.copyAmount(1, aStack))
-                                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                            if (GTOreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) {
+                                GTValues.RA.stdBuilder()
+                                    .itemInputs(GTUtility.copyAmount(1, aStack))
+                                    .itemOutputs(GTOreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
                                     .duration(15 * SECONDS)
                                     .eut(2)
                                     .addTo(compressorRecipes);
@@ -155,9 +155,9 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                         if (tMat.mMaterial == Materials.Air) {
                             tDustStack = ItemList.Cell_Air.get(tMat.mAmount / 2L);
                         } else {
-                            tDustStack = GT_OreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount);
+                            tDustStack = GTOreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount);
                             if (tDustStack == null)
-                                tDustStack = GT_OreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount);
+                                tDustStack = GTOreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount);
                         }
                         if (tItemAmount + tMat.mAmount * 3628800L
                             <= aStack.getMaxStackSize() * aMaterial.getDensity()) {
@@ -165,17 +165,17 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                             if (tDustStack != null) {
                                 tDustStack.stackSize = ((int) (tDustStack.stackSize * tDensityMultiplier));
                                 while ((tDustStack.stackSize > 64) && (tList.size() < 6)
-                                    && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64L
+                                    && (tCapsuleCount + GTModHandler.getCapsuleCellContainerCount(tDustStack) * 64L
                                         <= 64L)) {
-                                    tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64L;
-                                    tList.add(GT_Utility.copyAmount(64, tDustStack));
+                                    tCapsuleCount += GTModHandler.getCapsuleCellContainerCount(tDustStack) * 64L;
+                                    tList.add(GTUtility.copyAmount(64, tDustStack));
                                     tDustStack.stackSize -= 64;
                                 }
                                 if ((tDustStack.stackSize > 0) && (tList.size() < 6)
                                     && (tCapsuleCount
-                                        + GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(tDustStack)
+                                        + GTModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(tDustStack)
                                         <= 64L)) {
-                                    tCapsuleCount += GT_ModHandler
+                                    tCapsuleCount += GTModHandler
                                         .getCapsuleCellContainerCountMultipliedWithStackSize(tDustStack);
                                     tList.add(tDustStack);
                                 }
@@ -189,9 +189,9 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                         int tList_sS = tList.size();
                         for (int i = 0; i < tList_sS; i++) {
                             if ((!ItemList.Cell_Air.isStackEqual(tList.get(i)))
-                                && ((tFluid = GT_Utility.getFluidForFilledItem(tList.get(i), true)) != null)) {
+                                && ((tFluid = GTUtility.getFluidForFilledItem(tList.get(i), true)) != null)) {
                                 tFluid.amount *= tList.get(i).stackSize;
-                                tCapsuleCount -= GT_ModHandler
+                                tCapsuleCount -= GTModHandler
                                     .getCapsuleCellContainerCountMultipliedWithStackSize(tList.get(i));
                                 tList.remove(i);
                                 break;
@@ -199,13 +199,13 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                         }
                         if ((aMaterial.mExtraData & 0x1) != 0) {
                             if (tList.size() > 0 || tFluid != null) {
-                                GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder();
+                                GTRecipeBuilder recipeBuilder = GTValues.RA.stdBuilder();
                                 if (tCapsuleCount > 0L) {
                                     recipeBuilder.itemInputs(
-                                        GT_Utility.copyAmount(tItemAmount, aStack),
+                                        GTUtility.copyAmount(tItemAmount, aStack),
                                         ItemList.Cell_Empty.get(tCapsuleCount));
                                 } else {
-                                    recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, aStack));
+                                    recipeBuilder.itemInputs(GTUtility.copyAmount(tItemAmount, aStack));
                                 }
                                 if (tList.size() > 0) {
                                     ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]);
@@ -222,13 +222,13 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                         }
                         if ((aMaterial.mExtraData & 0x2) != 0) {
                             if (tList.size() > 0 || tFluid != null) {
-                                GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder();
+                                GTRecipeBuilder recipeBuilder = GTValues.RA.stdBuilder();
                                 if (tCapsuleCount > 0L) {
                                     recipeBuilder.itemInputs(
-                                        GT_Utility.copyAmount(tItemAmount, aStack),
+                                        GTUtility.copyAmount(tItemAmount, aStack),
                                         ItemList.Cell_Empty.get(tCapsuleCount));
                                 } else {
-                                    recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, aStack));
+                                    recipeBuilder.itemInputs(GTUtility.copyAmount(tItemAmount, aStack));
                                 }
                                 if (tList.size() > 0) {
                                     ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]);
@@ -245,26 +245,26 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     }
                 }
                 if (aMaterial.contains(SubTag.CRYSTALLISABLE)
-                    && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) {
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                    && GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) {
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(1))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
                         .outputChances(7000)
                         .fluidInputs(Materials.Water.getFluid(200L))
                         .duration(1 * MINUTES + 40 * SECONDS)
                         .eut(24)
                         .addTo(autoclaveRecipes);
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(2))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(2))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
                         .outputChances(9000)
-                        .fluidInputs(GT_ModHandler.getDistilledWater(100L))
+                        .fluidInputs(GTModHandler.getDistilledWater(100L))
                         .duration(1 * MINUTES + 15 * SECONDS)
                         .eut(24)
                         .addTo(autoclaveRecipes);
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(3))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
                         .outputChances(10000)
                         .fluidInputs(Materials.Void.getMolten(36L))
                         .duration(1 * MINUTES)
@@ -275,65 +275,63 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     case "NULL", "Mercury", "Coal":
                         break;
                     case "Glass":
-                        GT_ModHandler.addSmeltingRecipe(
-                            GT_Utility.copyAmount(1, aStack),
+                        GTModHandler.addSmeltingRecipe(
+                            GTUtility.copyAmount(1, aStack),
                             new ItemStack(net.minecraft.init.Blocks.glass));
                         break;
                     case "NetherQuartz":
                     case "Quartz":
                     case "CertusQuartz":
-                        GT_ModHandler.removeFurnaceSmelting(aStack);
+                        GTModHandler.removeFurnaceSmelting(aStack);
                         break;
                     case "MeatRaw":
-                        GT_ModHandler.addSmeltingRecipe(
-                            GT_Utility.copyAmount(1, aStack),
-                            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.MeatCooked, 1L));
+                        GTModHandler.addSmeltingRecipe(
+                            GTUtility.copyAmount(1, aStack),
+                            GTOreDictUnificator.get(OrePrefixes.dust, Materials.MeatCooked, 1L));
                         break;
                     case "Oilsands":
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(1, aStack))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(1, aStack))
                             .fluidOutputs(Materials.OilHeavy.getFluid(1000))
                             .duration(33 * SECONDS)
                             .eut(8)
                             .addTo(centrifugeRecipes);
                         break;
                     case "HydratedCoal":
-                        GT_ModHandler.addSmeltingRecipe(
-                            GT_Utility.copyAmount(1, aStack),
-                            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L));
+                        GTModHandler.addSmeltingRecipe(
+                            GTUtility.copyAmount(1, aStack),
+                            GTOreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L));
                         break;
                     case "Diamond": {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(64))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(64))
                             .itemOutputs(
                                 ItemList.IC2_Industrial_Diamond.get(3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(
-                                GT_Utility.copyAmount(4, aStack),
-                                GT_ModHandler.getIC2Item("dynamite", 16, null))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), GTModHandler.getIC2Item("dynamite", 16, null))
                             .itemOutputs(
                                 ItemList.IC2_Industrial_Diamond.get(3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 32))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 32))
                             .itemOutputs(
                                 ItemList.IC2_Industrial_Diamond.get(3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("industrialTnt", 8))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), GTModHandler.getIC2Item("industrialTnt", 8))
                             .itemOutputs(
                                 ItemList.IC2_Industrial_Diamond.get(3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
@@ -349,37 +347,35 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     case "BlueTopaz":
                     case "Tanzanite":
                     case "Amethyst": {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(48))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(48))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(
-                                GT_Utility.copyAmount(4, aStack),
-                                GT_ModHandler.getIC2Item("dynamite", 12, null))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), GTModHandler.getIC2Item("dynamite", 12, null))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 24))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 24))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("industrialTnt", 6))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), GTModHandler.getIC2Item("industrialTnt", 6))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
@@ -394,35 +390,35 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     case "Forcicium":
                     case "Forcillium":
                     case "Force": {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(32))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(32))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("dynamite", 8, null))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), GTModHandler.getIC2Item("dynamite", 8, null))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 16))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 16))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("industrialTnt", 4))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(4, aStack), GTModHandler.getIC2Item("industrialTnt", 4))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
+                                GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L),
+                                GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L))
                             .duration(1 * SECONDS)
                             .eut(TierEU.RECIPE_LV)
                             .addTo(implosionRecipes);
@@ -430,42 +426,42 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                 }
             }
             case dustPure, dustImpure, dustRefined -> {
-                Materials tByProduct = GT_Utility.selectItemInList(
+                Materials tByProduct = GTUtility.selectItemInList(
                     aPrefix == OrePrefixes.dustRefined ? 2 : aPrefix == OrePrefixes.dustPure ? 1 : 0,
                     aMaterial,
                     aMaterial.mOreByProducts);
                 if (aPrefix == OrePrefixes.dustPure) {
                     if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_GOLD)) {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(1, aStack))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(1, aStack))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Gold, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L))
+                                GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.dustSmall, Materials.Gold, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L))
                             .outputChances(10000, 4000, 2000)
                             .duration(20 * SECONDS)
                             .eut(24)
                             .addTo(electroMagneticSeparatorRecipes);
                     }
                     if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_IRON)) {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(1, aStack))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(1, aStack))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Iron, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Iron, 1L))
+                                GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.dustSmall, Materials.Iron, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.nugget, Materials.Iron, 1L))
                             .outputChances(10000, 4000, 2000)
                             .duration(20 * SECONDS)
                             .eut(24)
                             .addTo(electroMagneticSeparatorRecipes);
                     }
                     if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_NEODYMIUM)) {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(1, aStack))
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(1, aStack))
                             .itemOutputs(
-                                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Neodymium, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Neodymium, 1L))
+                                GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.dustSmall, Materials.Neodymium, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.nugget, Materials.Neodymium, 1L))
                             .outputChances(10000, 4000, 2000)
                             .duration(20 * SECONDS)
                             .eut(24)
@@ -473,70 +469,70 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                     }
                 }
                 if (aMaterial.contains(SubTag.CRYSTALLISABLE)
-                    && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) {
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                    && GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) {
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(1))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
                         .outputChances(9000)
                         .fluidInputs(Materials.Water.getFluid(200L))
                         .duration(1 * MINUTES + 40 * SECONDS)
                         .eut(24)
                         .addTo(autoclaveRecipes);
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(2))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(2))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
                         .outputChances(9500)
-                        .fluidInputs(GT_ModHandler.getDistilledWater(100L))
+                        .fluidInputs(GTModHandler.getDistilledWater(100L))
                         .duration(1 * MINUTES + 15 * SECONDS)
                         .eut(24)
                         .addTo(autoclaveRecipes);
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3))
-                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack), GTUtility.getIntegratedCircuit(3))
+                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))
                         .outputChances(10000)
                         .fluidInputs(Materials.Void.getMolten(36L))
                         .duration(1 * MINUTES)
                         .eut(24)
                         .addTo(autoclaveRecipes);
                 }
-                ItemStack tImpureStack = GT_OreDictUnificator.get(
+                ItemStack tImpureStack = GTOreDictUnificator.get(
                     OrePrefixes.dustTiny,
                     tByProduct,
-                    GT_OreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L),
+                    GTOreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L),
                     1L);
                 if (tImpureStack == null) {
-                    tImpureStack = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tByProduct, 1L);
+                    tImpureStack = GTOreDictUnificator.get(OrePrefixes.dustSmall, tByProduct, 1L);
                     if (tImpureStack == null) {
-                        tImpureStack = GT_OreDictUnificator.get(
+                        tImpureStack = GTOreDictUnificator.get(
                             OrePrefixes.dust,
                             tByProduct,
-                            GT_OreDictUnificator.get(OrePrefixes.gem, tByProduct, 1L),
+                            GTOreDictUnificator.get(OrePrefixes.gem, tByProduct, 1L),
                             1L);
                         if (tImpureStack == null) {
-                            tImpureStack = GT_OreDictUnificator.get(OrePrefixes.cell, tByProduct, 1L);
+                            tImpureStack = GTOreDictUnificator.get(OrePrefixes.cell, tByProduct, 1L);
                             if (tImpureStack == null) {
-                                GT_Values.RA.stdBuilder()
-                                    .itemInputs(GT_Utility.copyAmount(1, aStack))
-                                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                                GTValues.RA.stdBuilder()
+                                    .itemInputs(GTUtility.copyAmount(1, aStack))
+                                    .itemOutputs(GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
                                     .duration(Math.max(1L, aMaterial.getMass()))
                                     .eut(5)
                                     .addTo(centrifugeRecipes);
                             } else {
-                                FluidStack tFluid = GT_Utility.getFluidForFilledItem(tImpureStack, true);
+                                FluidStack tFluid = GTUtility.getFluidForFilledItem(tImpureStack, true);
                                 if (tFluid == null) {
-                                    GT_Values.RA.stdBuilder()
-                                        .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Cell_Empty.get(1))
+                                    GTValues.RA.stdBuilder()
+                                        .itemInputs(GTUtility.copyAmount(9, aStack), ItemList.Cell_Empty.get(1))
                                         .itemOutputs(
-                                            GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L),
+                                            GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L),
                                             tImpureStack)
                                         .duration(Math.max(1L, aMaterial.getMass() * 72L))
                                         .eut(5)
                                         .addTo(centrifugeRecipes);
                                 } else {
                                     tFluid.amount /= 10;
-                                    GT_Values.RA.stdBuilder()
-                                        .itemInputs(GT_Utility.copyAmount(1, aStack))
-                                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                                    GTValues.RA.stdBuilder()
+                                        .itemInputs(GTUtility.copyAmount(1, aStack))
+                                        .itemOutputs(GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
                                         .fluidOutputs(tFluid)
                                         .duration(Math.max(1L, aMaterial.getMass() * 8L))
                                         .eut(5)
@@ -544,30 +540,30 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                                 }
                             }
                         } else {
-                            GT_Values.RA.stdBuilder()
-                                .itemInputs(GT_Utility.copyAmount(9, aStack))
-                                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L), tImpureStack)
+                            GTValues.RA.stdBuilder()
+                                .itemInputs(GTUtility.copyAmount(9, aStack))
+                                .itemOutputs(GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L), tImpureStack)
                                 .duration(Math.max(1L, aMaterial.getMass() * 72L))
                                 .eut(5)
                                 .addTo(centrifugeRecipes);
                         }
                     } else {
-                        GT_Values.RA.stdBuilder()
-                            .itemInputs(GT_Utility.copyAmount(2, aStack))
-                            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L), tImpureStack)
+                        GTValues.RA.stdBuilder()
+                            .itemInputs(GTUtility.copyAmount(2, aStack))
+                            .itemOutputs(GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L), tImpureStack)
                             .duration(Math.max(1L, aMaterial.getMass() * 16L))
                             .eut(5)
                             .addTo(centrifugeRecipes);
                     }
                 } else {
-                    GT_Values.RA.stdBuilder()
-                        .itemInputs(GT_Utility.copyAmount(1, aStack))
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTUtility.copyAmount(1, aStack))
                         .itemOutputs(
-                            GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                            GT_OreDictUnificator.get(
+                            GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
+                            GTOreDictUnificator.get(
                                 OrePrefixes.dust,
                                 tByProduct,
-                                GT_OreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L),
+                                GTOreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L),
                                 1L))
                         .outputChances(10000, 1111)
                         .duration(Math.max(1L, aMaterial.getMass() * 8L))
@@ -576,17 +572,17 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                 }
             }
             case dustSmall -> {
-                GT_Values.RA.stdBuilder()
-                    .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Schematic_Dust.get(0L))
-                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                GTValues.RA.stdBuilder()
+                    .itemInputs(GTUtility.copyAmount(4, aStack), ItemList.Schematic_Dust.get(0L))
+                    .itemOutputs(GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
                     .duration(1 * SECONDS)
                     .eut(4)
                     .addTo(packagerRecipes);
                 if (!aMaterial.mBlastFurnaceRequired) {
-                    GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null);
+                    GTRecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null);
                     if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) {
-                        GT_RecipeRegistrator.registerReverseArcSmelting(
-                            GT_Utility.copyAmount(1, aStack),
+                        GTRecipeRegistrator.registerReverseArcSmelting(
+                            GTUtility.copyAmount(1, aStack),
                             aMaterial,
                             aPrefix.mMaterialAmount,
                             null,
@@ -596,17 +592,17 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                 }
             }
             case dustTiny -> {
-                GT_Values.RA.stdBuilder()
-                    .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Schematic_Dust.get(0L))
-                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                GTValues.RA.stdBuilder()
+                    .itemInputs(GTUtility.copyAmount(9, aStack), ItemList.Schematic_Dust.get(0L))
+                    .itemOutputs(GTOreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
                     .duration(1 * SECONDS)
                     .eut(4)
                     .addTo(packagerRecipes);
                 if (!aMaterial.mBlastFurnaceRequired) {
-                    GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null);
+                    GTRecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null);
                     if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) {
-                        GT_RecipeRegistrator.registerReverseArcSmelting(
-                            GT_Utility.copyAmount(1, aStack),
+                        GTRecipeRegistrator.registerReverseArcSmelting(
+                            GTUtility.copyAmount(1, aStack),
                             aMaterial,
                             aPrefix.mMaterialAmount,
                             null,
@@ -616,7 +612,7 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr
                 }
                 if (!aMaterial.contains(SubTag.NO_SMELTING)) {
                     if (aMaterial.mBlastFurnaceRequired) {
-                        GT_ModHandler.removeFurnaceSmelting(aStack);
+                        GTModHandler.removeFurnaceSmelting(aStack);
                     }
                 }
             }