% Refactored the entire project to stop using MiscUtils everywhere possible, now it's gtPlusPlus.

25 files changed, 4032 insertions, 0 deletions

diff --git a/src/Java/gtPlusPlus/core/util/BaseHandler.java b/src/Java/gtPlusPlus/core/util/BaseHandler.java
new file mode 100644
index 0000000000..63f22f3763
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/BaseHandler.java
@@ -0,0 +1,11 @@
+package gtPlusPlus.core.util;
+
+public abstract class BaseHandler {
+
+	public abstract void preInit();
+	
+	public abstract void init();
+	
+	public abstract void postInit();
+	
+}
diff --git a/src/Java/gtPlusPlus/core/util/ClassUtils.java b/src/Java/gtPlusPlus/core/util/ClassUtils.java
new file mode 100644
index 0000000000..ba3db748f9
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/ClassUtils.java
@@ -0,0 +1,78 @@
+package gtPlusPlus.core.util;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ClassUtils {
+
+
+	/*@ if (isPresent("com.optionaldependency.DependencyClass")) {
+    //  This block will never execute when the dependency is not present
+    //  There is therefore no more risk of code throwing NoClassDefFoundException.
+    executeCodeLinkingToDependency();
+	}*/
+	public static boolean isPresent(String className) {
+		try {
+			Class.forName(className);
+			return true;
+		} catch (Throwable ex) {
+			// Class or one of its dependencies is not present...
+			return false;
+		}
+	}
+
+	public static Method getMethodViaReflection(Class<?> lookupClass, String methodName, boolean invoke) throws Exception{
+		Class<? extends Class> lookup = lookupClass.getClass();
+		Method m = lookup.getDeclaredMethod(methodName);
+		m.setAccessible(true);// Abracadabra 
+		if (invoke){
+			m.invoke(lookup);// now its OK
+		}
+		return m;
+	}
+
+	public static Class getNonPublicClass(String className){
+		Class<?> c = null;
+		try {
+			c = Class.forName(className);
+		} catch (ClassNotFoundException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		//full package name --------^^^^^^^^^^
+		//or simpler without Class.forName:
+		//Class<package1.A> c = package1.A.class;
+
+		if (null != c){
+			//In our case we need to use
+			Constructor<?> constructor = null;
+			try {
+				constructor = c.getDeclaredConstructor();
+			} catch (NoSuchMethodException | SecurityException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			//note: getConstructor() can return only public constructors
+			//so we needed to search for any Declared constructor
+
+			//now we need to make this constructor accessible
+			if (null != constructor){
+				constructor.setAccessible(true);//ABRACADABRA!
+
+				try {
+					Object o = constructor.newInstance();
+					return (Class) o;
+				} catch (InstantiationException | IllegalAccessException
+						| IllegalArgumentException | InvocationTargetException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+		}
+		return null;
+	}
+
+
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/Log.java b/src/Java/gtPlusPlus/core/util/Log.java
new file mode 100644
index 0000000000..ea7076e453
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/Log.java
@@ -0,0 +1,29 @@
+package gtPlusPlus.core.util;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public final class Log
+{
+  public static final Logger LOGGER = LogManager.getLogger("MiscUtils");
+  
+  public static void warn(String msg)
+  {
+    LOGGER.warn(msg);
+  }
+  
+  public static void error(String msg)
+  {
+    LOGGER.error(msg);
+  }
+  
+  public static void info(String msg)
+  {
+    LOGGER.info(msg);
+  }
+  
+  public static void debug(String msg)
+  {
+    LOGGER.debug(msg);
+  }
+}
diff --git a/src/Java/gtPlusPlus/core/util/LoggingUtils.java b/src/Java/gtPlusPlus/core/util/LoggingUtils.java
new file mode 100644
index 0000000000..7783577ee2
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/LoggingUtils.java
@@ -0,0 +1,54 @@
+package gtPlusPlus.core.util;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Date;
+
+public class LoggingUtils {
+
+	public static void profileLog(Object o){    	
+    	try {
+			String content;
+			File file = new File("GregtechTimingsTC.txt");
+			// if file doesnt exists, then create it
+			if (!file.exists()) {
+				file.createNewFile();
+				FileWriter fw = new FileWriter(file.getAbsoluteFile(), true);
+				BufferedWriter bw = new BufferedWriter(fw);
+				bw.write("============================================================");
+				bw.write(System.lineSeparator());
+				bw.close();
+			}			
+			if (o instanceof String){
+				content = (String) o;
+    		}
+    		else {
+    	    content = o.toString();
+    		}		
+			FileWriter fw = new FileWriter(file.getAbsoluteFile(), true);
+			BufferedWriter bw = new BufferedWriter(fw);
+			bw.write(content);
+			bw.write(System.lineSeparator());
+			bw.close();
+			System.out.println("Data Logged.");
+
+		} catch (IOException e) {
+			System.out.println("Data logging failed.");
+		}
+    }
+	
+	public static boolean logCurrentSystemTime(String message){
+		Date date = new Date(System.currentTimeMillis());
+    	try {
+		profileLog(message+" | "+date.toString());
+		return true;
+    	}
+    	catch (Throwable r) {
+    		return false;
+    	}
+    	
+	}
+	
+}
diff --git a/src/Java/gtPlusPlus/core/util/Utils.java b/src/Java/gtPlusPlus/core/util/Utils.java
new file mode 100644
index 0000000000..f6430cc75d
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/Utils.java
@@ -0,0 +1,539 @@
+package gtPlusPlus.core.util;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TC_Aspects;
+import gregtech.api.enums.TC_Aspects.TC_AspectStack;
+import gtPlusPlus.GTplusplus;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.fluid.FluidUtils;
+import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.math.MathUtils;
+import ic2.core.IC2Potion;
+import ic2.core.Ic2Items;
+import ic2.core.init.InternalName;
+import ic2.core.item.armor.ItemArmorHazmat;
+import ic2.core.item.resources.ItemCell;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.UUID;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item.ToolMaterial;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.util.EnumHelper;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.registry.EntityRegistry;
+
+public class Utils {
+
+	public static final int WILDCARD_VALUE = Short.MAX_VALUE;
+
+	static class ShortTimerTask extends TimerTask {
+		@Override
+		public void run() {
+			Utils.LOG_WARNING("Timer expired.");
+		}
+	}
+
+	public static TC_AspectStack getTcAspectStack (TC_Aspects aspect, int size){
+
+		TC_AspectStack returnValue = null;
+
+		if (aspect.name().toUpperCase() == "COGNITIO"){
+			//Adds in Compat for older GT Versions which Misspell aspects.
+			try {
+				returnValue = new TC_AspectStack(TC_Aspects.valueOf("COGNITIO"), size);
+			} catch (NoSuchFieldError r){
+				Utils.LOG_INFO("Fallback TC Aspect found - "+aspect.name()+" - PLEASE UPDATE GREGTECH TO A NEWER VERSION TO REMOVE THIS MESSAGE - THIS IS NOT AN ERROR");
+				returnValue = new TC_AspectStack(TC_Aspects.valueOf("COGNITO"), size);
+
+			}
+		}
+		else if (aspect.name().toUpperCase() == "EXANIMUS"){
+			//Adds in Compat for older GT Versions which Misspell aspects.
+			try {
+				returnValue = new TC_AspectStack(TC_Aspects.valueOf("EXANIMUS"), size);
+			} catch (NoSuchFieldError r){
+				Utils.LOG_INFO("Fallback TC Aspect found - "+aspect.name()+" - PLEASE UPDATE GREGTECH TO A NEWER VERSION TO REMOVE THIS MESSAGE - THIS IS NOT AN ERROR");
+				returnValue = new TC_AspectStack(TC_Aspects.valueOf("EXAMINIS"), size);
+			}
+		}
+		else if (aspect.name().toUpperCase() == "PRAECANTATIO"){
+			//Adds in Compat for older GT Versions which Misspell aspects.
+			try {
+				returnValue = new TC_AspectStack(TC_Aspects.valueOf("PRAECANTATIO"), size);
+			} catch (NoSuchFieldError r){
+				Utils.LOG_INFO("Fallback TC Aspect found - "+aspect.name()+" - PLEASE UPDATE GREGTECH TO A NEWER VERSION TO REMOVE THIS MESSAGE - THIS IS NOT AN ERROR");
+				returnValue = new TC_AspectStack(TC_Aspects.valueOf("PRAECANTIO"), size);
+			}
+		}
+		else {
+			returnValue = new TC_AspectStack(aspect, size);
+		}
+
+		return returnValue;
+	}
+
+	public static boolean containsMatch(boolean strict, ItemStack[] inputs, ItemStack... targets)
+	{
+		for (ItemStack input : inputs)
+		{
+			for (ItemStack target : targets)
+			{
+				if (itemMatches(target, input, strict))
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	public static boolean itemMatches(ItemStack target, ItemStack input, boolean strict)
+	{
+		if (input == null || target == null)
+		{
+			return false;
+		}
+		return (target.getItem() == input.getItem() && ((target.getItemDamage() == WILDCARD_VALUE && !strict) || target.getItemDamage() == input.getItemDamage()));
+	}
+
+	//TODO
+	public static void registerEntityToBiomeSpawns(Class<EntityLiving> classy, EnumCreatureType EntityType, BiomeGenBase baseBiomeGen){
+		EntityRegistry.addSpawn(classy, 6, 1, 5, EntityType, baseBiomeGen); //change the values to vary the spawn rarity, biome, etc. 
+	}
+
+	//Non-Dev Comments 
+	public static void LOG_INFO(String s){
+		//if (CORE.DEBUG){
+		FMLLog.info("GT++: "+s);
+		//}
+	}
+
+	//Developer Comments
+	public static void LOG_WARNING(String s){
+		if (CORE.DEBUG){
+			FMLLog.warning("GT++: "+s);
+		}
+	}
+
+	//Errors
+	public static void LOG_ERROR(String s){
+		if (CORE.DEBUG){
+			FMLLog.severe("GT++: "+s);
+		}
+	}
+
+	//Developer Logger
+	public static void LOG_SPECIFIC_WARNING(String whatToLog, String msg, int line){
+		if (CORE.DEBUG){		
+			FMLLog.warning("GT++ |"+line+"| "+whatToLog+" | "+msg);
+		}			
+	}
+
+	public static void paintBox(Graphics g, int MinA, int MinB, int MaxA, int MaxB){
+		g.drawRect (MinA, MinB, MaxA, MaxB);  
+	}
+
+	public static void messagePlayer(EntityPlayer P, String S){
+		gregtech.api.util.GT_Utility.sendChatToPlayer(P, S);
+	}
+
+	/**
+	 * Returns if that Liquid is IC2Steam.
+	 */
+	public static boolean isIC2Steam(FluidStack aFluid) {
+		if (aFluid == null) return false;
+		return aFluid.isFluidEqual(getIC2Steam(1));
+	}
+
+	/**
+	 * Returns a Liquid Stack with given amount of IC2Steam.
+	 */
+	public static FluidStack getIC2Steam(long aAmount) {
+		return FluidRegistry.getFluidStack("ic2steam", (int)aAmount);
+	}
+
+
+
+	/*public static void recipeBuilderBlock(ItemStack slot_1, ItemStack slot_2, ItemStack slot_3, ItemStack slot_4, ItemStack slot_5, ItemStack slot_6, ItemStack slot_7, ItemStack slot_8, ItemStack slot_9, Block resultBlock){
+		GameRegistry.addRecipe(new ItemStack(resultBlock),
+				new Object[] {"ABC", "DEF", "GHI",
+			'A',slot_1,'B',slot_2,'C',slot_3,
+			'D',slot_4,'E',slot_5,'F',slot_6,
+			'G',slot_7,'H',slot_8,'I',slot_9
+		});			
+	}*/
+
+	public static String checkCorrectMiningToolForBlock(Block currentBlock, World currentWorld){
+		String correctTool = "";
+		if (!currentWorld.isRemote){			
+			try {
+				correctTool = currentBlock.getHarvestTool(0);
+				Utils.LOG_WARNING(correctTool);
+
+			} catch (NullPointerException e){
+
+			}
+		}
+
+		return correctTool;
+	}
+
+	/**
+	 * 
+	 * @param colorStr e.g. "#FFFFFF"
+	 * @return String - formatted "rgb(0,0,0)"
+	 */
+	public static String hex2Rgb(String hexString) {
+		Color c = new Color(
+				Integer.valueOf(hexString.substring(1, 3), 16), 
+				Integer.valueOf(hexString.substring(3, 5), 16), 
+				Integer.valueOf(hexString.substring(5, 7), 16));
+
+		StringBuffer sb = new StringBuffer();
+		sb.append("rgb(");
+		sb.append(c.getRed());
+		sb.append(",");
+		sb.append(c.getGreen());
+		sb.append(",");
+		sb.append(c.getBlue());
+		sb.append(")");
+		return sb.toString();
+	}
+
+	public static Timer ShortTimer(int seconds) {
+		Timer timer;
+		timer = new Timer();
+		timer.schedule(new ShortTimerTask(), seconds * 1000);
+		return timer;
+	}
+
+	public static String byteToHex(byte b) {
+		int i = b & 0xFF;
+		return Integer.toHexString(i);
+	}
+
+	public static Object[] convertListToArray(List<Object> sourceList) {	
+		Object[] targetArray = sourceList.toArray(new Object[sourceList.size()]);
+		return targetArray;
+	}
+
+	public static List<Object> convertArrayToListFixed(Object[] sourceArray) {
+		List<Object> targetList = Arrays.asList(sourceArray);
+		return targetList;
+	}
+
+	public static List<Object> convertArrayToList(Object[] sourceArray) {
+		List<Object> targetList = new ArrayList<Object>(Arrays.asList(sourceArray));
+		return targetList;
+	}
+
+	public static EntityPlayer getPlayerOnServerFromUUID(UUID parUUID){
+		if (parUUID == null) 
+		{
+			return null;
+		}
+		List<EntityPlayerMP> allPlayers = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
+		for (EntityPlayerMP player : allPlayers) 
+		{
+			if (player.getUniqueID().equals(parUUID)) 
+			{
+				return player;
+			}
+		}
+		return null;
+	}
+
+	@Deprecated
+	public static Block findBlockUnderEntityNonBoundingBox(Entity parEntity){
+		int blockX = MathHelper.floor_double(parEntity.posX);
+		int blockY = MathHelper.floor_double(parEntity.posY-0.2D - (double)parEntity.yOffset);
+		int blockZ = MathHelper.floor_double(parEntity.posZ);
+		return parEntity.worldObj.getBlock(blockX, blockY, blockZ);
+	}
+
+	public static Block findBlockUnderEntity(Entity parEntity){
+		int blockX = MathHelper.floor_double(parEntity.posX);
+		int blockY = MathHelper.floor_double(parEntity.boundingBox.minY)-1;
+		int blockZ = MathHelper.floor_double(parEntity.posZ);
+		return parEntity.worldObj.getBlock(blockX, blockY, blockZ);
+	}
+
+	public static int getFacingDirection(Entity entity){
+		int d = MathHelper.floor_double((double) (entity.rotationYaw * 4.0F / 360) + 0.50) & 3;
+		return d;
+	}
+
+	public static boolean isPlayerOP(EntityPlayer player){
+		if (player.canCommandSenderUseCommand(2, "")){
+			return true;
+		}
+		return false;
+	}
+
+	public static void setEntityOnFire(Entity entity, int length){
+		entity.setFire(length);
+	}
+
+	public static void spawnCustomParticle(Entity entity){
+		GTplusplus.proxy.generateMysteriousParticles(entity);
+	}	
+
+	public static void spawnFX(World world, int x, int y, int z, String particleName, Object particleName2){
+		if (!world.isRemote){
+			if (particleName2 == null || particleName2.equals("")){
+				particleName2 = particleName;
+			}
+			int l = MathUtils.randInt(0, 4);
+			double d0 = (double)((float)x + 0.5F);
+			double d1 = (double)((float)y + 0.7F);
+			double d2 = (double)((float)z + 0.5F);
+			double d3 = 0.2199999988079071D;
+			double d4 = 0.27000001072883606D;
+
+			if (l == 1)
+			{
+				world.spawnParticle(particleName, d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
+			}
+			else if (l == 2)
+			{
+				world.spawnParticle((String) particleName2, d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
+			}
+			else if (l == 3)
+			{
+				world.spawnParticle(particleName, d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
+			}
+			else if (l == 4)
+			{
+				world.spawnParticle((String) particleName2, d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
+			}
+			else
+			{
+				world.spawnParticle(particleName, d0, d1, d2, 0.0D, 0.0D, 0.0D);
+				if (particleName2 != null){
+					world.spawnParticle((String) particleName2, d0, d1, d2, 0.0D, 0.0D, 0.0D);
+				}
+			}
+		}
+	}
+
+	public static int rgbtoHexValue(int r, int g, int b){		    
+		Color c = new Color(r,g,b);
+		String temp = Integer.toHexString( c.getRGB() & 0xFFFFFF ).toUpperCase();	
+
+		//System.out.println( "hex: " + Integer.toHexString( c.getRGB() & 0xFFFFFF ) + " hex value:"+temp); 
+		temp = Utils.appenedHexNotationToString(String.valueOf(temp));
+		Utils.LOG_WARNING("Made "+temp+" - Hopefully it's not a mess.");
+		Utils.LOG_WARNING("It will decode into "+Integer.decode(temp)+".");
+		return Integer.decode(temp);
+	}
+
+	/*
+	 * http://javadevnotes.com/java-left-pad-string-with-zeros-examples
+	 */
+	public static String leftPadWithZeroes(String originalString, int length) {
+		StringBuilder sb = new StringBuilder();
+		while (sb.length() + originalString.length() < length) {
+			sb.append('0');
+		}
+		sb.append(originalString);
+		String paddedString = sb.toString();
+		return paddedString;
+	}
+
+	/*
+	 * Original Code by Chandana Napagoda - https://cnapagoda.blogspot.com.au/2011/03/java-hex-color-code-generator.html
+	 */	
+	public static Map<Integer, String> hexColourGenerator(int colorCount){
+		int maxColorValue = 16777215;
+		// this is decimal value of the "FFFFFF"
+		int devidedvalue = maxColorValue/colorCount;
+		int countValue = 0;
+		HashMap<Integer, String> hexColorMap = new HashMap<Integer, String>();
+		for(int a=0; a < colorCount && maxColorValue >= countValue ; a++){
+			if(a != 0){
+				countValue+=devidedvalue;
+				hexColorMap.put(a,Integer.toHexString( 0x10000 | countValue).substring(1).toUpperCase());
+			}
+			else {
+				hexColorMap.put(a,Integer.toHexString( 0x10000 | countValue).substring(1).toUpperCase());
+			}
+		}
+		return hexColorMap;
+	}
+
+	/*
+	 * Original Code by Chandana Napagoda - https://cnapagoda.blogspot.com.au/2011/03/java-hex-color-code-generator.html
+	 */
+	public static Map<Integer, String> hexColourGeneratorRandom(int colorCount){
+		HashMap<Integer, String> hexColorMap = new HashMap<Integer, String>();
+		for(int a=0;a < colorCount; a++){
+			String code = ""+(int)(Math.random()*256);
+			code = code+code+code;
+			int  i = Integer.parseInt(code);
+			hexColorMap.put(a,Integer.toHexString( 0x1000000 | i).substring(1).toUpperCase());
+			Utils.LOG_INFO(""+Integer.toHexString( 0x1000000 | i).substring(1).toUpperCase());
+		}
+		return hexColorMap;
+	}
+
+	public static String appenedHexNotationToString(Object hexAsStringOrInt){
+		String hexChar = "0x";
+		String result;
+		if (hexAsStringOrInt.getClass() == String.class){
+
+			if (((String) hexAsStringOrInt).length() != 6){
+				String temp = leftPadWithZeroes((String) hexAsStringOrInt, 6);
+				result = temp;
+			}
+			result = hexChar+hexAsStringOrInt;
+			return result;
+		}
+		else if (hexAsStringOrInt.getClass() == Integer.class){
+			;
+			if (((String) hexAsStringOrInt).length() != 6){
+				String temp = leftPadWithZeroes((String) hexAsStringOrInt, 6);
+				result = temp;
+			}
+			result = hexChar+String.valueOf(hexAsStringOrInt);
+			return result;
+		}
+		else {
+			return null;
+		}
+	}
+
+	public static Integer appenedHexNotationToInteger(int hexAsStringOrInt){
+		String hexChar = "0x";
+		String result;
+		Utils.LOG_INFO(String.valueOf(hexAsStringOrInt));
+		result = hexChar+String.valueOf(hexAsStringOrInt);
+		return Integer.getInteger(result);
+	}
+
+	public static boolean doesEntryExistAlreadyInOreDictionary(String OreDictName){
+		if (OreDictionary.getOres(OreDictName).size() != 0) {
+			return true;
+		}
+		return false;
+	}
+
+	public static boolean invertBoolean(boolean booleans){
+		if (booleans == true){
+			return false;
+		}
+		return true;
+	}
+
+	public static boolean applyRadiationDamageToEntity(int damage, World world, Entity entityHolding){
+		if (!world.isRemote){				
+			if (damage > 0 && (entityHolding instanceof EntityLivingBase)) {
+				EntityLivingBase entityLiving = (EntityLivingBase) entityHolding;
+				if (!ItemArmorHazmat.hasCompleteHazmat(entityLiving)) {
+					int duration;
+					if (entityLiving.getActivePotionEffect(IC2Potion.radiation) != null){
+						//Utils.LOG_INFO("t");
+						duration = (damage*5)+entityLiving.getActivePotionEffect(IC2Potion.radiation).getDuration();
+					}
+					else {
+						//Utils.LOG_INFO("f");
+						duration = damage*30;
+					}					
+					IC2Potion.radiation.applyTo(entityLiving, duration, damage * 15);
+				}
+			}
+			return true;
+		}
+		return false;		
+	}
+
+	private static short cellID = 15;
+	public static ItemStack createInternalNameAndFluidCell(String s){
+		Utils.LOG_WARNING("1");
+		InternalName yourName = EnumHelper.addEnum(InternalName.class, s, new Class[0], new Object[0]);
+		Utils.LOG_WARNING("2 "+yourName.name());
+		ItemCell item = (ItemCell)Ic2Items.cell.getItem();
+		Utils.LOG_WARNING("3 "+item.getUnlocalizedName());
+		try
+		{
+			Utils.LOG_WARNING("4");
+			Class<? extends ItemCell> clz = item.getClass();
+			Utils.LOG_WARNING("5 "+clz.getSimpleName());
+			Method methode = clz.getDeclaredMethod("addCell", int.class, InternalName.class, Block[].class);
+			Utils.LOG_WARNING("6 "+methode.getName());
+			methode.setAccessible(true);
+			Utils.LOG_WARNING("7 "+methode.isAccessible());
+			ItemStack temp = (ItemStack) methode.invoke(item, cellID++, yourName, new Block[0]);
+			Utils.LOG_INFO("Successfully created "+temp.getDisplayName()+"s.");
+			FluidContainerRegistry.registerFluidContainer(FluidUtils.getFluidStack(s.toLowerCase(), 0), temp.copy(), Ic2Items.cell.copy());
+			UtilsItems.addItemToOreDictionary(temp.copy(), "cell"+s);
+			return temp;
+		}
+		catch(Exception e){
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public static String sanitizeString(String input){
+		String temp;
+		String output;
+		
+		temp = input.replace(" ", "");
+		temp = temp.replace("-", "");
+		temp = temp.replace("_", "");
+		temp = temp.replace("?", "");
+		temp = temp.replace("!", "");
+		temp = temp.replace("@", "");
+		temp = temp.replace("#", "");
+		temp = temp.replace("(", "");
+		temp = temp.replace(")", "");
+		temp = temp.replace("{", "");
+		temp = temp.replace("}", "");
+		temp = temp.replace("[", "");
+		temp = temp.replace("]", "");
+		output = temp;		
+		return output;
+		
+	}
+	
+	public static ToolMaterial generateMaterialFromGT(Materials gtMaterial){
+		String name = gtMaterial.name();
+		int harvestLevel = gtMaterial.mToolQuality;
+		int durability = gtMaterial.mDurability;
+		float damage = gtMaterial.mToolQuality;
+		int efficiency = (int) gtMaterial.mToolSpeed;
+		int enchantability = gtMaterial.mEnchantmentToolsLevel;
+		ToolMaterial temp = EnumHelper.addToolMaterial(name, harvestLevel, durability, efficiency, damage, enchantability);
+		return temp;
+		
+	}
+
+
+}
+
+
diff --git a/src/Java/gtPlusPlus/core/util/UtilsChatFormatting.java b/src/Java/gtPlusPlus/core/util/UtilsChatFormatting.java
new file mode 100644
index 0000000000..9e358b3074
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/UtilsChatFormatting.java
@@ -0,0 +1,156 @@
+package gtPlusPlus.core.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public enum UtilsChatFormatting
+{
+    BLACK('0'),
+    DARK_BLUE('1'),
+    DARK_GREEN('2'),
+    DARK_AQUA('3'),
+    DARK_RED('4'),
+    DARK_PURPLE('5'),
+    GOLD('6'),
+    GRAY('7'),
+    DARK_GRAY('8'),
+    BLUE('9'),
+    GREEN('a'),
+    AQUA('b'),
+    RED('c'),
+    LIGHT_PURPLE('d'),
+    YELLOW('e'),
+    WHITE('f'),
+    OBFUSCATED('k', true),
+    BOLD('l', true),
+    STRIKETHROUGH('m', true),
+    UNDERLINE('n', true),
+    ITALIC('o', true),
+    RESET('r');
+    /** Maps a formatting code (e.g., 'f') to its corresponding enum value (e.g., WHITE). */
+    private static final Map<Character, UtilsChatFormatting> formattingCodeMapping = new HashMap<Character, UtilsChatFormatting>();
+    /** Maps a name (e.g., 'underline') to its corresponding enum value (e.g., UNDERLINE). */
+    private static final Map<String, UtilsChatFormatting> nameMapping = new HashMap<String, UtilsChatFormatting>();
+    /**
+     * Matches formatting codes that indicate that the client should treat the following text as bold, recolored,
+     * obfuscated, etc.
+     */
+    private static final Pattern formattingCodePattern = Pattern.compile("(?i)" + String.valueOf('\u00a7') + "[0-9A-FK-OR]");
+    /** The formatting code that produces this format. */
+    private final char formattingCode;
+    private final boolean fancyStyling;
+    /**
+     * The control string (section sign + formatting code) that can be inserted into client-side text to display
+     * subsequent text in this format.
+     */
+    private final String controlString;
+
+    private UtilsChatFormatting(char p_i1336_3_)
+    {
+        this(p_i1336_3_, false);
+    }
+
+    private UtilsChatFormatting(char p_i1337_3_, boolean p_i1337_4_)
+    {
+        this.formattingCode = p_i1337_3_;
+        this.fancyStyling = p_i1337_4_;
+        this.controlString = "\u00a7" + p_i1337_3_;
+    }
+
+    /**
+     * Gets the formatting code that produces this format.
+     */
+    public char getFormattingCode()
+    {
+        return this.formattingCode;
+    }
+
+    /**
+     * False if this is just changing the color or resetting; true otherwise.
+     */
+    public boolean isFancyStyling()
+    {
+        return this.fancyStyling;
+    }
+
+    /**
+     * Checks if typo is a color.
+     */
+    public boolean isColor()
+    {
+        return !this.fancyStyling && this != RESET;
+    }
+
+    /**
+     * Gets the friendly name of this value.
+     */
+    public String getFriendlyName()
+    {
+        return this.name().toLowerCase();
+    }
+
+    @Override
+	public String toString()
+    {
+        return this.controlString;
+    }
+
+    /**
+     * Returns a copy of the given string, with formatting codes stripped away.
+     */
+    @SideOnly(Side.CLIENT)
+    public static String getTextWithoutFormattingCodes(String p_110646_0_)
+    {
+        return p_110646_0_ == null ? null : formattingCodePattern.matcher(p_110646_0_).replaceAll("");
+    }
+
+    /**
+     * Gets a value by its friendly name; null if the given name does not map to a defined value.
+     */
+    public static UtilsChatFormatting getValueByName(String p_96300_0_)
+    {
+        return p_96300_0_ == null ? null : (UtilsChatFormatting)nameMapping.get(p_96300_0_.toLowerCase());
+    }
+
+    /**
+     * Gets all the valid values. Args: @param par0: Whether or not to include color values. @param par1: Whether or not
+     * to include fancy-styling values (anything that isn't a color value or the "reset" value).
+     */
+    public static Collection<String> getValidValues(boolean p_96296_0_, boolean p_96296_1_)
+    {
+        ArrayList<String> arraylist = new ArrayList<String>();
+        UtilsChatFormatting[] aenumchatformatting = values();
+        int i = aenumchatformatting.length;
+
+        for (int j = 0; j < i; ++j)
+        {
+            UtilsChatFormatting enumchatformatting = aenumchatformatting[j];
+
+            if ((!enumchatformatting.isColor() || p_96296_0_) && (!enumchatformatting.isFancyStyling() || p_96296_1_))
+            {
+                arraylist.add(enumchatformatting.getFriendlyName());
+            }
+        }
+
+        return arraylist;
+    }
+
+    static
+    {
+        UtilsChatFormatting[] var0 = values();
+        int var1 = var0.length;
+
+        for (int var2 = 0; var2 < var1; ++var2)
+        {
+            UtilsChatFormatting var3 = var0[var2];
+            formattingCodeMapping.put(Character.valueOf(var3.getFormattingCode()), var3);
+            nameMapping.put(var3.getFriendlyName(), var3);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/util/UtilsRarity.java b/src/Java/gtPlusPlus/core/util/UtilsRarity.java
new file mode 100644
index 0000000000..19339b7717
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/UtilsRarity.java
@@ -0,0 +1,23 @@
+package gtPlusPlus.core.util;
+
+import net.minecraft.util.EnumChatFormatting;
+
+public enum UtilsRarity
+{
+    T1_poor(EnumChatFormatting.GRAY, "Poor"),
+    T2_normal(EnumChatFormatting.WHITE, "Common"),
+    T3_uncommon(EnumChatFormatting.GREEN, "Uncommon"),
+    T4_magic(EnumChatFormatting.BLUE, "Magic"),
+    T5_rare(EnumChatFormatting.LIGHT_PURPLE, "Rare"),
+    T6_epic(EnumChatFormatting.YELLOW, "Epic"),
+    T8_unique(EnumChatFormatting.GOLD, "Unique");
+   
+    public final EnumChatFormatting rarityColor;
+    public final String rarityName;
+
+    private UtilsRarity(EnumChatFormatting rarity, String name)
+    {
+        this.rarityColor = rarity;
+        this.rarityName = name;
+    }
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/util/UtilsText.java b/src/Java/gtPlusPlus/core/util/UtilsText.java
new file mode 100644
index 0000000000..e91fa95e4c
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/UtilsText.java
@@ -0,0 +1,32 @@
+package gtPlusPlus.core.util;
+
+public enum UtilsText {
+
+	blue('1'),
+	green('2'),
+	teal('3'),
+	maroon('4'),
+	purple('5'),
+	orange('6'),
+	lightGray('7'),
+	darkGray('8'),
+	lightBlue('9'),
+	black('0'),
+	lime('a'),
+	aqua('b'),
+	red('c'),
+	pink('d'),
+	yellow('e'),
+	white('f');
+
+	private char colourValue;
+	private UtilsText (char value)
+	{
+		this.colourValue = value;
+	}
+
+	public String colour() {
+		return "§"+colourValue;
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/debug/DEBUG_BLOCK_ShapeSpawner.java b/src/Java/gtPlusPlus/core/util/debug/DEBUG_BLOCK_ShapeSpawner.java
new file mode 100644
index 0000000000..74df9f90ba
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/DEBUG_BLOCK_ShapeSpawner.java
@@ -0,0 +1,139 @@
+package gtPlusPlus.core.util.debug;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gtPlusPlus.core.util.Utils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class DEBUG_BLOCK_ShapeSpawner extends DEBUG_MULTIBLOCK_ShapeSpawner {
+
+	private static boolean controller;
+
+	public DEBUG_BLOCK_ShapeSpawner(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+	}
+
+	public DEBUG_BLOCK_ShapeSpawner(String aName) {
+		super(aName);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new DEBUG_BLOCK_ShapeSpawner(this.mName);
+	}
+
+	
+	public String[] getDescription() {
+		return new String[]{
+				"Controller Block for the Testing",
+				"Create the shapes for Multiblocks.",};
+	}
+
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity arg0, byte arg1,
+			byte arg2, byte arg3, boolean arg4, boolean arg5) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack aStack) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		
+		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+		
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 0, zDir)) {
+			return false;
+		}
+		
+		int stepX = aBaseMetaTileEntity.getXCoord();
+		int stepY = aBaseMetaTileEntity.getYCoord();
+		int stepZ = aBaseMetaTileEntity.getZCoord();
+		int temp = 0;
+
+		Utils.LOG_INFO("Starting Block located @ "+"[X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+
+		int tAmount = 0;
+		switch (xDir) {
+		case -1:
+			stepX++;
+			Utils.LOG_INFO("Modifying stepX + accomodate a "+xDir+" xDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+
+		case 1:
+			stepX--;
+			Utils.LOG_INFO("Modifying stepX - accomodate a "+xDir+" xDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+		}
+		switch (zDir) {
+		case -1:
+			stepZ++;
+			Utils.LOG_INFO("Modifying stepZ + accomodate a "+zDir+" zDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+
+		case 1:
+			stepZ--;
+			Utils.LOG_INFO("Modifying stepZ - accomodate a "+zDir+" zDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+		}
+
+		for (int i = stepX-1; i <= stepX+1; i++){
+			for (int j = stepZ-1; j <= stepZ+1; j++){
+				for (int h = stepY-1; h <= stepY+1; h++){	
+
+
+					Utils.LOG_INFO("Block Facing - X:"+xDir+"    Z:"+zDir);
+					Utils.LOG_INFO("(h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))");
+					Utils.LOG_INFO("  "+(h != 0)+"   ||       "+(((xDir + i != 0)+"       ||       "+(zDir + j != 0))+"       &&    "+((i != 0)+"   ||   "+(j != 0))));
+				}
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public int getMaxEfficiency(ItemStack aStack) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public int getPollutionPerTick(ItemStack aStack) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public int getDamageToComponent(ItemStack aStack) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public int getAmountOfOutputs() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/debug/DEBUG_INIT.java b/src/Java/gtPlusPlus/core/util/debug/DEBUG_INIT.java
new file mode 100644
index 0000000000..440949471c
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/DEBUG_INIT.java
@@ -0,0 +1,43 @@
+package gtPlusPlus.core.util.debug;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.item.ModItems;
+import gtPlusPlus.core.item.base.BaseItemWithCharge;
+import gtPlusPlus.core.item.general.BedLocator_Base;
+import gtPlusPlus.core.lib.CORE;
+import net.minecraftforge.common.MinecraftForge;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class DEBUG_INIT {
+
+	public static void registerBlocks(){
+		//Debug Loading
+		if (CORE.DEBUG){
+
+		}
+	}
+
+	public static void registerItems(){
+		ModItems.itemDebugShapeSpawner = new DEBUG_ITEM_ShapeSpawner("itemDebugShapeSpawner", AddToCreativeTab.tabMisc, 1, 500);
+		GameRegistry.registerItem(ModItems.itemDebugShapeSpawner, "itemDebugShapeSpawner");
+		ModItems.itemBedLocator_Base = new BedLocator_Base("itemBedLocator_Base");
+		GameRegistry.registerItem(ModItems.itemBedLocator_Base, "itemBedLocator_Base");		
+		ModItems.itemBaseItemWithCharge = new BaseItemWithCharge("itemBaseItemWithCharge", 0, 1000);
+		GameRegistry.registerItem(ModItems.itemBaseItemWithCharge, "itemBaseItemWithCharge");
+	}
+
+	public static void registerTEs(){
+
+	}
+
+	public static void registerMisc(){
+
+
+
+	}
+
+	public static void registerHandlers(){
+		MinecraftForge.EVENT_BUS.register(new DEBUG_ScreenOverlay());	
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/debug/DEBUG_ITEM_ShapeSpawner.java b/src/Java/gtPlusPlus/core/util/debug/DEBUG_ITEM_ShapeSpawner.java
new file mode 100644
index 0000000000..bfaa7404e1
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/DEBUG_ITEM_ShapeSpawner.java
@@ -0,0 +1,55 @@
+package gtPlusPlus.core.util.debug;
+
+import static net.minecraftforge.event.entity.player.PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.item.base.BaseItemGeneric;
+import gtPlusPlus.core.util.Utils;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class DEBUG_ITEM_ShapeSpawner extends BaseItemGeneric{
+
+	public DEBUG_ITEM_ShapeSpawner(String s, CreativeTabs c, int stackSize, int maxDmg) {
+		super(s, c, stackSize, maxDmg);
+		s = "itemDebugShapeSpawner";
+		c = AddToCreativeTab.tabMisc;
+		stackSize = 1;
+		maxDmg = 500;
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player){
+		
+		if (!world.isRemote){
+			Utils.LOG_INFO("Constructing the shape for the "+"VACUUM FREEZER");
+			Thread thread = new Thread(new DEBUG_TimerThread(world, player));
+			   thread.start();
+		}
+		return stack;		
+	}
+	
+	
+	
+	@SuppressWarnings("static-method")
+	@SubscribeEvent
+	public void playerInteractEventHandler(PlayerInteractEvent event)
+	{
+		if (event.isCanceled() || event.world.isRemote || event.action != RIGHT_CLICK_BLOCK) return;
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {
+		list.add(EnumChatFormatting.GOLD+"For Testing Gregtech Shapes!");
+		super.addInformation(stack, aPlayer, list, bool);
+	}	
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/debug/DEBUG_MULTIBLOCK_ShapeSpawner.java b/src/Java/gtPlusPlus/core/util/debug/DEBUG_MULTIBLOCK_ShapeSpawner.java
new file mode 100644
index 0000000000..78acb27cfb
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/DEBUG_MULTIBLOCK_ShapeSpawner.java
@@ -0,0 +1,805 @@
+package gtPlusPlus.core.util.debug;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.GT_Mod;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.gui.GT_Container_MultiMachine;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBus;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+
+import java.util.ArrayList;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+public abstract class DEBUG_MULTIBLOCK_ShapeSpawner extends MetaTileEntity {
+
+    public static boolean disableMaintenance;
+    public boolean mMachine = false, mWrench = false, mScrewdriver = false, mSoftHammer = false, mHardHammer = false, mSolderingTool = false, mCrowbar = false, mRunningOnLoad = false;
+    public int mPollution = 0, mProgresstime = 0, mMaxProgresstime = 0, mEUt = 0, mEfficiencyIncrease = 0, mUpdate = 0, mStartUpCheck = 100, mRuntime = 0, mEfficiency = 0;
+    public ItemStack[] mOutputItems = null;
+    public FluidStack[] mOutputFluids = null;
+    public ArrayList<GT_MetaTileEntity_Hatch_Input> mInputHatches = new ArrayList<GT_MetaTileEntity_Hatch_Input>();
+    public ArrayList<GT_MetaTileEntity_Hatch_Output> mOutputHatches = new ArrayList<GT_MetaTileEntity_Hatch_Output>();
+    public ArrayList<GT_MetaTileEntity_Hatch_InputBus> mInputBusses = new ArrayList<GT_MetaTileEntity_Hatch_InputBus>();
+    public ArrayList<GT_MetaTileEntity_Hatch_OutputBus> mOutputBusses = new ArrayList<GT_MetaTileEntity_Hatch_OutputBus>();
+    public ArrayList<GT_MetaTileEntity_Hatch_Dynamo> mDynamoHatches = new ArrayList<GT_MetaTileEntity_Hatch_Dynamo>();
+    public ArrayList<GT_MetaTileEntity_Hatch_Muffler> mMufflerHatches = new ArrayList<GT_MetaTileEntity_Hatch_Muffler>();
+    public ArrayList<GT_MetaTileEntity_Hatch_Energy> mEnergyHatches = new ArrayList<GT_MetaTileEntity_Hatch_Energy>();
+    public ArrayList<GT_MetaTileEntity_Hatch_Maintenance> mMaintenanceHatches = new ArrayList<GT_MetaTileEntity_Hatch_Maintenance>();
+
+    public DEBUG_MULTIBLOCK_ShapeSpawner(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional, 2);
+        this.disableMaintenance = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MultiBlockMachines.disableMaintenance", false);
+    }
+
+    public DEBUG_MULTIBLOCK_ShapeSpawner(String aName) {
+        super(aName, 2);
+        this.disableMaintenance = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MultiBlockMachines.disableMaintenance", false);
+    }
+
+    public static boolean isValidMetaTileEntity(MetaTileEntity aMetaTileEntity) {
+        return aMetaTileEntity.getBaseMetaTileEntity() != null && aMetaTileEntity.getBaseMetaTileEntity().getMetaTileEntity() == aMetaTileEntity && !aMetaTileEntity.getBaseMetaTileEntity().isDead();
+    }
+
+    @Override
+    public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) {
+        return aSide != getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex > 0;
+    }
+
+    @Override
+    public int getProgresstime() {
+        return mProgresstime;
+    }
+
+    @Override
+    public int maxProgresstime() {
+        return mMaxProgresstime;
+    }
+
+    @Override
+    public int increaseProgress(int aProgress) {
+        return aProgress;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("mEUt", mEUt);
+        aNBT.setInteger("mProgresstime", mProgresstime);
+        aNBT.setInteger("mMaxProgresstime", mMaxProgresstime);
+        aNBT.setInteger("mEfficiencyIncrease", mEfficiencyIncrease);
+        aNBT.setInteger("mEfficiency", mEfficiency);
+        aNBT.setInteger("mPollution", mPollution);
+        aNBT.setInteger("mRuntime", mRuntime);
+
+        if (mOutputItems != null) for (int i = 0; i < mOutputItems.length; i++)
+            if (mOutputItems[i] != null) {
+                NBTTagCompound tNBT = new NBTTagCompound();
+                mOutputItems[i].writeToNBT(tNBT);
+                aNBT.setTag("mOutputItem" + i, tNBT);
+            }
+        if (mOutputFluids != null) for (int i = 0; i < mOutputFluids.length; i++)
+            if (mOutputFluids[i] != null) {
+                NBTTagCompound tNBT = new NBTTagCompound();
+                mOutputFluids[i].writeToNBT(tNBT);
+                aNBT.setTag("mOutputFluids" + i, tNBT);
+            }
+
+        aNBT.setBoolean("mWrench", mWrench);
+        aNBT.setBoolean("mScrewdriver", mScrewdriver);
+        aNBT.setBoolean("mSoftHammer", mSoftHammer);
+        aNBT.setBoolean("mHardHammer", mHardHammer);
+        aNBT.setBoolean("mSolderingTool", mSolderingTool);
+        aNBT.setBoolean("mCrowbar", mCrowbar);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        mEUt = aNBT.getInteger("mEUt");
+        mProgresstime = aNBT.getInteger("mProgresstime");
+        mMaxProgresstime = aNBT.getInteger("mMaxProgresstime");
+        if (mMaxProgresstime > 0) mRunningOnLoad = true;
+        mEfficiencyIncrease = aNBT.getInteger("mEfficiencyIncrease");
+        mEfficiency = aNBT.getInteger("mEfficiency");
+        mPollution = aNBT.getInteger("mPollution");
+        mRuntime = aNBT.getInteger("mRuntime");
+        mOutputItems = new ItemStack[getAmountOfOutputs()];
+        for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = GT_Utility.loadItem(aNBT, "mOutputItem" + i);
+        mOutputFluids = new FluidStack[getAmountOfOutputs()];
+        for (int i = 0; i < mOutputFluids.length; i++)
+            mOutputFluids[i] = GT_Utility.loadFluid(aNBT, "mOutputFluids" + i);
+        mWrench = aNBT.getBoolean("mWrench");
+        mScrewdriver = aNBT.getBoolean("mScrewdriver");
+        mSoftHammer = aNBT.getBoolean("mSoftHammer");
+        mHardHammer = aNBT.getBoolean("mHardHammer");
+        mSolderingTool = aNBT.getBoolean("mSolderingTool");
+        mCrowbar = aNBT.getBoolean("mCrowbar");
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) return true;
+        aBaseMetaTileEntity.openGUI(aPlayer);
+        return true;
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_Container_MultiMachine(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "MultiblockDisplay.png");
+    }
+
+    @Override
+    public byte getTileEntityBaseType() {
+        return 2;
+    }
+
+    @Override
+    public void onMachineBlockUpdate() {
+        mUpdate = 50;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (mEfficiency < 0) mEfficiency = 0;
+            if (--mUpdate == 0 || --mStartUpCheck == 0) {
+                mInputHatches.clear();
+                mInputBusses.clear();
+                mOutputHatches.clear();
+                mOutputBusses.clear();
+                mDynamoHatches.clear();
+                mEnergyHatches.clear();
+                mMufflerHatches.clear();
+                mMaintenanceHatches.clear();
+                mMachine = checkMachine(aBaseMetaTileEntity, mInventory[1]);
+            }
+            if (mStartUpCheck < 0) {
+                if (mMachine) {
+                    for (GT_MetaTileEntity_Hatch_Maintenance tHatch : mMaintenanceHatches) {
+                        if (isValidMetaTileEntity(tHatch)) {
+                            if (!this.disableMaintenance) {
+                                if (tHatch.mWrench) mWrench = true;
+                                if (tHatch.mScrewdriver) mScrewdriver = true;
+                                if (tHatch.mSoftHammer) mSoftHammer = true;
+                                if (tHatch.mHardHammer) mHardHammer = true;
+                                if (tHatch.mSolderingTool) mSolderingTool = true;
+                                if (tHatch.mCrowbar) mCrowbar = true;
+                            } else {
+                                mWrench = true;
+                                mScrewdriver = true;
+                                mSoftHammer = true;
+                                mHardHammer = true;
+                                mSolderingTool = true;
+                                mCrowbar = true;
+                            }
+
+                            tHatch.mWrench = false;
+                            tHatch.mScrewdriver = false;
+                            tHatch.mSoftHammer = false;
+                            tHatch.mHardHammer = false;
+                            tHatch.mSolderingTool = false;
+                            tHatch.mCrowbar = false;
+                        }
+                    }
+                    if (getRepairStatus() > 0) {
+                        if (mMaxProgresstime > 0 && doRandomMaintenanceDamage()) {
+                            if (onRunningTick(mInventory[1])) {
+                                if (!polluteEnvironment(getPollutionPerTick(mInventory[1]))) {
+                                    stopMachine();
+                                }
+                                if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) {
+                                    if (mOutputItems != null) for (ItemStack tStack : mOutputItems)
+                                        if (tStack != null) {
+                                            try {
+                                                GT_Mod.instance.achievements.issueAchivementHatch(aBaseMetaTileEntity.getWorld().getPlayerEntityByName(aBaseMetaTileEntity.getOwnerName()), tStack);
+                                            } catch (Exception e) {
+                                            }
+                                            addOutput(tStack);
+                                        }
+                                    if (mOutputFluids != null && mOutputFluids.length == 1) {
+                                        for (FluidStack tStack : mOutputFluids)
+                                            if (tStack != null) {
+                                                addOutput(tStack);
+                                            }
+                                    } else if (mOutputFluids != null && mOutputFluids.length > 1) {
+                                        addFluidOutputs(mOutputFluids);
+                                    }
+                                    mEfficiency = Math.max(0, Math.min(mEfficiency + mEfficiencyIncrease, getMaxEfficiency(mInventory[1]) - ((getIdealStatus() - getRepairStatus()) * 1000)));
+                                    mOutputItems = null;
+                                    mProgresstime = 0;
+                                    mMaxProgresstime = 0;
+                                    mEfficiencyIncrease = 0;
+                                    if (aBaseMetaTileEntity.isAllowedToWork()) checkRecipe(mInventory[1]);
+                                    if (mOutputFluids != null && mOutputFluids.length > 0) {
+                                        if (mOutputFluids.length > 1) {
+                                            GT_Mod.instance.achievements.issueAchievement(aBaseMetaTileEntity.getWorld().getPlayerEntityByName(aBaseMetaTileEntity.getOwnerName()), "oilplant");
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            if (aTick % 100 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified()) {
+
+                                if (aBaseMetaTileEntity.isAllowedToWork()) {
+                                    checkRecipe(mInventory[1]);
+                                }
+                                if (mMaxProgresstime <= 0) mEfficiency = Math.max(0, mEfficiency - 1000);
+                            }
+                        }
+                    } else {
+                        stopMachine();
+                    }
+                } else {
+                    stopMachine();
+                }
+            }
+            aBaseMetaTileEntity.setErrorDisplayID((aBaseMetaTileEntity.getErrorDisplayID() & ~127) | (mWrench ? 0 : 1) | (mScrewdriver ? 0 : 2) | (mSoftHammer ? 0 : 4) | (mHardHammer ? 0 : 8) | (mSolderingTool ? 0 : 16) | (mCrowbar ? 0 : 32) | (mMachine ? 0 : 64));
+            aBaseMetaTileEntity.setActive(mMaxProgresstime > 0);
+        }
+    }
+
+    public boolean polluteEnvironment(int aPollutionLevel) {
+        mPollution += aPollutionLevel;
+        for (GT_MetaTileEntity_Hatch_Muffler tHatch : mMufflerHatches) {
+            if (isValidMetaTileEntity(tHatch)) {
+                if (mPollution >= 10000) {
+                    if (tHatch.polluteEnvironment()) {
+                        mPollution -= 10000;
+                    }
+                } else {
+                    break;
+                }
+            }
+        }
+        return mPollution < 10000;
+    }
+
+    /**
+     * Called every tick the Machine runs
+     */
+    public boolean onRunningTick(ItemStack aStack) {
+        if (mEUt > 0) {
+            addEnergyOutput(((long) mEUt * mEfficiency) / 10000);
+            return true;
+        }
+        if (mEUt < 0) {
+            if (!drainEnergyInput(((long) -mEUt * 10000) / Math.max(1000, mEfficiency))) {
+                stopMachine();
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Checks if this is a Correct Machine Part for this kind of Machine (Turbine Rotor for example)
+     */
+    public abstract boolean isCorrectMachinePart(ItemStack aStack);
+
+    /**
+     * Checks the Recipe
+     */
+    public abstract boolean checkRecipe(ItemStack aStack);
+
+    /**
+     * Checks the Machine. You have to assign the MetaTileEntities for the Hatches here.
+     */
+    public abstract boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack);
+
+    /**
+     * Gets the maximum Efficiency that spare Part can get (0 - 10000)
+     */
+    public abstract int getMaxEfficiency(ItemStack aStack);
+
+    /**
+     * Gets the pollution this Device outputs to a Muffler per tick (10000 = one Pullution Block)
+     */
+    public abstract int getPollutionPerTick(ItemStack aStack);
+
+    /**
+     * Gets the damage to the ItemStack, usually 0 or 1.
+     */
+    public abstract int getDamageToComponent(ItemStack aStack);
+
+    /**
+     * Gets the Amount of possibly outputted Items for loading the Output Stack Array from NBT.
+     * This should be the largest Amount that can ever happen legitimately.
+     */
+    public abstract int getAmountOfOutputs();
+
+    /**
+     * If it explodes when the Component has to be replaced.
+     */
+    public abstract boolean explodesOnComponentBreak(ItemStack aStack);
+
+    public void stopMachine() {
+        mOutputItems = null;
+        mEUt = 0;
+        mEfficiency = 0;
+        mProgresstime = 0;
+        mMaxProgresstime = 0;
+        mEfficiencyIncrease = 0;
+        getBaseMetaTileEntity().disableWorking();
+    }
+
+    public int getRepairStatus() {
+        return (mWrench ? 1 : 0) + (mScrewdriver ? 1 : 0) + (mSoftHammer ? 1 : 0) + (mHardHammer ? 1 : 0) + (mSolderingTool ? 1 : 0) + (mCrowbar ? 1 : 0);
+    }
+
+    public int getIdealStatus() {
+        return 6;
+    }
+
+    public boolean doRandomMaintenanceDamage() {
+        if (!isCorrectMachinePart(mInventory[1]) || getRepairStatus() == 0) {
+            stopMachine();
+            return false;
+        }
+        if (mRuntime++ > 1000) {
+            mRuntime = 0;
+            if (getBaseMetaTileEntity().getRandomNumber(6000) == 0) {
+                switch (getBaseMetaTileEntity().getRandomNumber(6)) {
+                    case 0:
+                        mWrench = false;
+                        break;
+                    case 1:
+                        mScrewdriver = false;
+                        break;
+                    case 2:
+                        mSoftHammer = false;
+                        break;
+                    case 3:
+                        mHardHammer = false;
+                        break;
+                    case 4:
+                        mSolderingTool = false;
+                        break;
+                    case 5:
+                        mCrowbar = false;
+                        break;
+                }
+            }
+            if (mInventory[1] != null && getBaseMetaTileEntity().getRandomNumber(2) == 0 && !mInventory[1].getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.")) {
+                if (mInventory[1].getItem() instanceof GT_MetaGenerated_Tool_01) {
+                    NBTTagCompound tNBT = mInventory[1].getTagCompound();
+                    if (tNBT != null) {
+                        NBTTagCompound tNBT2 = tNBT.getCompoundTag("GT.CraftingComponents");
+                        if (!tNBT.getBoolean("mDis")) {
+                            tNBT2 = new NBTTagCompound();
+                            Materials tMaterial = GT_MetaGenerated_Tool.getPrimaryMaterial(mInventory[1]);
+                            ItemStack tTurbine = GT_OreDictUnificator.get(OrePrefixes.turbineBlade, tMaterial, 1);
+                            int i = mInventory[1].getItemDamage();
+                            if (i == 170) {
+                                ItemStack tStack = GT_Utility.copyAmount(1, tTurbine);
+                                tNBT2.setTag("Ingredient.0", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.1", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.2", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.3", tStack.writeToNBT(new NBTTagCompound()));
+                                tStack = GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Magnalium, 1);
+                                tNBT2.setTag("Ingredient.4", tStack.writeToNBT(new NBTTagCompound()));
+                            } else if (i == 172) {
+                                ItemStack tStack = GT_Utility.copyAmount(1, tTurbine);
+                                tNBT2.setTag("Ingredient.0", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.1", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.2", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.3", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.5", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.6", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.7", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.8", tStack.writeToNBT(new NBTTagCompound()));
+                                tStack = GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Titanium, 1);
+                                tNBT2.setTag("Ingredient.4", tStack.writeToNBT(new NBTTagCompound()));
+                            } else if (i == 174) {
+                                ItemStack tStack = GT_Utility.copyAmount(2, tTurbine);
+                                tNBT2.setTag("Ingredient.0", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.1", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.2", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.3", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.5", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.6", tStack.writeToNBT(new NBTTagCompound()));
+                                tStack = GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.TungstenSteel, 1);
+                                tNBT2.setTag("Ingredient.4", tStack.writeToNBT(new NBTTagCompound()));
+                            } else if (i == 176) {
+                                ItemStack tStack = GT_Utility.copyAmount(2, tTurbine);
+                                tNBT2.setTag("Ingredient.0", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.1", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.2", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.3", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.5", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.6", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.7", tStack.writeToNBT(new NBTTagCompound()));
+                                tNBT2.setTag("Ingredient.8", tStack.writeToNBT(new NBTTagCompound()));
+                                tStack = GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Americium, 1);
+                                tNBT2.setTag("Ingredient.4", tStack.writeToNBT(new NBTTagCompound()));
+                            }
+                            tNBT.setTag("GT.CraftingComponents", tNBT2);
+                            tNBT.setBoolean("mDis", true);
+                            mInventory[1].setTagCompound(tNBT);
+
+                        }
+                    }
+
+                    ((GT_MetaGenerated_Tool) mInventory[1].getItem()).doDamage(mInventory[1], (long) Math.min(mEUt / 5, Math.pow(mEUt, 0.7)));
+                    if (mInventory[1].stackSize == 0) mInventory[1] = null;
+                }
+            }
+        }
+        return true;
+    }
+
+    public void explodeMultiblock() {
+        mInventory[1] = null;
+        for (MetaTileEntity tTileEntity : mInputBusses) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mOutputBusses) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mInputHatches) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mOutputHatches) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mDynamoHatches) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mMufflerHatches) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mEnergyHatches) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        for (MetaTileEntity tTileEntity : mMaintenanceHatches) tTileEntity.getBaseMetaTileEntity().doExplosion(V[8]);
+        getBaseMetaTileEntity().doExplosion(V[8]);
+    }
+
+    public boolean addEnergyOutput(long aEU) {
+        if (aEU <= 0) return true;
+        for (GT_MetaTileEntity_Hatch_Dynamo tHatch : mDynamoHatches) {
+            if (isValidMetaTileEntity(tHatch)) {
+                if (tHatch.getBaseMetaTileEntity().increaseStoredEnergyUnits(aEU, false)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public long getMaxInputVoltage() {
+        long rVoltage = 0;
+        for (GT_MetaTileEntity_Hatch_Energy tHatch : mEnergyHatches)
+            if (isValidMetaTileEntity(tHatch)) rVoltage += tHatch.getBaseMetaTileEntity().getInputVoltage();
+        return rVoltage;
+    }
+
+    public boolean drainEnergyInput(long aEU) {
+        if (aEU <= 0) return true;
+        for (GT_MetaTileEntity_Hatch_Energy tHatch : mEnergyHatches)
+            if (isValidMetaTileEntity(tHatch)) {
+                if (tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(aEU, false)) return true;
+            }
+        return false;
+    }
+
+    public boolean addOutput(FluidStack aLiquid) {
+        if (aLiquid == null) return false;
+        FluidStack tLiquid = aLiquid.copy();
+        for (GT_MetaTileEntity_Hatch_Output tHatch : mOutputHatches) {
+            if (isValidMetaTileEntity(tHatch) && GT_ModHandler.isSteam(aLiquid) ? tHatch.outputsSteam() : tHatch.outputsLiquids()) {
+                int tAmount = tHatch.fill(tLiquid, false);
+                if (tAmount >= tLiquid.amount) {
+                    return tHatch.fill(tLiquid, true) >= tLiquid.amount;
+                } else if (tAmount > 0) {
+                    tLiquid.amount = tLiquid.amount - tHatch.fill(tLiquid, true);
+                }
+            }
+        }
+        return false;
+    }
+
+    private void addFluidOutputs(FluidStack[] mOutputFluids2) {
+        for (int i = 0; i < mOutputFluids2.length; i++) {
+            if (mOutputHatches.size() > i && mOutputHatches.get(i) != null && mOutputFluids2[i] != null && isValidMetaTileEntity(mOutputHatches.get(i))) {
+                mOutputHatches.get(i).fill(mOutputFluids2[i], true);
+            }
+        }
+
+    }
+
+    public boolean depleteInput(FluidStack aLiquid) {
+        if (aLiquid == null) return false;
+        for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
+            tHatch.mRecipeMap = getRecipeMap();
+            if (isValidMetaTileEntity(tHatch)) {
+                FluidStack tLiquid = tHatch.getFluid();
+                if (tLiquid != null && tLiquid.isFluidEqual(aLiquid)) {
+                    tLiquid = tHatch.drain(aLiquid.amount, false);
+                    if (tLiquid != null && tLiquid.amount >= aLiquid.amount) {
+                        tLiquid = tHatch.drain(aLiquid.amount, true);
+                        return tLiquid != null && tLiquid.amount >= aLiquid.amount;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean addOutput(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack)) return false;
+        aStack = GT_Utility.copy(aStack);
+//		FluidStack aLiquid = GT_Utility.getFluidForFilledItem(aStack, true);
+//		if (aLiquid == null) {
+        for (GT_MetaTileEntity_Hatch_OutputBus tHatch : mOutputBusses) {
+            if (isValidMetaTileEntity(tHatch)) {
+                for (int i = tHatch.getSizeInventory() - 1; i >= 0; i--) {
+                    if (tHatch.getBaseMetaTileEntity().addStackToSlot(i, aStack)) return true;
+                }
+            }
+        }
+        for (GT_MetaTileEntity_Hatch_Output tHatch : mOutputHatches) {
+            if (isValidMetaTileEntity(tHatch) && tHatch.outputsItems()) {
+                if (tHatch.getBaseMetaTileEntity().addStackToSlot(1, aStack)) return true;
+            }
+        }
+//		}else {
+//			for (GT_MetaTileEntity_Hatch_Output tHatch : mOutputHatches) {
+//				if (isValidMetaTileEntity(tHatch) && GT_ModHandler.isSteam(aLiquid)?tHatch.outputsSteam():tHatch.outputsLiquids()) {
+//					int tAmount = tHatch.fill(aLiquid, false);
+//					if (tAmount >= aLiquid.amount) {
+//						return tHatch.fill(aLiquid, true) >= aLiquid.amount;
+//					}
+//				}
+//			}
+//		}
+        return false;
+    }
+
+    public boolean depleteInput(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack)) return false;
+        FluidStack aLiquid = GT_Utility.getFluidForFilledItem(aStack, true);
+        if (aLiquid != null) return depleteInput(aLiquid);
+        for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
+            tHatch.mRecipeMap = getRecipeMap();
+            if (isValidMetaTileEntity(tHatch)) {
+                if (GT_Utility.areStacksEqual(aStack, tHatch.getBaseMetaTileEntity().getStackInSlot(0))) {
+                    if (tHatch.getBaseMetaTileEntity().getStackInSlot(0).stackSize >= aStack.stackSize) {
+                        tHatch.getBaseMetaTileEntity().decrStackSize(0, aStack.stackSize);
+                        return true;
+                    }
+                }
+            }
+        }
+        for (GT_MetaTileEntity_Hatch_InputBus tHatch : mInputBusses) {
+            tHatch.mRecipeMap = getRecipeMap();
+            if (isValidMetaTileEntity(tHatch)) {
+                for (int i = tHatch.getBaseMetaTileEntity().getSizeInventory() - 1; i >= 0; i--) {
+                    if (GT_Utility.areStacksEqual(aStack, tHatch.getBaseMetaTileEntity().getStackInSlot(i))) {
+                        if (tHatch.getBaseMetaTileEntity().getStackInSlot(0).stackSize >= aStack.stackSize) {
+                            tHatch.getBaseMetaTileEntity().decrStackSize(0, aStack.stackSize);
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    public ArrayList<ItemStack> getStoredOutputs() {
+        ArrayList<ItemStack> rList = new ArrayList<ItemStack>();
+        for (GT_MetaTileEntity_Hatch_Output tHatch : mOutputHatches) {
+            if (isValidMetaTileEntity(tHatch)) {
+                rList.add(tHatch.getBaseMetaTileEntity().getStackInSlot(1));
+            }
+        }
+        for (GT_MetaTileEntity_Hatch_OutputBus tHatch : mOutputBusses) {
+            if (isValidMetaTileEntity(tHatch)) {
+                for (int i = tHatch.getBaseMetaTileEntity().getSizeInventory() - 1; i >= 0; i--) {
+                    rList.add(tHatch.getBaseMetaTileEntity().getStackInSlot(i));
+                }
+            }
+        }
+        return rList;
+    }
+
+    public ArrayList<FluidStack> getStoredFluids() {
+        ArrayList<FluidStack> rList = new ArrayList<FluidStack>();
+        for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
+            tHatch.mRecipeMap = getRecipeMap();
+            if (isValidMetaTileEntity(tHatch) && tHatch.getFillableStack() != null) {
+                rList.add(tHatch.getFillableStack());
+            }
+        }
+        return rList;
+    }
+
+    public ArrayList<ItemStack> getStoredInputs() {
+        ArrayList<ItemStack> rList = new ArrayList<ItemStack>();
+        for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches) {
+            tHatch.mRecipeMap = getRecipeMap();
+            if (isValidMetaTileEntity(tHatch) && tHatch.getBaseMetaTileEntity().getStackInSlot(0) != null) {
+                rList.add(tHatch.getBaseMetaTileEntity().getStackInSlot(0));
+            }
+        }
+        for (GT_MetaTileEntity_Hatch_InputBus tHatch : mInputBusses) {
+            tHatch.mRecipeMap = getRecipeMap();
+            if (isValidMetaTileEntity(tHatch)) {
+                for (int i = tHatch.getBaseMetaTileEntity().getSizeInventory() - 1; i >= 0; i--) {
+                    if (tHatch.getBaseMetaTileEntity().getStackInSlot(i) != null)
+                        rList.add(tHatch.getBaseMetaTileEntity().getStackInSlot(i));
+                }
+            }
+        }
+        return rList;
+    }
+
+    public GT_Recipe_Map getRecipeMap() {
+        return null;
+    }
+
+    public void updateSlots() {
+        for (GT_MetaTileEntity_Hatch_Input tHatch : mInputHatches)
+            if (isValidMetaTileEntity(tHatch)) tHatch.updateSlots();
+        for (GT_MetaTileEntity_Hatch_InputBus tHatch : mInputBusses)
+            if (isValidMetaTileEntity(tHatch)) tHatch.updateSlots();
+    }
+
+    public boolean addToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch)
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input)
+            return mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus)
+            return mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output)
+            return mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_OutputBus)
+            return mOutputBusses.add((GT_MetaTileEntity_Hatch_OutputBus) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy)
+            return mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Dynamo)
+            return mDynamoHatches.add((GT_MetaTileEntity_Hatch_Dynamo) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance)
+            return mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity);
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Muffler)
+            return mMufflerHatches.add((GT_MetaTileEntity_Hatch_Muffler) aMetaTileEntity);
+        return false;
+    }
+
+    public boolean addMaintenanceToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            return mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    public boolean addEnergyInputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        }
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            return mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    public boolean addDynamoToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Dynamo) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            return mDynamoHatches.add((GT_MetaTileEntity_Hatch_Dynamo) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    public boolean addMufflerToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Muffler) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            return mMufflerHatches.add((GT_MetaTileEntity_Hatch_Muffler) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    public boolean addInputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            ((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity).mRecipeMap = getRecipeMap();
+            return mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            ((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity).mRecipeMap = getRecipeMap();
+            return mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    public boolean addOutputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (aMetaTileEntity == null) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            return mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity);
+        }
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_OutputBus) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).mMachineBlock = (byte) aBaseCasingIndex;
+            return mOutputBusses.add((GT_MetaTileEntity_Hatch_OutputBus) aMetaTileEntity);
+        }
+        return false;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[]{"Progress:", (mProgresstime / 20) + "secs", (mMaxProgresstime / 20) + "secs", "Efficiency:", (mEfficiency / 100.0F) + "%", "Problems:", "" + (getIdealStatus() - getRepairStatus())};
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return false;
+    }
+}
diff --git a/src/Java/gtPlusPlus/core/util/debug/DEBUG_ScreenOverlay.java b/src/Java/gtPlusPlus/core/util/debug/DEBUG_ScreenOverlay.java
new file mode 100644
index 0000000000..9153543eaf
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/DEBUG_ScreenOverlay.java
@@ -0,0 +1,45 @@
+package gtPlusPlus.core.util.debug;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.Gui;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.item.Item;
+import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class DEBUG_ScreenOverlay extends Gui {
+
+	int width, height;
+	Minecraft mc = Minecraft.getMinecraft();
+
+	@SubscribeEvent
+	public void eventHandler(RenderGameOverlayEvent.Text event)
+	{
+
+		//if (mc.thePlayer.getHeldItem().equals(ModItems.itemStaballoyPickaxe)){
+		ScaledResolution res = new ScaledResolution(this.mc, this.mc.displayWidth, this.mc.displayHeight);
+		FontRenderer fontRender = mc.fontRenderer;
+		this.width = res.getScaledWidth();
+		this.height = res.getScaledHeight();
+		Minecraft.getMinecraft().entityRenderer.setupOverlayRendering();
+		String str = "Words";
+		Item heldItem = null;
+
+		try{heldItem = mc.thePlayer.getHeldItem().getItem();
+
+		if (heldItem != null){
+			/*if (heldItem instanceof StaballoyPickaxe){
+
+				int dmg =((StaballoyPickaxe) heldItem).getDamage(((StaballoyPickaxe) heldItem).thisPickaxe);
+
+				((StaballoyPickaxe) heldItem).checkFacing(((StaballoyPickaxe) heldItem).localWorld);
+				str = "DAMAGE: "+ dmg +" | FACING: "+((StaballoyPickaxe) heldItem).FACING+" | FACING_HORIZONTAL: "+((StaballoyPickaxe) heldItem).FACING_HORIZONTAL+" | LOOKING DIRECTION: "+((StaballoyPickaxe) heldItem).lookingDirection;
+
+				drawString(fontRender, str, (this.width - fontRender.getStringWidth(str)) / 2, this.height / 10, 0xFFAA00);
+			}*/
+		}
+		}catch(NullPointerException e){}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/util/debug/DEBUG_TimerThread.java b/src/Java/gtPlusPlus/core/util/debug/DEBUG_TimerThread.java
new file mode 100644
index 0000000000..1eb69eb11b
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/DEBUG_TimerThread.java
@@ -0,0 +1,64 @@
+package gtPlusPlus.core.util.debug;
+
+import gtPlusPlus.core.util.Utils;
+
+import java.util.concurrent.TimeUnit;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class DEBUG_TimerThread implements Runnable {
+
+	private World world;
+	private EntityPlayer player;
+	
+
+	public DEBUG_TimerThread(World WORLD, EntityPlayer PLAYER) {
+		world = WORLD;
+		player = PLAYER;
+	}
+
+	@Override
+	public void run(){
+		int xDir = ForgeDirection.getOrientation(player.getPlayerCoordinates().posX).offsetX;
+		int zDir = ForgeDirection.getOrientation(player.getPlayerCoordinates().posZ).offsetZ;
+		
+		int stepX = Minecraft.getMinecraft().objectMouseOver.blockX;
+		int stepY = Minecraft.getMinecraft().objectMouseOver.blockY;
+		int stepZ = Minecraft.getMinecraft().objectMouseOver.blockZ;
+		Utils.LOG_INFO("Clicked on a Block @ "+"[X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]"+" with xDir:"+xDir+" zDir:"+zDir);
+		world.setBlock(stepX, stepY, stepZ, Blocks.bedrock,0,3);
+		Utils.LOG_INFO("Makng it Bedrock for future investment.");
+		//for (int i = -1; i <= 1; i++) {
+		//stepX = stepX+i;
+			for (int i = stepX-1; i <= stepX+1; i++){
+				for (int j = stepZ-1; j <= stepZ+1; j++){
+					for (int h = stepY-1; h <= stepY+1; h++){	
+						
+						xDir = ForgeDirection.getOrientation(player.getPlayerCoordinates().posX).offsetX;
+						zDir = ForgeDirection.getOrientation(player.getPlayerCoordinates().posZ).offsetZ;
+						
+			//for (int j = -1; j <= 1; j++) {
+				//stepZ = stepZ+j;
+				//for (int h = -1; h <= 1; h++) {
+					//stepY = stepY+h;
+					Utils.LOG_INFO("Placing Block @ "+"[X:"+i+"][Y:"+h+"][Z:"+j+"]"+" with xDir:"+xDir+" zDir:"+zDir);		
+					if ((h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))) {	
+					world.setBlock(i, h, j, Blocks.stone,0,3);
+					}
+					else {
+						Utils.LOG_INFO("Not even sure what this is for, but I got here.");
+					}
+					try {
+						TimeUnit.MILLISECONDS.sleep(500);
+					} catch (InterruptedException e1) {
+						e1.printStackTrace();
+					}				
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/util/debug/UtilityGL11Debug.java b/src/Java/gtPlusPlus/core/util/debug/UtilityGL11Debug.java
new file mode 100644
index 0000000000..59c652d73b
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/debug/UtilityGL11Debug.java
@@ -0,0 +1,343 @@
+package gtPlusPlus.core.util.debug;
+
+import java.nio.ByteBuffer;
+
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+
+
+/**
+ * User: The Grey Ghost
+ * Date: 9/02/14
+ */
+public class UtilityGL11Debug
+{
+  public class GLproperty
+  {
+    public GLproperty(int init_gLconstant, String init_name, String init_description, String init_category, String init_fetchCommand) {
+      gLconstant = init_gLconstant;
+      name = init_name;
+      description = init_description;
+      category = init_category;
+      fetchCommand = init_fetchCommand;
+    }
+
+    public int gLconstant;
+    public String name;
+    public String description;
+    public String category;
+    public String fetchCommand;
+  }
+
+  public static UtilityGL11Debug instance = new UtilityGL11Debug();
+
+  public GLproperty[] propertyList = 
+
+  {
+      new GLproperty(GL11.GL_CURRENT_COLOR, "GL_CURRENT_COLOR", "Current color", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_INDEX, "GL_CURRENT_INDEX", "Current color index", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_TEXTURE_COORDS, "GL_CURRENT_TEXTURE_COORDS", "Current texture coordinates", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_NORMAL, "GL_CURRENT_NORMAL", "Current normal", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_RASTER_POSITION, "GL_CURRENT_RASTER_POSITION", "Current raster position", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_RASTER_DISTANCE, "GL_CURRENT_RASTER_DISTANCE", "Current raster distance", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_RASTER_COLOR, "GL_CURRENT_RASTER_COLOR", "Color associated with raster position", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_RASTER_INDEX, "GL_CURRENT_RASTER_INDEX", "Color index associated with raster position", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_RASTER_TEXTURE_COORDS, "GL_CURRENT_RASTER_TEXTURE_COORDS", "Texture coordinates associated with raster position", "current", "glGetFloatv()"),
+      new GLproperty(GL11.GL_CURRENT_RASTER_POSITION_VALID, "GL_CURRENT_RASTER_POSITION_VALID", "Raster position valid bit", "current", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_EDGE_FLAG, "GL_EDGE_FLAG", "Edge flag", "current", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_VERTEX_ARRAY, "GL_VERTEX_ARRAY", "Vertex array enable", "vertex-array", "glIsEnabled()"),
+      new GLproperty(GL11.GL_VERTEX_ARRAY_SIZE, "GL_VERTEX_ARRAY_SIZE", "Coordinates per vertex", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_VERTEX_ARRAY_TYPE, "GL_VERTEX_ARRAY_TYPE", "Type of vertex coordinates", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_VERTEX_ARRAY_STRIDE, "GL_VERTEX_ARRAY_STRIDE", "Stride between vertices", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_VERTEX_ARRAY_POINTER, "GL_VERTEX_ARRAY_POINTER", "Pointer to the vertex array", "vertex-array", "glGetPointerv()"),
+      new GLproperty(GL11.GL_NORMAL_ARRAY, "GL_NORMAL_ARRAY", "Normal array enable", "vertex-array", "glIsEnabled()"),
+      new GLproperty(GL11.GL_NORMAL_ARRAY_TYPE, "GL_NORMAL_ARRAY_TYPE", "Type of normal coordinates", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_NORMAL_ARRAY_STRIDE, "GL_NORMAL_ARRAY_STRIDE", "Stride between normals", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_NORMAL_ARRAY_POINTER, "GL_NORMAL_ARRAY_POINTER", "Pointer to the normal array", "vertex-array", "glGetPointerv()"),
+      new GLproperty(GL11.GL_COLOR_ARRAY, "GL_COLOR_ARRAY", "RGBA color array enable", "vertex-array", "glIsEnabled()"),
+      new GLproperty(GL11.GL_COLOR_ARRAY_SIZE, "GL_COLOR_ARRAY_SIZE", "Colors per vertex", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_COLOR_ARRAY_TYPE, "GL_COLOR_ARRAY_TYPE", "Type of color components", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_COLOR_ARRAY_STRIDE, "GL_COLOR_ARRAY_STRIDE", "Stride between colors", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_COLOR_ARRAY_POINTER, "GL_COLOR_ARRAY_POINTER", "Pointer to the color array", "vertex-array", "glGetPointerv()"),
+      new GLproperty(GL11.GL_INDEX_ARRAY, "GL_INDEX_ARRAY", "Color-index array enable", "vertex-array", "glIsEnabled()"),
+      new GLproperty(GL11.GL_INDEX_ARRAY_TYPE, "GL_INDEX_ARRAY_TYPE", "Type of color indices", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_INDEX_ARRAY_STRIDE, "GL_INDEX_ARRAY_STRIDE", "Stride between color indices", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_INDEX_ARRAY_POINTER, "GL_INDEX_ARRAY_POINTER", "Pointer to the index array", "vertex-array", "glGetPointerv()"),
+      new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY, "GL_TEXTURE_COORD_ARRAY", "Texture coordinate array enable", "vertex-array", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_SIZE, "GL_TEXTURE_COORD_ARRAY_SIZE", "Texture coordinates per element", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_TYPE, "GL_TEXTURE_COORD_ARRAY_TYPE", "Type of texture coordinates", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_STRIDE, "GL_TEXTURE_COORD_ARRAY_STRIDE", "Stride between texture coordinates", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_TEXTURE_COORD_ARRAY_POINTER, "GL_TEXTURE_COORD_ARRAY_POINTER", "Pointer to the texture coordinate array", "vertex-array", "glGetPointerv()"),
+      new GLproperty(GL11.GL_EDGE_FLAG_ARRAY, "GL_EDGE_FLAG_ARRAY", "Edge flag array enable", "vertex-array", "glIsEnabled()"),
+      new GLproperty(GL11.GL_EDGE_FLAG_ARRAY_STRIDE, "GL_EDGE_FLAG_ARRAY_STRIDE", "Stride between edge flags", "vertex-array", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_EDGE_FLAG_ARRAY_POINTER, "GL_EDGE_FLAG_ARRAY_POINTER", "Pointer to the edge flag array", "vertex-array", "glGetPointerv()"),
+      new GLproperty(GL11.GL_MODELVIEW_MATRIX, "GL_MODELVIEW_MATRIX", "Modelview matrix stack", "matrix", "glGetFloatv()"),
+      new GLproperty(GL11.GL_PROJECTION_MATRIX, "GL_PROJECTION_MATRIX", "Projection matrix stack", "matrix", "glGetFloatv()"),
+      new GLproperty(GL11.GL_TEXTURE_MATRIX, "GL_TEXTURE_MATRIX", "Texture matrix stack", "matrix", "glGetFloatv()"),
+      new GLproperty(GL11.GL_VIEWPORT, "GL_VIEWPORT", "Viewport origin and extent", "viewport", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_DEPTH_RANGE, "GL_DEPTH_RANGE", "Depth range near and far", "viewport", "glGetFloatv()"),
+      new GLproperty(GL11.GL_MODELVIEW_STACK_DEPTH, "GL_MODELVIEW_STACK_DEPTH", "Modelview matrix stack pointer", "matrix", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_PROJECTION_STACK_DEPTH, "GL_PROJECTION_STACK_DEPTH", "Projection matrix stack pointer", "matrix", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_TEXTURE_STACK_DEPTH, "GL_TEXTURE_STACK_DEPTH", "Texture matrix stack pointer", "matrix", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MATRIX_MODE, "GL_MATRIX_MODE", "Current matrix mode", "transform", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_NORMALIZE, "GL_NORMALIZE", "Current normal normalization on/off", "transform/ enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_FOG_COLOR, "GL_FOG_COLOR", "Fog color", "fog", "glGetFloatv()"),
+      new GLproperty(GL11.GL_FOG_INDEX, "GL_FOG_INDEX", "Fog index", "fog", "glGetFloatv()"),
+      new GLproperty(GL11.GL_FOG_DENSITY, "GL_FOG_DENSITY", "Exponential fog density", "fog", "glGetFloatv()"),
+      new GLproperty(GL11.GL_FOG_START, "GL_FOG_START", "Linear fog start", "fog", "glGetFloatv()"),
+      new GLproperty(GL11.GL_FOG_END, "GL_FOG_END", "Linear fog end", "fog", "glGetFloatv()"),
+      new GLproperty(GL11.GL_FOG_MODE, "GL_FOG_MODE", "Fog mode", "fog", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_FOG, "GL_FOG", "True if fog enabled", "fog/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_SHADE_MODEL, "GL_SHADE_MODEL", "glShadeModel() setting", "lighting", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LIGHTING, "GL_LIGHTING", "True if lighting is enabled", "lighting/e nable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_COLOR_MATERIAL, "GL_COLOR_MATERIAL", "True if color tracking is enabled", "lighting", "glIsEnabled()"),
+      new GLproperty(GL11.GL_COLOR_MATERIAL_PARAMETER, "GL_COLOR_MATERIAL_PARAMETER", "Material properties tracking current color", "lighting", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_COLOR_MATERIAL_FACE, "GL_COLOR_MATERIAL_FACE", "Face(s) affected by color tracking", "lighting", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_AMBIENT, "GL_AMBIENT", "Ambient material color", "lighting", "glGetMaterialfv()"),
+      new GLproperty(GL11.GL_DIFFUSE, "GL_DIFFUSE", "Diffuse material color", "lighting", "glGetMaterialfv()"),
+      new GLproperty(GL11.GL_SPECULAR, "GL_SPECULAR", "Specular material color", "lighting", "glGetMaterialfv()"),
+      new GLproperty(GL11.GL_EMISSION, "GL_EMISSION", "Emissive material color", "lighting", "glGetMaterialfv()"),
+      new GLproperty(GL11.GL_SHININESS, "GL_SHININESS", "Specular exponent of material", "lighting", "glGetMaterialfv()"),
+      new GLproperty(GL11.GL_LIGHT_MODEL_AMBIENT, "GL_LIGHT_MODEL_AMBIENT", "Ambient scene color", "lighting", "glGetFloatv()"),
+      new GLproperty(GL11.GL_LIGHT_MODEL_LOCAL_VIEWER, "GL_LIGHT_MODEL_LOCAL_VIEWER", "Viewer is local", "lighting", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_LIGHT_MODEL_TWO_SIDE, "GL_LIGHT_MODEL_TWO_SIDE", "Use two-sided lighting", "lighting", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_AMBIENT, "GL_AMBIENT", "Ambient intensity of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_DIFFUSE, "GL_DIFFUSE", "Diffuse intensity of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_SPECULAR, "GL_SPECULAR", "Specular intensity of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_POSITION, "GL_POSITION", "Position of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_CONSTANT_ATTENUATION, "GL_CONSTANT_ATTENUATION", "Constant attenuation factor", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_LINEAR_ATTENUATION, "GL_LINEAR_ATTENUATION", "Linear attenuation factor", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_QUADRATIC_ATTENUATION, "GL_QUADRATIC_ATTENUATION", "Quadratic attenuation factor", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_SPOT_DIRECTION, "GL_SPOT_DIRECTION", "Spotlight direction of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_SPOT_EXPONENT, "GL_SPOT_EXPONENT", "Spotlight exponent of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_SPOT_CUTOFF, "GL_SPOT_CUTOFF", "Spotlight angle of light i", "lighting", "glGetLightfv()"),
+      new GLproperty(GL11.GL_LIGHT0, "GL_LIGHT0", "True if light 0 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT1, "GL_LIGHT1", "True if light 1 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT2, "GL_LIGHT2", "True if light 2 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT3, "GL_LIGHT3", "True if light 3 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT4, "GL_LIGHT4", "True if light 4 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT5, "GL_LIGHT5", "True if light 5 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT6, "GL_LIGHT6", "True if light 6 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LIGHT7, "GL_LIGHT7", "True if light 7 enabled", "lighting/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_COLOR_INDEXES, "GL_COLOR_INDEXES", "ca, cd, and cs for color-index lighting", "lighting/e nable", "glGetMaterialfv()"),
+      new GLproperty(GL11.GL_POINT_SIZE, "GL_POINT_SIZE", "Point size", "point", "glGetFloatv()"),
+      new GLproperty(GL11.GL_POINT_SMOOTH, "GL_POINT_SMOOTH", "Point antialiasing on", "point/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LINE_WIDTH, "GL_LINE_WIDTH", "Line width", "line", "glGetFloatv()"),
+      new GLproperty(GL11.GL_LINE_SMOOTH, "GL_LINE_SMOOTH", "Line antialiasing on", "line/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LINE_STIPPLE_PATTERN, "GL_LINE_STIPPLE_PATTERN", "Line stipple", "line", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LINE_STIPPLE_REPEAT, "GL_LINE_STIPPLE_REPEAT", "Line stipple repeat", "line", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LINE_STIPPLE, "GL_LINE_STIPPLE", "Line stipple enable", "line/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_CULL_FACE, "GL_CULL_FACE", "Polygon culling enabled", "polygon/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_CULL_FACE_MODE, "GL_CULL_FACE_MODE", "Cull front-/back-facing polygons", "polygon", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_FRONT_FACE, "GL_FRONT_FACE", "Polygon front-face CW/CCW indicator", "polygon", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_POLYGON_SMOOTH, "GL_POLYGON_SMOOTH", "Polygon antialiasing on", "polygon/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_POLYGON_MODE, "GL_POLYGON_MODE", "Polygon rasterization mode (front and back)", "polygon", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_POLYGON_OFFSET_FACTOR, "GL_POLYGON_OFFSET_FACTOR", "Polygon offset factor", "polygon", "glGetFloatv()"),
+      new GLproperty(GL11.GL_POLYGON_OFFSET_POINT, "GL_POLYGON_OFFSET_POINT", "Polygon offset enable for GL_POINT mode rasterization", "polygon/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_POLYGON_OFFSET_LINE, "GL_POLYGON_OFFSET_LINE", "Polygon offset enable for GL_LINE mode rasterization", "polygon/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_POLYGON_OFFSET_FILL, "GL_POLYGON_OFFSET_FILL", "Polygon offset enable for GL_FILL mode rasterization", "polygon/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_POLYGON_STIPPLE, "GL_POLYGON_STIPPLE", "Polygon stipple enable", "polygon/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_1D, "GL_TEXTURE_1D", "True if 1-D texturing enabled ", "texture/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_2D, "GL_TEXTURE_2D", "True if 2-D texturing enabled ", "texture/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_BINDING_1D, "GL_TEXTURE_BINDING_1D", "Texture object bound to GL_TEXTURE_1D", "texture", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_TEXTURE_BINDING_2D, "GL_TEXTURE_BINDING_2D", "Texture object bound to GL_TEXTURE_2D", "texture", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_TEXTURE, "GL_TEXTURE", "x-D texture image at level of detail i", "UNUSED", "glGetTexImage()"),
+      new GLproperty(GL11.GL_TEXTURE_WIDTH, "GL_TEXTURE_WIDTH", "x-D texture image i's width", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_HEIGHT, "GL_TEXTURE_HEIGHT", "x-D texture image i's height", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_BORDER, "GL_TEXTURE_BORDER", "x-D texture image i's border width", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_RED_SIZE, "GL_TEXTURE_RED_SIZE", "x-D texture image i's red resolution", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_GREEN_SIZE, "GL_TEXTURE_GREEN_SIZE", "x-D texture image i's green resolution", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_BLUE_SIZE, "GL_TEXTURE_BLUE_SIZE", "x-D texture image i's blue resolution", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_ALPHA_SIZE, "GL_TEXTURE_ALPHA_SIZE", "x-D texture image i's alpha resolution", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_LUMINANCE_SIZE, "GL_TEXTURE_LUMINANCE_SIZE", "x-D texture image i's luminance resolution", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_INTENSITY_SIZE, "GL_TEXTURE_INTENSITY_SIZE", "x-D texture image i's intensity resolution", "UNUSED", "glGetTexLevelParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_BORDER_COLOR, "GL_TEXTURE_BORDER_COLOR", "Texture border color", "texture", "glGetTexParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_MIN_FILTER, "GL_TEXTURE_MIN_FILTER", "Texture minification function", "texture", "glGetTexParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_MAG_FILTER, "GL_TEXTURE_MAG_FILTER", "Texture magnification function", "texture", "glGetTexParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_WRAP_S, "GL_TEXTURE_WRAP_S", "Texture wrap mode (x is S or T)", "texture", "glGetTexParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_WRAP_T, "GL_TEXTURE_WRAP_T", "Texture wrap mode (x is S or T)", "texture", "glGetTexParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_PRIORITY, "GL_TEXTURE_PRIORITY", "Texture object priority", "texture", "glGetTexParameter*()"),
+      new GLproperty(GL11.GL_TEXTURE_ENV_MODE, "GL_TEXTURE_ENV_MODE", "Texture application function", "texture", "glGetTexEnviv()"),
+      new GLproperty(GL11.GL_TEXTURE_ENV_COLOR, "GL_TEXTURE_ENV_COLOR", "Texture environment color", "texture", "glGetTexEnvfv()"),
+      new GLproperty(GL11.GL_TEXTURE_GEN_S, "GL_TEXTURE_GEN_S", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_GEN_T, "GL_TEXTURE_GEN_T", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_GEN_R, "GL_TEXTURE_GEN_R", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_TEXTURE_GEN_Q, "GL_TEXTURE_GEN_Q", "Texgen enabled (x is S, T, R, or Q)", "texture/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_EYE_PLANE, "GL_EYE_PLANE", "Texgen plane equation coefficients", "texture", "glGetTexGenfv()"),
+      new GLproperty(GL11.GL_OBJECT_PLANE, "GL_OBJECT_PLANE", "Texgen object linear coefficients", "texture", "glGetTexGenfv()"),
+      new GLproperty(GL11.GL_TEXTURE_GEN_MODE, "GL_TEXTURE_GEN_MODE", "Function used for texgen", "texture", "glGetTexGeniv()"),
+      new GLproperty(GL11.GL_SCISSOR_TEST, "GL_SCISSOR_TEST", "Scissoring enabled", "scissor/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_SCISSOR_BOX, "GL_SCISSOR_BOX", "Scissor box", "scissor", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ALPHA_TEST, "GL_ALPHA_TEST", "Alpha test enabled", "color-buffer/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_ALPHA_TEST_FUNC, "GL_ALPHA_TEST_FUNC", "Alpha test function", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ALPHA_TEST_REF, "GL_ALPHA_TEST_REF", "Alpha test reference value", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_TEST, "GL_STENCIL_TEST", "Stenciling enabled", "stencil-buffer/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_STENCIL_FUNC, "GL_STENCIL_FUNC", "Stencil function", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_VALUE_MASK, "GL_STENCIL_VALUE_MASK", "Stencil mask", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_REF, "GL_STENCIL_REF", "Stencil reference value", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_FAIL, "GL_STENCIL_FAIL", "Stencil fail action", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_PASS_DEPTH_FAIL, "GL_STENCIL_PASS_DEPTH_FAIL", "Stencil depth buffer fail action", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_PASS_DEPTH_PASS, "GL_STENCIL_PASS_DEPTH_PASS", "Stencil depth buffer pass action", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_DEPTH_TEST, "GL_DEPTH_TEST", "Depth buffer enabled", "depth-buffer/ena ble", "glIsEnabled()"),
+      new GLproperty(GL11.GL_DEPTH_FUNC, "GL_DEPTH_FUNC", "Depth buffer test function", "depth-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_BLEND, "GL_BLEND", "Blending enabled", "color-buffer/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_BLEND_SRC, "GL_BLEND_SRC", "Blending source function", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_BLEND_DST, "GL_BLEND_DST", "Blending destination function", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_DITHER, "GL_DITHER", "Dithering enabled", "color-buffer/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_INDEX_LOGIC_OP, "GL_INDEX_LOGIC_OP", "Color index logical operation enabled", "color-buffer/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_COLOR_LOGIC_OP, "GL_COLOR_LOGIC_OP", "RGBA color logical operation enabled", "color-buffer/enable", "glIsEnabled()"),
+      new GLproperty(GL11.GL_LOGIC_OP_MODE, "GL_LOGIC_OP_MODE", "Logical operation function", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_DRAW_BUFFER, "GL_DRAW_BUFFER", "Buffers selected for drawing", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_INDEX_WRITEMASK, "GL_INDEX_WRITEMASK", "Color-index writemask", "color-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_COLOR_WRITEMASK, "GL_COLOR_WRITEMASK", "Color write enables; R, G, B, or A", "color-buffer", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_DEPTH_WRITEMASK, "GL_DEPTH_WRITEMASK", "Depth buffer enabled for writing", "depth-buffer", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_STENCIL_WRITEMASK, "GL_STENCIL_WRITEMASK", "Stencil-buffer writemask", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_COLOR_CLEAR_VALUE, "GL_COLOR_CLEAR_VALUE", "Color-buffer clear value (RGBA mode)", "color-buffer", "glGetFloatv()"),
+      new GLproperty(GL11.GL_INDEX_CLEAR_VALUE, "GL_INDEX_CLEAR_VALUE", "Color-buffer clear value (color-index mode)", "color-buffer", "glGetFloatv()"),
+      new GLproperty(GL11.GL_DEPTH_CLEAR_VALUE, "GL_DEPTH_CLEAR_VALUE", "Depth-buffer clear value", "depth-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_CLEAR_VALUE, "GL_STENCIL_CLEAR_VALUE", "Stencil-buffer clear value", "stencil-buffer", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ACCUM_CLEAR_VALUE, "GL_ACCUM_CLEAR_VALUE", "Accumulation-buffer clear value", "accum-buffer", "glGetFloatv()"),
+      new GLproperty(GL11.GL_UNPACK_SWAP_BYTES, "GL_UNPACK_SWAP_BYTES", "Value of GL_UNPACK_SWAP_BYTES", "pixel-store", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_UNPACK_LSB_FIRST, "GL_UNPACK_LSB_FIRST", "Value of GL_UNPACK_LSB_FIRST", "pixel-store", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_UNPACK_ROW_LENGTH, "GL_UNPACK_ROW_LENGTH", "Value of GL_UNPACK_ROW_LENGTH", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_UNPACK_SKIP_ROWS, "GL_UNPACK_SKIP_ROWS", "Value of GL_UNPACK_SKIP_ROWS", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_UNPACK_SKIP_PIXELS, "GL_UNPACK_SKIP_PIXELS", "Value of GL_UNPACK_SKIP_PIXELS", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_UNPACK_ALIGNMENT, "GL_UNPACK_ALIGNMENT", "Value of GL_UNPACK_ALIGNMENT", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_PACK_SWAP_BYTES, "GL_PACK_SWAP_BYTES", "Value of GL_PACK_SWAP_BYTES", "pixel-store", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_PACK_LSB_FIRST, "GL_PACK_LSB_FIRST", "Value of GL_PACK_LSB_FIRST", "pixel-store", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_PACK_ROW_LENGTH, "GL_PACK_ROW_LENGTH", "Value of GL_PACK_ROW_LENGTH", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_PACK_SKIP_ROWS, "GL_PACK_SKIP_ROWS", "Value of GL_PACK_SKIP_ROWS", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_PACK_SKIP_PIXELS, "GL_PACK_SKIP_PIXELS", "Value of GL_PACK_SKIP_PIXELS", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_PACK_ALIGNMENT, "GL_PACK_ALIGNMENT", "Value of GL_PACK_ALIGNMENT", "pixel-store", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAP_COLOR, "GL_MAP_COLOR", "True if colors are mapped", "pixel", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_MAP_STENCIL, "GL_MAP_STENCIL", "True if stencil values are mapped", "pixel", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_INDEX_SHIFT, "GL_INDEX_SHIFT", "Value of GL_INDEX_SHIFT", "pixel", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_INDEX_OFFSET, "GL_INDEX_OFFSET", "Value of GL_INDEX_OFFSET", "pixel", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ZOOM_X, "GL_ZOOM_X", "x zoom factor", "pixel", "glGetFloatv()"),
+      new GLproperty(GL11.GL_ZOOM_Y, "GL_ZOOM_Y", "y zoom factor", "pixel", "glGetFloatv()"),
+      new GLproperty(GL11.GL_READ_BUFFER, "GL_READ_BUFFER", "Read source buffer", "pixel", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ORDER, "GL_ORDER", "1D map order", "capability", "glGetMapiv()"),
+      new GLproperty(GL11.GL_ORDER, "GL_ORDER", "2D map orders", "capability", "glGetMapiv()"),
+      new GLproperty(GL11.GL_COEFF, "GL_COEFF", "1D control points", "capability", "glGetMapfv()"),
+      new GLproperty(GL11.GL_COEFF, "GL_COEFF", "2D control points", "capability", "glGetMapfv()"),
+      new GLproperty(GL11.GL_DOMAIN, "GL_DOMAIN", "1D domain endpoints", "capability", "glGetMapfv()"),
+      new GLproperty(GL11.GL_DOMAIN, "GL_DOMAIN", "2D domain endpoints", "capability", "glGetMapfv()"),
+      new GLproperty(GL11.GL_MAP1_GRID_DOMAIN, "GL_MAP1_GRID_DOMAIN", "1D grid endpoints", "eval", "glGetFloatv()"),
+      new GLproperty(GL11.GL_MAP2_GRID_DOMAIN, "GL_MAP2_GRID_DOMAIN", "2D grid endpoints", "eval", "glGetFloatv()"),
+      new GLproperty(GL11.GL_MAP1_GRID_SEGMENTS, "GL_MAP1_GRID_SEGMENTS", "1D grid divisions", "eval", "glGetFloatv()"),
+      new GLproperty(GL11.GL_MAP2_GRID_SEGMENTS, "GL_MAP2_GRID_SEGMENTS", "2D grid divisions", "eval", "glGetFloatv()"),
+      new GLproperty(GL11.GL_AUTO_NORMAL, "GL_AUTO_NORMAL", "True if automatic normal generation enabled", "eval", "glIsEnabled()"),
+      new GLproperty(GL11.GL_PERSPECTIVE_CORRECTION_HINT, "GL_PERSPECTIVE_CORRECTION_HINT", "Perspective correction hint", "hint", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_POINT_SMOOTH_HINT, "GL_POINT_SMOOTH_HINT", "Point smooth hint", "hint", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LINE_SMOOTH_HINT, "GL_LINE_SMOOTH_HINT", "Line smooth hint", "hint", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_POLYGON_SMOOTH_HINT, "GL_POLYGON_SMOOTH_HINT", "Polygon smooth hint", "hint", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_FOG_HINT, "GL_FOG_HINT", "Fog hint", "hint", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_LIGHTS, "GL_MAX_LIGHTS", "Maximum number of lights", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES", "Maximum number of user clipping planes", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH", "Maximum modelview-matrix stack depth", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH", "Maximum projection-matrix stack depth", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH", "Maximum depth of texture matrix stack", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_SUBPIXEL_BITS, "GL_SUBPIXEL_BITS", "Number of bits of subpixel precision in x and y", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE", "See discussion in Texture Proxy in Chapter 9", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE", "Maximum size of a glPixelMap() translation table", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH", "Maximum selection-name stack depth", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING", "Maximum display-list call nesting", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER", "Maximum evaluator polynomial order", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS", "Maximum viewport dimensions", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH", "Maximum depth of the attribute stack", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", "Maximum depth of the client attribute stack", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_AUX_BUFFERS, "GL_AUX_BUFFERS", "Number of auxiliary buffers", "capability", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_RGBA_MODE, "GL_RGBA_MODE", "True if color buffers store RGBA", "capability", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_INDEX_MODE, "GL_INDEX_MODE", "True if color buffers store indices", "capability", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_DOUBLEBUFFER, "GL_DOUBLEBUFFER", "True if front and back buffers exist", "capability", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_STEREO, "GL_STEREO", "True if left and right buffers exist", "capability", "glGetBooleanv()"),
+      new GLproperty(GL11.GL_POINT_SIZE_RANGE, "GL_POINT_SIZE_RANGE", "Range (low to high) of antialiased point sizes", "capability", "glGetFloatv()"),
+      new GLproperty(GL11.GL_POINT_SIZE_GRANULARITY, "GL_POINT_SIZE_GRANULARITY", "Antialiased point-size granularity", "capability", "glGetFloatv()"),
+      new GLproperty(GL11.GL_LINE_WIDTH_RANGE, "GL_LINE_WIDTH_RANGE", "Range (low to high) of antialiased line widths", "capability", "glGetFloatv()"),
+      new GLproperty(GL11.GL_LINE_WIDTH_GRANULARITY, "GL_LINE_WIDTH_GRANULARITY", "Antialiased line-width granularity", "capability", "glGetFloatv()"),
+      new GLproperty(GL11.GL_RED_BITS, "GL_RED_BITS", "Number of bits per red component in color buffers", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_GREEN_BITS, "GL_GREEN_BITS", "Number of bits per green component in color buffers", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_BLUE_BITS, "GL_BLUE_BITS", "Number of bits per blue component in color buffers", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ALPHA_BITS, "GL_ALPHA_BITS", "Number of bits per alpha component in color buffers", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_INDEX_BITS, "GL_INDEX_BITS", "Number of bits per index in color buffers", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_DEPTH_BITS, "GL_DEPTH_BITS", "Number of depth-buffer bitplanes", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_STENCIL_BITS, "GL_STENCIL_BITS", "Number of stencil bitplanes", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ACCUM_RED_BITS, "GL_ACCUM_RED_BITS", "Number of bits per red component in the accumulation buffer", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ACCUM_GREEN_BITS, "GL_ACCUM_GREEN_BITS", "Number of bits per green component in the accumulation buffer", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ACCUM_BLUE_BITS, "GL_ACCUM_BLUE_BITS", "Number of bits per blue component in the accumulation buffer", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ACCUM_ALPHA_BITS, "GL_ACCUM_ALPHA_BITS", "Number of bits per alpha component in the accumulation buffer", "capability", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LIST_BASE, "GL_LIST_BASE", "Setting of glListBase()", "list", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LIST_INDEX, "GL_LIST_INDEX", "Number of display list under construction; 0 if none", "current", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_LIST_MODE, "GL_LIST_MODE", "Mode of display list under construction; undefined if none", "current", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_ATTRIB_STACK_DEPTH, "GL_ATTRIB_STACK_DEPTH", "Attribute stack pointer", "current", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH, "GL_CLIENT_ATTRIB_STACK_DEPTH", "Client attribute stack pointer", "current", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_NAME_STACK_DEPTH, "GL_NAME_STACK_DEPTH", "Name stack depth", "current", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_RENDER_MODE, "GL_RENDER_MODE", "glRenderMode() setting", "current", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_SELECTION_BUFFER_POINTER, "GL_SELECTION_BUFFER_POINTER", "Pointer to selection buffer", "select", "glGetPointerv()"),
+      new GLproperty(GL11.GL_SELECTION_BUFFER_SIZE, "GL_SELECTION_BUFFER_SIZE", "Size of selection buffer", "select", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_FEEDBACK_BUFFER_POINTER, "GL_FEEDBACK_BUFFER_POINTER", "Pointer to feedback buffer", "feedback", "glGetPointerv()"),
+      new GLproperty(GL11.GL_FEEDBACK_BUFFER_SIZE, "GL_FEEDBACK_BUFFER_SIZE", "Size of feedback buffer", "feedback", "glGetIntegerv()"),
+      new GLproperty(GL11.GL_FEEDBACK_BUFFER_TYPE, "GL_FEEDBACK_BUFFER_TYPE", "Type of feedback buffer", "feedback", "glGetIntegerv()"),
+  };
+
+  public static void dumpOpenGLstate()
+  {
+  }
+
+  public static void dumpAllIsEnabled() //Call This
+  {
+    for (int i = 0; i < instance.propertyList.length; ++i) 
+
+    {
+      if (instance.propertyList[i].fetchCommand == "glIsEnabled()") 
+
+      {
+        System.out.print(instance.propertyList[i].name + ":");
+        System.out.print(GL11.glIsEnabled(instance.propertyList[i].gLconstant));
+        System.out.println(" (" + instance.propertyList[i].description + ")");
+      }
+    }
+  }
+
+  public static void dumpAllType(String type) 
+
+  {
+    for (int i = 0; i < instance.propertyList.length; ++i) 
+
+    {
+      if (instance.propertyList[i].category.equals(type)) 
+
+      {
+        System.out.print(instance.propertyList[i].name + ":");
+        System.out.println(getPropertyAsString(i));
+        System.out.println(" (" + instance.propertyList[i].description + ")");
+      }
+    }
+  }
+
+  private static String getPropertyAsString(int propertyListIndex)
+  {
+    int gLconstant = instance.propertyList[propertyListIndex].gLconstant;
+    if (instance.propertyList[propertyListIndex].fetchCommand.equals("glIsEnabled()"))     {
+      return "" + GL11.glIsEnabled(gLconstant);
+    }
+
+    if (instance.propertyList[propertyListIndex].fetchCommand == "glGetBooleanv()") 
+
+    {
+      ByteBuffer params = BufferUtils.createByteBuffer(16);
+
+      GL11.glGetBoolean(gLconstant, params);
+      String out = "";
+      for (int i = 0; i < params.capacity(); ++i) 
+
+      {
+        out += (i == 0 ? "" : ", ") + params.get(i);
+      }
+      return out;
+    }
+
+    return "";
+  }
+}
+
diff --git a/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java b/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java
new file mode 100644
index 0000000000..53873c6e4e
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java
@@ -0,0 +1,44 @@
+package gtPlusPlus.core.util.fluid;
+
+import gtPlusPlus.core.util.Utils;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+public class FluidUtils {
+
+	public static FluidStack getFluidStack(String fluidName, int amount){
+		Utils.LOG_WARNING("Trying to get a fluid stack of "+fluidName);
+		try {
+			return FluidRegistry.getFluidStack(fluidName, amount).copy();
+		} 
+		catch (Throwable e){
+			return null;
+		}
+
+	}
+	
+	public static FluidStack[] getFluidStackArray(String fluidName, int amount){
+		Utils.LOG_WARNING("Trying to get a fluid stack of "+fluidName);
+		try {
+			FluidStack[] singleFluid = {FluidRegistry.getFluidStack(fluidName, amount)};
+			return singleFluid;
+		} 
+		catch (Throwable e){
+			return null;
+		}
+
+	}
+	
+	public static FluidStack[] getFluidStackArray(FluidStack fluidName, int amount){
+		Utils.LOG_WARNING("Trying to get a fluid stack of "+fluidName);
+		try {
+			FluidStack[] singleFluid = {FluidRegistry.getFluidStack(fluidName.getLocalizedName(), amount)};
+			return singleFluid;
+		} 
+		catch (Throwable e){
+			return null;
+		}
+
+	}
+	
+}
diff --git a/src/Java/gtPlusPlus/core/util/gregtech/recipehandlers/GregtechRecipe.java b/src/Java/gtPlusPlus/core/util/gregtech/recipehandlers/GregtechRecipe.java
new file mode 100644
index 0000000000..d1857ffefc
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/gregtech/recipehandlers/GregtechRecipe.java
@@ -0,0 +1,87 @@
+package gtPlusPlus.core.util.gregtech.recipehandlers;
+
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+
+import java.lang.reflect.Method;
+
+import net.minecraft.item.ItemStack;
+
+public final class GregtechRecipe {
+
+	public LibraryProxy ourProxy;
+	public GregtechRecipe(){
+		Utils.LOG_INFO("Initializing a recipe handler for different versions of Gregtech 5.");
+		try {
+			if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){
+			this.ourProxy = new LibProxy1();
+			Utils.LOG_INFO("Selecting GT 5.7/5.8 Recipe Set");
+			}
+			if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){
+			this.ourProxy = new LibProxy2();
+			Utils.LOG_INFO("Selecting GT 5.9 Recipe Set");
+			}
+		} catch (NoSuchMethodException e) {
+			this.ourProxy = null;
+		}
+	}
+
+	public boolean addSmeltingAndAlloySmeltingRecipe(ItemStack aInput, ItemStack aOutput) {
+		Utils.LOG_INFO("Adding a GT Furnace/Alloy Smelter Recipe");
+		return ourProxy.addSmeltingAndAlloySmeltingRecipe(aInput, aOutput);
+	}
+
+}
+
+abstract class LibraryProxy { // can also be interface unless you want to have common code here
+	abstract public boolean addSmeltingAndAlloySmeltingRecipe(ItemStack aInput, ItemStack aOutput);
+}
+
+class LibProxy1 extends LibraryProxy {
+	final Method m1;
+
+	public LibProxy1() throws NoSuchMethodException {
+		m1 = GT_ModHandler.class.getDeclaredMethod("addSmeltingAndAlloySmeltingRecipe", ItemStack.class, ItemStack.class);
+	}
+
+	@Override
+	public boolean addSmeltingAndAlloySmeltingRecipe(ItemStack aInput, ItemStack aOutput) {
+		try {
+			Utils.LOG_INFO("Trying with Gt 5.7/5.8 Method.");
+			return (boolean) m1.invoke(null, aInput, aOutput);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+}
+
+class LibProxy2 extends LibraryProxy {
+	final Method m2;
+
+	public LibProxy2() throws NoSuchMethodException {
+		m2 = GT_ModHandler.class.getDeclaredMethod("addSmeltingAndAlloySmeltingRecipe", ItemStack.class, ItemStack.class, boolean.class);
+	}
+
+	@Override
+	public boolean addSmeltingAndAlloySmeltingRecipe(ItemStack aInput, ItemStack aOutput) {
+		try {
+			Utils.LOG_INFO("Trying with Gt 5.9 Method.");
+			return (boolean) m2.invoke(null, aInput, aOutput, true);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+}
+
+/*class Lib { // v1
+	public static void addRecipe(ItemStack aInput, ItemStack aOutput) {
+		System.out.println("shit totally happened v1");
+	}
+}
+
+class Lib2 { // v2
+    public static void addRecipe(ItemStack aInput, ItemStack aOutput, boolean hidden) {
+        System.out.println("shit totally happened v2");
+    }
+}*/
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/util/item/UtilsItems.java b/src/Java/gtPlusPlus/core/util/item/UtilsItems.java
new file mode 100644
index 0000000000..623fc1707c
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/item/UtilsItems.java
@@ -0,0 +1,361 @@
+package gtPlusPlus.core.util.item;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.util.GT_OreDictUnificator;
+import gtPlusPlus.core.block.base.BlockBaseModular;
+import gtPlusPlus.core.block.base.BasicBlock.BlockTypes;
+import gtPlusPlus.core.item.ModItems;
+import gtPlusPlus.core.item.base.BasicSpawnEgg;
+import gtPlusPlus.core.item.base.bolts.BaseItemBolt;
+import gtPlusPlus.core.item.base.dusts.BaseItemDust;
+import gtPlusPlus.core.item.base.gears.BaseItemGear;
+import gtPlusPlus.core.item.base.ingots.BaseItemIngot;
+import gtPlusPlus.core.item.base.ingots.BaseItemIngotHot;
+import gtPlusPlus.core.item.base.plates.BaseItemPlate;
+import gtPlusPlus.core.item.base.rings.BaseItemRing;
+import gtPlusPlus.core.item.base.rods.BaseItemRod;
+import gtPlusPlus.core.item.base.rods.BaseItemRodLong;
+import gtPlusPlus.core.item.base.rotors.BaseItemRotor;
+import gtPlusPlus.core.item.base.screws.BaseItemScrew;
+import gtPlusPlus.core.item.tool.staballoy.MultiPickaxeBase;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.lib.MaterialInfo;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.wrapper.var;
+
+import java.util.ArrayList;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.Item;
+import net.minecraft.item.Item.ToolMaterial;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class UtilsItems {
+
+	public static ItemStack getItemStackOfItem(Boolean modToCheck, String mod_itemname_meta){
+		if (modToCheck){
+			try{
+				Item em = null;
+
+				Item em1 = getItem(mod_itemname_meta);
+				Utils.LOG_WARNING("Found: "+em1.toString());
+				if (em1 != null){
+					em = em1;
+				}						
+				if (em != null ){
+					ItemStack returnStack = new ItemStack(em,1);				
+					return returnStack;
+				}
+				Utils.LOG_WARNING(mod_itemname_meta+" not found.");
+				return null;
+			} catch (NullPointerException e) {
+				Utils.LOG_ERROR(mod_itemname_meta+" not found. [NULL]");
+				return null;
+			}
+		}
+		return null;
+	}
+
+	public static ItemStack getSimpleStack(Item x){
+		return getSimpleStack(x, 1);
+	}
+
+	public static ItemStack getSimpleStack(Item x, int i){
+		try {
+			ItemStack r = new ItemStack(x, i);
+			return r;
+		} catch(Throwable e){
+			return null;
+		}
+	}
+	
+	public static ItemStack getSimpleStack(ItemStack x, int i){
+		try {
+			ItemStack r = x.copy();
+			r.stackSize = i;
+			return r;
+		} catch(Throwable e){
+			return null;
+		}
+	}
+
+
+	public static void getItemForOreDict(String FQRN, String oreDictName, String itemName, int meta){
+		try {
+			Item em = null;			
+			Item em1 = getItem(FQRN);
+			Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta);
+			if (em1 != null){
+				em = em1;
+			}
+			if (em != null){
+
+				ItemStack metaStack = new ItemStack(em,1,meta);
+				GT_OreDictUnificator.registerOre(oreDictName, metaStack);
+
+				/*ItemStack itemStackWithMeta = new ItemStack(em,1,meta);
+				GT_OreDictUnificator.registerOre(oreDictName, new ItemStack(itemStackWithMeta.getItem()));*/
+			}
+		} catch (NullPointerException e) {
+			Utils.LOG_ERROR(itemName+" not found. [NULL]");
+		}
+	}
+	
+	public static void addItemToOreDictionary(ItemStack stack, String oreDictName){
+		try {
+				GT_OreDictUnificator.registerOre(oreDictName, stack);
+		} catch (NullPointerException e) {
+			Utils.LOG_ERROR(stack.getDisplayName()+" not registered. [NULL]");
+		}
+	}
+
+	@SuppressWarnings("unused")
+	public static ItemStack getItemStackWithMeta(boolean MOD, String FQRN, String itemName, int meta, int itemstackSize){
+		if (MOD){
+			try {
+				Item em = null;			
+				Item em1 = getItem(FQRN);
+				Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta);
+				if (em1 != null){
+					if (null == em){
+						em = em1;
+					}
+					if (em != null){
+						ItemStack metaStack = new ItemStack(em,itemstackSize,meta);
+						return metaStack;
+					}
+				}
+				return null;
+			} catch (NullPointerException e) {
+				Utils.LOG_ERROR(itemName+" not found. [NULL]");
+				return null;
+			}	
+		}
+		return null;
+	}
+
+	@SuppressWarnings("unused")
+	public static ItemStack simpleMetaStack(String FQRN, int meta, int itemstackSize){		
+		try {
+			Item em = null;			
+			Item em1 = getItem(FQRN);
+			Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta);
+			if (em1 != null){
+				if (null == em){
+					em = em1;
+				}
+				if (em != null){
+					ItemStack metaStack = new ItemStack(em,itemstackSize,meta);
+					return metaStack;
+				}
+			}
+			return null;
+		} catch (NullPointerException e) {
+			Utils.LOG_ERROR(FQRN+" not found. [NULL]");
+			return null;
+		}		
+	}
+
+	@SuppressWarnings("unused")
+	public static ItemStack simpleMetaStack(Item item, int meta, int itemstackSize){		
+		try {
+			Item em = item;			
+			Item em1 = item;
+			Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta);
+			if (em1 != null){
+				if (null == em){
+					em = em1;
+				}
+				if (em != null){
+					ItemStack metaStack = new ItemStack(em,itemstackSize,meta);
+					return metaStack;
+				}
+			}
+			return null;
+		} catch (NullPointerException e) {
+			Utils.LOG_ERROR(item.getUnlocalizedName()+" not found. [NULL]");
+			return null;
+		}		
+	}
+
+	public static ItemStack getCorrectStacktype(String fqrn, int stackSize){
+		String oreDict = "ore:";
+		ItemStack temp;
+		if (fqrn.toLowerCase().contains(oreDict.toLowerCase())){
+			String sanitizedName = fqrn.replace(oreDict, "");
+			temp = UtilsItems.getItemStack(sanitizedName, stackSize);
+			return temp;
+		}
+		String[] fqrnSplit = fqrn.split(":");
+		if(fqrnSplit[2] == null){fqrnSplit[2] = "0";}			
+		temp = UtilsItems.getItemStackWithMeta(LoadedMods.MiscUtils, fqrn, fqrnSplit[1], Integer.parseInt(fqrnSplit[2]), stackSize);
+		return temp;			
+	}	
+
+	public static ItemStack getCorrectStacktype(Object item_Input, int stackSize) {
+		if (item_Input instanceof String){
+			return getCorrectStacktype(item_Input, stackSize);
+		}
+		else if (item_Input instanceof ItemStack){
+			return (ItemStack) item_Input;
+		}
+		if (item_Input instanceof var){
+			return ((var) item_Input).getStack(stackSize);
+		}
+		return null;
+	}
+
+	public static Item getItem(String fqrn) // fqrn = fully qualified resource name
+	{
+		String[] fqrnSplit = fqrn.split(":");
+		return GameRegistry.findItem(fqrnSplit[0], fqrnSplit[1]);
+	}
+
+	public static ItemStack getItemStack(String fqrn, int Size) // fqrn = fully qualified resource name
+	{
+		String[] fqrnSplit = fqrn.split(":");
+		return GameRegistry.findItemStack(fqrnSplit[0], fqrnSplit[1], Size);
+	}
+
+	// TODO
+	/*public static FluidStack getFluidStack(Materials m, int Size) // fqrn = fully qualified resource name
+	{
+		String[] fqrnSplit = fqrn.split(":");
+
+		FluidStack x = (FluidStack) "Materials."+m+".getFluid"(Size);
+
+		return GameRegistry.findItemStack(fqrnSplit[0], fqrnSplit[1], Size);
+	}*/
+
+	public static Item getItemInPlayersHand(){
+		Minecraft mc = Minecraft.getMinecraft();
+		Item heldItem = null;
+
+		try{heldItem = mc.thePlayer.getHeldItem().getItem();
+		}catch(NullPointerException e){return null;}
+
+		if (heldItem != null){
+			return heldItem;
+		}
+
+		return null;
+	}
+
+	public static void generateSpawnEgg(String entityModID, String parSpawnName, int colourEgg, int colourOverlay){
+		Item itemSpawnEgg = new BasicSpawnEgg(entityModID, parSpawnName, colourEgg, colourOverlay).setUnlocalizedName("spawn_egg_"+parSpawnName.toLowerCase()).setTextureName(CORE.MODID+":spawn_egg");
+		GameRegistry.registerItem(itemSpawnEgg, "spawnEgg"+parSpawnName);
+	}
+
+	public static ItemStack getItemStackOfAmountFromOreDict(String oredictName, int amount){
+		ArrayList<ItemStack> oreDictList = OreDictionary.getOres(oredictName);
+		if (!oreDictList.isEmpty()){
+		ItemStack returnValue = oreDictList.get(0).copy();
+		returnValue.stackSize = amount;
+		return returnValue;
+		}
+	 return getSimpleStack(ModItems.AAA_Broken, amount);
+	}
+	
+	public static void generateItemsFromMaterial(String unlocalizedName, String materialName, int materialTier, MaterialInfo matInfo, int Colour, boolean hotIngot){
+		if (materialTier > 10 || materialTier <= 0){
+			materialTier = 2;
+		}
+		int sRadiation = 0;
+		
+		if (materialName.toLowerCase().contains("uranium")){
+			sRadiation = 2;
+		}
+		else if (materialName.toLowerCase().contains("plutonium")){
+			sRadiation = 4;
+		}
+		else if (materialName.toLowerCase().contains("thorium")){
+			sRadiation = 1;
+		}
+		if (sRadiation >= 1){
+			Item temp;
+			Block tempBlock;
+			tempBlock = new BlockBaseModular(unlocalizedName, materialName,BlockTypes.STANDARD, Colour);
+			temp = new BaseItemIngot("itemIngot"+unlocalizedName, materialName, Colour, sRadiation);
+			
+			temp = new BaseItemDust("itemDust"+unlocalizedName, materialName, matInfo, Colour, "Dust", hotIngot, materialTier, sRadiation);
+			temp = new BaseItemDust("itemDustTiny"+unlocalizedName, materialName, matInfo, Colour, "Tiny", hotIngot, materialTier, sRadiation);
+			temp = new BaseItemDust("itemDustSmall"+unlocalizedName, materialName, matInfo, Colour, "Small", hotIngot, materialTier, sRadiation);
+			
+			temp = new BaseItemPlate("itemPlate"+unlocalizedName, materialName, Colour, materialTier, sRadiation);
+			temp = new BaseItemRod("itemRod"+unlocalizedName, materialName, Colour, materialTier, sRadiation);
+			temp = new BaseItemRodLong("itemRodLong"+unlocalizedName, materialName, Colour, materialTier, sRadiation);
+		}
+		
+		else {
+			Item temp;
+			Block tempBlock;
+			tempBlock = new BlockBaseModular(unlocalizedName, materialName,BlockTypes.STANDARD, Colour);
+			tempBlock = new BlockBaseModular(unlocalizedName, materialName,BlockTypes.FRAME, Colour);
+			temp = new BaseItemIngot("itemIngot"+unlocalizedName, materialName, Colour, sRadiation);
+			if (hotIngot){
+				Item tempIngot = temp;
+				temp = new BaseItemIngotHot("itemHotIngot"+unlocalizedName, materialName, UtilsItems.getSimpleStack(tempIngot, 1), materialTier);
+				}
+			temp = new BaseItemDust("itemDust"+unlocalizedName, materialName, matInfo, Colour, "Dust", hotIngot, materialTier, sRadiation);
+			temp = new BaseItemDust("itemDustTiny"+unlocalizedName, materialName, matInfo, Colour, "Tiny", hotIngot, materialTier, sRadiation);
+			temp = new BaseItemDust("itemDustSmall"+unlocalizedName, materialName, matInfo, Colour, "Small", hotIngot, materialTier, sRadiation);
+			
+			temp = new BaseItemPlate("itemPlate"+unlocalizedName, materialName, Colour, materialTier, sRadiation);
+			temp = new BaseItemRod("itemRod"+unlocalizedName, materialName, Colour, materialTier, sRadiation);
+			temp = new BaseItemRodLong("itemRodLong"+unlocalizedName, materialName, Colour, materialTier, sRadiation);
+			temp = new BaseItemRing("itemRing"+unlocalizedName, materialName, Colour, materialTier);
+			temp = new BaseItemBolt("itemBolt"+unlocalizedName, materialName, Colour, materialTier);
+			temp = new BaseItemScrew("itemScrew"+unlocalizedName, materialName, Colour, materialTier);
+			temp = new BaseItemRotor("itemRotor"+unlocalizedName, materialName, Colour);
+			temp = new BaseItemGear("itemGear"+unlocalizedName, materialName, Colour, materialTier);
+		}
+		
+	}
+	
+	public static MultiPickaxeBase generateMultiPick(Materials material){
+		ToolMaterial customMaterial = Utils.generateMaterialFromGT(material);
+		short[] rgb;
+		rgb = material.getRGBA();
+		int dur = customMaterial.getMaxUses();
+		
+		if (dur <= 0){
+			dur = material.mDurability;
+		}
+		
+		MultiPickaxeBase MP_Redstone = new MultiPickaxeBase(
+				material.name()+" Multipick",
+				(customMaterial),
+				dur,
+				Utils.rgbtoHexValue(rgb[0],rgb[1],rgb[2])
+				);
+		
+		return MP_Redstone;
+		
+	}
+	
+	public static String getArrayStackNames(ItemStack[] aStack){
+		String itemNames = "Item Array: ";
+		for (ItemStack alph : aStack){
+			String temp = itemNames;
+			itemNames = temp + ", " + alph.getDisplayName() + " x" + alph.stackSize;
+		}
+		return itemNames;
+		
+	}
+	
+	public static String getFluidArrayStackNames(FluidStack[] aStack){
+		String itemNames = "Fluid Array: ";
+		for (FluidStack alph : aStack){
+			String temp = itemNames;
+			itemNames = temp + ", " + alph.getFluid().getName() + " x" + alph.amount;
+		}
+		return itemNames;
+		
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java b/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java
new file mode 100644
index 0000000000..69548eb49a
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java
@@ -0,0 +1,87 @@
+package gtPlusPlus.core.util.materials;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TC_Aspects.TC_AspectStack;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.objects.MaterialStack;
+import gtPlusPlus.core.lib.MaterialInfo;
+import gtPlusPlus.core.util.Utils;
+
+import java.util.List;
+
+import net.minecraftforge.common.util.EnumHelper;
+
+public class MaterialUtils {
+	
+	public static short firstID = 791;
+
+	private static Class[][] commonTypes =
+		{{Materials.class, int.class, TextureSet.class, float.class, int.class,
+			int.class, int.class, int.class, int.class, int.class, int.class,
+			String.class, int.class, int.class, int.class, int.class, boolean.class,
+			boolean.class, int.class, int.class, int.class, Dyes.class, int.class,
+			List.class , List.class}};
+	
+	public static Materials addGtMaterial(String enumNameForMaterial, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, int aTypes, int aR, int aG, int aB, int aA, String aLocalName, int aFuelType, int aFuelPower, int aMeltingPoint, int aBlastFurnaceTemp, boolean aBlastFurnaceRequired, boolean aTransparent, int aOreValue, int aDensityMultiplier, int aDensityDivider, Dyes aColor, int aExtraData, List<MaterialStack> aMaterialList, List<TC_AspectStack> aAspects)
+    {
+		Utils.LOG_INFO("Attempting to add GT material: "+enumNameForMaterial);
+		return EnumHelper.addEnum(Materials.class, enumNameForMaterial, commonTypes, firstID++, aIconSet, aToolSpeed, aToolDurability, aToolQuality, aTypes, aR, aG, aB, aA, aLocalName,
+				aFuelType, aFuelPower, aMeltingPoint, aBlastFurnaceTemp, aBlastFurnaceRequired, aTransparent, aOreValue, aDensityMultiplier, aDensityDivider,
+				aColor, aExtraData, aMaterialList, aAspects);
+		}
+	
+
+	/*
+	 * That's shown, many times, in the EnumHelper code, all the add functions just wrap the addEnum function.
+	You need the target enum class, and 2 arrays, 1 holding the types for the constructor arguments, 
+	and the other holding the constructor argument values (the things being passed to the constructor)
+
+	The 'decompiled' Boolean should be set to true if the class you're adding to has been decompiled/recompiled again. 
+	(it adds a 2nd enum arguments that need to be accounted for, but isn't actually useful to you) 
+
+	 *
+	 *new Class[{int.class, TextureSet.class, float.class, int.class,
+	int.class, int.class, int.class, int.class, int.class, int.class,
+	String.class, int.class, int.class, int.class, int.class, boolean.class,
+	boolean.class, int.class, int.class, int.class, Dyes.class, int.class,
+					List.class , List.class}],
+	 */
+
+	
+
+	public static Materials GenerateGtMaterialForSingleUse(MaterialInfo s){
+
+		Materials yourName = EnumHelper.addEnum(
+
+				Materials.class, s.name(),
+
+
+
+				new Object[0]
+
+				);
+		try
+		{
+
+
+
+			/*Class<? extends ItemCell> clz = item.getClass();
+			Method methode = clz.getDeclaredMethod("addCell", int.class, InternalName.class, Block[].class);
+			methode.setAccessible(true);
+			ItemStack temp = (ItemStack) methode.invoke(item, cellID++, yourName, new Block[0]);*/
+
+
+
+
+
+
+			return Materials.Abyssal;
+		}
+		catch(Exception e){
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/math/MathUtils.java b/src/Java/gtPlusPlus/core/util/math/MathUtils.java
new file mode 100644
index 0000000000..3df5693bc3
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/math/MathUtils.java
@@ -0,0 +1,213 @@
+package gtPlusPlus.core.util.math;
+
+import gtPlusPlus.core.util.Utils;
+
+import java.util.Map;
+import java.util.Random;
+
+public class MathUtils {
+
+	/**
+	 * Returns a psuedo-random number between min and max, inclusive.
+	 * The difference between min and max can be at most
+	 * Integer.MAX_VALUE - 1.
+	 *
+	 * @param min Minimim value
+	 * @param max Maximim value.  Must be greater than min.
+	 * @return Integer between min and max, inclusive.
+	 * @see java.util.Random#nextInt(int)
+	 */
+	public static int randInt(int min, int max) {
+
+		// Usually this can be a field rather than a method variable
+		Random rand = new Random();
+
+		// nextInt is normally exclusive of the top value,
+		// so add 1 to make it inclusive
+		int randomNum = rand.nextInt((max - min) + 1) + min;
+
+		return randomNum;
+	}
+	
+	
+	/**
+	 * Returns a psuedo-random number between min and max, inclusive.
+	 * The difference between min and max can be at most
+	 * Long.MAX_VALUE - 1.
+	 *
+	 * @param min Minimim value
+	 * @param max Maximim value.  Must be greater than min.
+	 * @return Long between min and max, inclusive.
+	 * @see java.util.Random#nextLong(long)
+	 */
+	public static long randLong(long min, long max) {
+		// Usually this can be a field rather than a method variable
+		Random rand = new Random();
+
+		// nextInt is normally exclusive of the top value,
+		// so add 1 to make it inclusive
+		long randomNum = MathUtils.nextLong(rand,(max - min) + 1) + min;
+
+		return randomNum;
+	}
+	private static long nextLong(Random rng, long n) {
+		// error checking and 2^x checking removed for simplicity.
+		long bits, val;
+		do {
+			bits = (rng.nextLong() << 1) >>> 1;
+			val = bits % n;
+		} while (bits-val+(n-1) < 0L);
+		return val;
+	}
+	
+
+	/**
+	 * Returns a percentage.
+	 * The returned number is the % of X in Y.
+	 * Supports Doubles.
+	 *
+	 * @param current Current value.
+	 * @param max Maximim value.  Must be greater than min.
+	 * @return double between min and max, inclusive.	 
+	 */
+	public static double findPercentage(double current, double max){
+		double c = ((double) current / max) * 100;
+		double roundOff = Math.round(c * 100.00) / 100.00;
+		return roundOff;
+	}
+	
+
+	//Smooth Rounding Function
+	/**
+	 * Returns a double.
+	 * The returned number is d rounded to the nearest d.01.
+	 * Supports Doubles.
+	 *
+	 * @param current Current value.
+	 * @return double Rounded value.	 
+	 */
+	public static double decimalRounding(double d) {
+		return Math.round(d * 2) / 2.0;
+	}
+	
+
+	//Smooth Rounding Function (Nearest 5)
+	/**
+	 * Returns a double.
+	 * The returned number is d rounded to the nearest d.5.
+	 * Supports Doubles.
+	 *
+	 * @param current Current value.
+	 * @return double Rounded value.	 
+	 */
+	public static double decimalRoundingToWholes(double d) {
+		return 5*(Math.round(d/5));
+	}
+
+	
+	/**
+	 * Returns a boolean.
+	 * The returned boolean is wether or not X evenly fits in to Y.
+	 * Supports ints.
+	 *
+	 * @param x Value A.
+	 * @param y Value B.  Must be greater than min.
+	 * @return boolean Whether or not it divides evenly.	 
+	 */
+	public static boolean divideXintoY(int x, int y){
+		if ((x % y) == 0)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	
+	/**
+	 * Returns a boolean.
+	 * The returned boolean is based on the odd/eveness of the input.
+	 * Supports ints.
+	 *
+	 * @param x Value A.
+	 * @return boolean Whether or not it divides evenly.	 
+	 */
+	public static boolean isNumberEven(int x){
+		if ((x % 2) == 0)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	
+
+	/**
+	 * Returns an int.
+	 * The returned number is the value on i + 273.15F.
+	 * Supports ints.
+	 *
+	 * @param i Temp in Celcius.
+	 * @return int The celcius temp returned as Kelvin, rounded to the readest whole.	 
+	 */
+	public static float celsiusToKelvin(int i){
+		double f = i + 273.15F;
+		return (int)decimalRoundingToWholes(f);
+	}
+	
+
+	/**
+	 * Returns a hexInteger.
+	 * The returned number is the hex value of the input.
+	 * Supports ints.
+	 *
+	 * @param input Current value.
+	 * @return hexInteger. 
+	 */
+	public static int getHexNumberFromInt(int input){
+		String result = Integer.toHexString(input);
+		int resultINT = Integer.getInteger(result);
+		return resultINT;
+	}
+	
+
+	/**
+	 * Returns a hexInteger.
+	 * The returned value is between min and max.
+	 * Supports ints.
+	 *
+	 * @param min Minimum value.
+	 * @param max Maximium value.  Must be greater than min.
+	 * @return hexInteger between min and max, inclusive.	 
+	 */
+	public static int generateRandomHexValue(int min, int max){
+		int result = getHexNumberFromInt(randInt(min, max));
+		return result;
+	}
+
+	
+	/**
+	 * Returns a random hex value.
+	 * The returned value is between 000000-ffffff.
+	 *
+	 * @return hexInteger between min and max, inclusive.	 
+	 */
+	public static int generateSingularRandomHexValue(){
+		String temp;
+		int randomInt = randInt(1, 5);
+		final Map<Integer, String> colours = Utils.hexColourGeneratorRandom(5);
+
+		if (colours.get(randomInt) != null && colours.size() > 0){				
+			temp = colours.get(randomInt);		
+		}
+		else {
+			temp = "0F0F0F";	
+		}
+
+		Utils.LOG_WARNING("Operating with "+temp);	
+		temp = Utils.appenedHexNotationToString(String.valueOf(temp));
+		Utils.LOG_WARNING("Made "+temp+" - Hopefully it's not a mess.");
+		Utils.LOG_WARNING("It will decode into "+Integer.decode(temp)+".");
+		return Integer.decode(temp);
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/particles/EntityParticleFXMysterious.java b/src/Java/gtPlusPlus/core/util/particles/EntityParticleFXMysterious.java
new file mode 100644
index 0000000000..2c704e48a6
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/particles/EntityParticleFXMysterious.java
@@ -0,0 +1,17 @@
+package gtPlusPlus.core.util.particles;
+
+import net.minecraft.client.particle.EntityAuraFX;
+import net.minecraft.world.World;
+
+public class EntityParticleFXMysterious extends EntityAuraFX
+{
+    public EntityParticleFXMysterious(World parWorld,
+            double parX, double parY, double parZ,
+            double parMotionX, double parMotionY, double parMotionZ) 
+    {
+        super(parWorld, parX, parY, parZ, parMotionX, parMotionY, parMotionZ);
+        setParticleTextureIndex(82); // same as happy villager
+        particleScale = 2.0F;
+        setRBGColorF(0x88, 0x00, 0x88);
+    }
+}
diff --git a/src/Java/gtPlusPlus/core/util/player/PlayerCache.java b/src/Java/gtPlusPlus/core/util/player/PlayerCache.java
new file mode 100644
index 0000000000..095eb543db
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/player/PlayerCache.java
@@ -0,0 +1,190 @@
+package gtPlusPlus.core.util.player;
+
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.UUID;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.World;
+
+public class PlayerCache {
+
+	private static final File cache = new File("PlayerCache.dat");
+
+	public static final void initCache() {
+		if (CORE.PlayerCache == null || CORE.PlayerCache.equals(null)){
+			try {
+
+				if (cache != null){
+					CORE.PlayerCache = PlayerCache.readPropertiesFileAsMap();
+					Utils.LOG_INFO("Loaded PlayerCache.dat");	
+				}
+
+
+			} catch (Exception e) {
+				Utils.LOG_INFO("Failed to initialise PlayerCache.dat");
+				PlayerCache.createPropertiesFile("PLAYER_", "DATA");
+				//e.printStackTrace();
+			}
+		}
+	}
+
+	public static void createPropertiesFile(String playerName, String playerUUIDasString) {
+		try {
+			Properties props = new Properties();
+			props.setProperty(playerName+" ", playerUUIDasString);
+			OutputStream out = new FileOutputStream(cache);
+			props.store(out, "Player Cache.");
+			Utils.LOG_INFO("PlayerCache.dat created for future use.");
+		}
+		catch (Exception e ) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void appendParamChanges(String playerName, String playerUUIDasString) {
+		HashMap<String, UUID> playerInfo = new HashMap<String, UUID>();
+		playerInfo.put(playerName, UUID.fromString(playerUUIDasString));
+		
+		/*try {
+			Utils.LOG_INFO("Attempting to load "+cache.getName());
+			properties.load(new FileInputStream(cache));
+			if (properties == null || properties.equals(null)){
+				Utils.LOG_INFO("Please wait.");
+			}
+			else {
+				Utils.LOG_INFO("Loaded PlayerCache.dat");
+				properties.setProperty(playerName+"_", playerUUIDasString);
+				FileOutputStream fr=new FileOutputStream(cache);
+				properties.store(fr, "Player Cache.");
+				fr.close();
+			}
+
+		} */
+		
+		try
+        {
+               FileOutputStream fos = new FileOutputStream("PlayerCache.dat");
+               ObjectOutputStream oos = new ObjectOutputStream(fos);
+               oos.writeObject(playerInfo);
+               oos.close();
+               fos.close();
+               Utils.LOG_INFO("Serialized Player data saved in PlayerCache.dat");
+        }
+		
+		catch (IOException e) {
+			Utils.LOG_INFO("No PlayerCache file found, creating one.");
+			createPropertiesFile(playerName, playerUUIDasString);
+		}			
+	}
+
+	/**
+	 * Reads a "properties" file, and returns it as a Map 
+	 * (a collection of key/value pairs).
+	 * 
+	 * Credit due to Alvin Alexander - http://alvinalexander.com/java/java-properties-file-map-example?nocache=1#comment-8215
+	 * Changed slightly as the filename and delimiter are constant in my case.
+	 * 
+	 * @param filename  The properties filename to read.
+	 * @param delimiter The string (or character) that separates the key 
+	 *                  from the value in the properties file.
+	 * @return The Map that contains the key/value pairs.
+	 * @throws Exception
+	 */
+	@Deprecated
+	public static Map<String, String> readPropertiesFileAsMapOld() throws Exception {
+		String delimiter = "=";
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		Map<String, String> map = new HashMap<String, String>();
+		BufferedReader reader = new BufferedReader(new FileReader(cache));
+		String line;
+		while ((line = reader.readLine()) != null)
+		{
+			if (line.trim().length()==0) continue;
+			if (line.charAt(0)=='#') continue;
+			// assumption here is that proper lines are like "String : <a href="http://xxx.yyy.zzz/foo/bar"" title="http://xxx.yyy.zzz/foo/bar"">http://xxx.yyy.zzz/foo/bar"</a>,
+			// and the ":" is the delimiter
+			int delimPosition = line.indexOf(delimiter);
+			String key = line.substring(0, delimPosition-1).trim();
+			String value = line.substring(delimPosition+1).trim();
+			map.put(key, value);
+		}
+		reader.close();
+		CORE.PlayerCache = map;
+		return map;
+	}
+
+	public static HashMap<String, UUID> readPropertiesFileAsMap() {
+		HashMap<String, UUID> map = null;
+	      try
+	      {
+	         FileInputStream fis = new FileInputStream(cache);
+	         ObjectInputStream ois = new ObjectInputStream(fis);
+	         map = (HashMap<String, UUID>) ois.readObject();
+	         ois.close();
+	         fis.close();
+	      }catch(IOException ioe)
+	      {
+	         ioe.printStackTrace();	
+	         return null;
+	      }catch(ClassNotFoundException c)
+	      {
+	    	  Utils.LOG_INFO("Class not found");
+	         c.printStackTrace();
+	         return null;
+	      }
+	      Utils.LOG_WARNING("Deserialized PlayerCache..");
+	     return map;
+	}
+
+	public static String lookupPlayerByUUID(UUID UUID){
+		
+		try {
+			World worldw = Minecraft.getMinecraft().thePlayer.worldObj;
+			//if (!worldw.isRemote){
+				
+				
+				try {
+					Map<String, UUID> map = null;
+					try {
+						map = readPropertiesFileAsMap();
+					} catch (Exception e) {
+						Utils.LOG_INFO("With "+e.getCause()+" as cause, Caught Exception: "+e.toString());
+						//e.printStackTrace();
+					}
+					for (Entry<String, UUID> entry : map.entrySet()) {
+						if (Objects.equals(UUID, entry.getValue())) {
+							return entry.getKey();
+						}
+					}
+					return null;
+				} catch (NullPointerException e) {
+					Utils.LOG_INFO("With "+e.getCause()+" as cause, Caught Exception: "+e.toString());
+					//e.printStackTrace();
+				}			
+			
+			
+			//}
+				
+				
+		} catch (Throwable r){
+			Utils.LOG_INFO("With "+r.getCause()+" as cause, Caught Exception: "+r.toString());			
+		}		
+		return null;
+	}
+}
diff --git a/src/Java/gtPlusPlus/core/util/player/UtilsMining.java b/src/Java/gtPlusPlus/core/util/player/UtilsMining.java
new file mode 100644
index 0000000000..1b6b957b32
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/player/UtilsMining.java
@@ -0,0 +1,180 @@
+package gtPlusPlus.core.util.player;
+
+import gtPlusPlus.core.util.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public class UtilsMining {
+	
+	private static boolean durabilityDamage = false;
+	private static ItemStack stack;
+
+	public static Boolean canPickaxeBlock(Block currentBlock, World currentWorld){
+		String correctTool = "";
+		if (!currentWorld.isRemote){			
+			try {
+				correctTool = currentBlock.getHarvestTool(0);
+				//Utils.LOG_WARNING(correctTool);
+				if (correctTool.equals("pickaxe")){
+					return true;}
+			} catch (NullPointerException e){
+				return false;}
+		}
+		return false;
+	}
+	
+	private static void removeBlockAndDropAsItem(World world, int X, int Y, int Z){
+		try {
+			Block block = world.getBlock(X, Y, Z);		
+				if (canPickaxeBlock(block, world)){
+					if((block != Blocks.bedrock) && (block.getBlockHardness(world, X, Y, Z) != -1) && (block.getBlockHardness(world, X, Y, Z) <= 100) && (block != Blocks.water) && (block != Blocks.lava)){
+						block.dropBlockAsItem(world, X, Y, Z, world.getBlockMetadata(X, Y, Z), 0);
+						world.setBlockToAir(X, Y, Z);
+
+				}
+				else {
+					Utils.LOG_WARNING("Incorrect Tool for mining this block.");
+				}
+			}
+		} catch (NullPointerException e){
+
+		}
+	}
+
+	public static void customMine(World world, String FACING, EntityPlayer aPlayer){
+
+		float DURABILITY_LOSS = 0;
+		if (!world.isRemote){
+			int X = 0;
+			int Y = 0;
+			int Z = 0;
+
+			if (FACING.equals("below") || FACING.equals("above")){
+
+				//Set Player Facing
+				X = (int) aPlayer.posX;
+				Utils.LOG_WARNING("Setting Variable X: "+X);
+				if (FACING.equals("above")){
+					Z = (int) aPlayer.posY + 1;
+					Utils.LOG_WARNING("Setting Variable Y: "+Y);
+					}
+					else {
+						Z = (int) aPlayer.posY - 1;
+						Utils.LOG_WARNING("Setting Variable Y: "+Y);}
+				Z = (int) aPlayer.posZ;
+				Utils.LOG_WARNING("Setting Variable Z: "+Z);
+
+				DURABILITY_LOSS = 0;
+				for(int i = -2; i < 3; i++) {
+					for(int j = -2; j < 3; j++) {
+						for(int k = -2; k < 3; k++) {
+/*//							float dur = calculateDurabilityLoss(world, X + i, Y + k, Z + j);
+//							DURABILITY_LOSS = (DURABILITY_LOSS + dur);	
+//							Utils.LOG_WARNING("Added Loss: "+dur);
+*/							removeBlockAndDropAsItem(world, X + i, Y + k, Z + j);
+						}
+					}
+				}
+			}
+
+			else if (FACING.equals("facingEast") || FACING.equals("facingWest")){
+
+				//Set Player Facing
+				Z = (int) aPlayer.posZ;
+				Y = (int) aPlayer.posY;
+				if (FACING.equals("facingEast")){
+					X = (int) aPlayer.posX + 1;}
+					else {
+						X = (int) aPlayer.posX - 1;}
+					
+
+				DURABILITY_LOSS = 0;
+				for(int i = -1; i < 2; i++) {
+					for(int j = -1; j < 2; j++) {
+						for(int k = -1; k < 2; k++) {
+							/*float dur = calculateDurabilityLoss(world, X+k, Y + i, Z + j);
+							DURABILITY_LOSS = (DURABILITY_LOSS + dur);
+							Utils.LOG_WARNING("Added Loss: "+dur);*/
+							removeBlockAndDropAsItem(world, X+k, Y + i, Z + j);
+						}
+					}
+				}
+			}
+
+			else if (FACING.equals("facingNorth") || FACING.equals("facingSouth")){
+
+				//Set Player Facing
+				X = (int) aPlayer.posX;
+				Y = (int) aPlayer.posY;
+				
+				if (FACING.equals("facingNorth")){
+				Z = (int) aPlayer.posZ + 1;}
+				else {
+					Z = (int) aPlayer.posZ - 1;}
+				
+				DURABILITY_LOSS = 0;
+				for(int i = -1; i < 2; i++) {
+					for(int j = -1; j < 2; j++) {
+						for(int k = -1; k < 2; k++) {
+							/*float dur = calculateDurabilityLoss(world, X + j, Y + i, Z+k);
+							DURABILITY_LOSS = (DURABILITY_LOSS + dur);
+							Utils.LOG_WARNING("Added Loss: "+dur);*/
+							removeBlockAndDropAsItem(world, X + j, Y + i, Z+k);
+						}
+					}
+				}
+			}
+
+			//Set Durability damage to the item
+			if (durabilityDamage == true){
+			Utils.LOG_WARNING("Total Loss: "+(int)DURABILITY_LOSS);
+			if (stack.getItemDamage() < (stack.getMaxDamage()-DURABILITY_LOSS)){
+				stack.damageItem((int) DURABILITY_LOSS, aPlayer);
+			}
+			}
+			DURABILITY_LOSS = 0;
+		}
+	}
+	
+	
+	public static boolean getBlockType(Block block){
+		final String LIQUID = "liquid";
+		final String BLOCK = "block";
+		final String ORE = "ore";
+		final String AIR = "air";
+		String blockClass = "";
+
+		try {
+			blockClass = block.getClass().toString().toLowerCase();
+			Utils.LOG_WARNING(blockClass);
+			if (blockClass.toLowerCase().contains(LIQUID)){
+				Utils.LOG_WARNING(block.toString()+" is a Liquid.");
+				return false;
+			}
+			else if (blockClass.toLowerCase().contains(ORE)){
+				Utils.LOG_WARNING(block.toString()+" is an Ore.");
+				return true;
+			}
+			else if (blockClass.toLowerCase().contains(AIR)){
+				Utils.LOG_WARNING(block.toString()+" is Air.");
+				return false;
+			}
+			else if (blockClass.toLowerCase().contains(BLOCK)){
+				Utils.LOG_WARNING(block.toString()+" is a block of some kind.");
+				return false;
+			}
+			else {
+				Utils.LOG_WARNING(block.toString()+" is mystery.");
+				return false;
+			}
+		}
+		catch(NullPointerException e){
+			return false;
+		}
+	}
+	
+	
+}
diff --git a/src/Java/gtPlusPlus/core/util/recipe/UtilsRecipe.java b/src/Java/gtPlusPlus/core/util/recipe/UtilsRecipe.java
new file mode 100644
index 0000000000..997aaa95c9
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/recipe/UtilsRecipe.java
@@ -0,0 +1,370 @@
+package gtPlusPlus.core.util.recipe;
+
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.core.handler.COMPAT_HANDLER;
+import gtPlusPlus.core.handler.Recipes.LateRegistrationHandler;
+import gtPlusPlus.core.handler.Recipes.RegistrationHandler;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.item.UtilsItems;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraftforge.oredict.OreDictionary;
+import net.minecraftforge.oredict.ShapedOreRecipe;
+import net.minecraftforge.oredict.ShapelessOreRecipe;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class UtilsRecipe {
+
+	public static void recipeBuilder(Object slot_1, Object slot_2, Object slot_3, Object slot_4, Object slot_5, Object slot_6, Object slot_7, Object slot_8, Object slot_9, ItemStack resultItem){	
+
+		ArrayList<Object> validSlots = new ArrayList<Object>();
+
+		Utils.LOG_INFO("Trying to add a recipe for "+resultItem.toString());
+		String a,b,c,d,e,f,g,h,i;
+		if (slot_1 == null){ a = " ";} else { a = "1";validSlots.add('1');validSlots.add(slot_1);}
+		Utils.LOG_WARNING(a);
+		if (slot_2 == null){ b = " ";} else { b = "2";validSlots.add('2');validSlots.add(slot_2);}
+		Utils.LOG_WARNING(b);
+		if (slot_3 == null){ c = " ";} else { c = "3";validSlots.add('3');validSlots.add(slot_3);}
+		Utils.LOG_WARNING(c);
+		if (slot_4 == null){ d = " ";} else { d = "4";validSlots.add('4');validSlots.add(slot_4);}
+		Utils.LOG_WARNING(d);
+		if (slot_5 == null){ e = " ";} else { e = "5";validSlots.add('5');validSlots.add(slot_5);}
+		Utils.LOG_WARNING(e);
+		if (slot_6 == null){ f = " ";} else { f = "6";validSlots.add('6');validSlots.add(slot_6);}
+		Utils.LOG_WARNING(f);
+		if (slot_7 == null){ g = " ";} else { g = "7";validSlots.add('7');validSlots.add(slot_7);}
+		Utils.LOG_WARNING(g);
+		if (slot_8 == null){ h = " ";} else { h = "8";validSlots.add('8');validSlots.add(slot_8);}
+		Utils.LOG_WARNING(h);
+		if (slot_9 == null){ i = " ";} else { i = "9";validSlots.add('9');validSlots.add(slot_9);}
+		Utils.LOG_WARNING(i);
+
+
+		Utils.LOG_ERROR("_______");
+		String lineOne = a+b+c;
+		Utils.LOG_ERROR("|"+a+"|"+b+"|"+c+"|");
+		Utils.LOG_ERROR("_______");
+		String lineTwo = d+e+f;
+		Utils.LOG_ERROR("|"+d+"|"+e+"|"+f+"|");
+		Utils.LOG_ERROR("_______");
+		String lineThree = g+h+i;
+		Utils.LOG_ERROR("|"+g+"|"+h+"|"+i+"|");
+		Utils.LOG_ERROR("_______");
+
+		validSlots.add(0, lineOne);
+		validSlots.add(1, lineTwo);
+		validSlots.add(2, lineThree);
+		boolean advancedLog = false;
+		if (CORE.DEBUG){
+			advancedLog = true;
+		}		
+		if (advancedLog){
+			int j = 0;
+			int l = validSlots.size();
+			Utils.LOG_WARNING("l:"+l);
+			while (j <= l) {
+				Utils.LOG_WARNING("j:"+j);
+				if (j <= 2){
+					Utils.LOG_WARNING("ArrayList Values: "+validSlots.get(j));
+					Utils.LOG_WARNING("Adding 1.");
+					j++;
+				}
+				else if (j >= 3){
+					Utils.LOG_WARNING("ArrayList Values: '"+validSlots.get(j)+"' "+validSlots.get(j+1));
+					if (j < (l-2)){
+						Utils.LOG_WARNING("Adding 2.");
+						j=j+2;
+					}
+					else {
+						Utils.LOG_WARNING("Done iteration.");
+						break;
+					}
+				}
+				else if (j == l){
+					Utils.LOG_WARNING("Done iteration.");
+					break;
+				}
+				if (validSlots.get(j) instanceof String || validSlots.get(j) instanceof ItemStack){
+					//Utils.LOG_WARNING("Is Valid: "+validSlots.get(j));
+				}
+			}	
+		}
+
+		try {
+			GameRegistry.addRecipe(new ShapedOreRecipe(resultItem.copy(), (Object[]) validSlots.toArray()));		
+			Utils.LOG_INFO("Success! Added a recipe for "+resultItem.toString());
+			if (!COMPAT_HANDLER.areInitItemsLoaded){
+				RegistrationHandler.recipesSuccess++;
+			}
+			else {
+				LateRegistrationHandler.recipesSuccess++;
+			}
+		}
+		catch(NullPointerException | ClassCastException k){
+			k.getMessage();
+			k.getClass();
+			k.printStackTrace();
+			k.getLocalizedMessage();
+			Utils.LOG_WARNING("@@@: Invalid Recipe detected for: "+resultItem.getUnlocalizedName());
+			if (!COMPAT_HANDLER.areInitItemsLoaded){
+				RegistrationHandler.recipesFailed++;
+			}
+			else {
+				LateRegistrationHandler.recipesFailed++;
+			}			
+		}
+	}
+
+	public static void shapelessBuilder(ItemStack Output, Object slot_1, Object slot_2, Object slot_3, Object slot_4, Object slot_5, Object slot_6, Object slot_7, Object slot_8, Object slot_9){
+		//Item output_ITEM = Output.getItem();
+
+		ArrayList<Object> validSlots = new ArrayList<Object>();
+
+		Utils.LOG_INFO("Trying to add a recipe for "+Output.toString());
+		String a,b,c,d,e,f,g,h,i;
+		if (slot_1 == null){ a = " ";} else { a = "1";validSlots.add('1');validSlots.add(slot_1);}
+		Utils.LOG_WARNING(a);
+		if (slot_2 == null){ b = " ";} else { b = "2";validSlots.add('2');validSlots.add(slot_2);}
+		Utils.LOG_WARNING(b);
+		if (slot_3 == null){ c = " ";} else { c = "3";validSlots.add('3');validSlots.add(slot_3);}
+		Utils.LOG_WARNING(c);
+		if (slot_4 == null){ d = " ";} else { d = "4";validSlots.add('4');validSlots.add(slot_4);}
+		Utils.LOG_WARNING(d);
+		if (slot_5 == null){ e = " ";} else { e = "5";validSlots.add('5');validSlots.add(slot_5);}
+		Utils.LOG_WARNING(e);
+		if (slot_6 == null){ f = " ";} else { f = "6";validSlots.add('6');validSlots.add(slot_6);}
+		Utils.LOG_WARNING(f);
+		if (slot_7 == null){ g = " ";} else { g = "7";validSlots.add('7');validSlots.add(slot_7);}
+		Utils.LOG_WARNING(g);
+		if (slot_8 == null){ h = " ";} else { h = "8";validSlots.add('8');validSlots.add(slot_8);}
+		Utils.LOG_WARNING(h);
+		if (slot_9 == null){ i = " ";} else { i = "9";validSlots.add('9');validSlots.add(slot_9);}
+		Utils.LOG_WARNING(i);
+
+
+		Utils.LOG_ERROR("_______");
+		Utils.LOG_ERROR("|"+a+"|"+b+"|"+c+"|");
+		Utils.LOG_ERROR("_______");
+		Utils.LOG_ERROR("|"+d+"|"+e+"|"+f+"|");
+		Utils.LOG_ERROR("_______");
+		Utils.LOG_ERROR("|"+g+"|"+h+"|"+i+"|");
+		Utils.LOG_ERROR("_______");
+
+		validSlots.add(0, a);
+		validSlots.add(1, b);
+		validSlots.add(2, c);
+		validSlots.add(3, d);
+		validSlots.add(4, e);
+		validSlots.add(5, f);
+		validSlots.add(6, g);
+		validSlots.add(7, h);
+		validSlots.add(8, i);
+
+		try {
+			//GameRegistry.addRecipe(new ShapelessOreRecipe(Output, outputAmount), (Object[]) validSlots.toArray());
+			GameRegistry.addRecipe(new ShapelessOreRecipe(Output, (Object[]) validSlots.toArray()));
+			//GameRegistry.addShapelessRecipe(new ItemStack(output_ITEM, 1), new Object[] {slot_1, slot_2});
+			Utils.LOG_INFO("Success! Added a recipe for "+Output.toString());
+			RegistrationHandler.recipesSuccess++;		
+		}
+		catch(RuntimeException k){
+			k.getMessage();
+			k.getClass();
+			k.printStackTrace();
+			k.getLocalizedMessage();
+			Utils.LOG_WARNING("@@@: Invalid Recipe detected for: "+Output.getUnlocalizedName());
+			RegistrationHandler.recipesFailed++;
+		}
+
+
+		//GameRegistry.addShapelessRecipe(new ItemStack(output_ITEM, 1), new Object[] {slot_1, slot_2});
+	}
+
+	public static void recipeBuilder(Object[] array, ItemStack outPut) {
+		Utils.LOG_SPECIFIC_WARNING("object Array - recipeBuilder", "Attempting to build a recipe using an object array as an input, splitting it, then running the normal recipeBuilder() method.", 396);
+		Object a=null;
+		Object b=null;
+		Object c=null;
+		Object d=null;
+		Object e=null;
+		Object f=null;
+		Object g=null;
+		Object h=null;
+		Object i=null;
+		for(int z =0; z <= array.length; z++){
+			array[z].toString();
+			switch(z)
+			{
+			case 0:
+				a = array[z];
+				break;
+			case 1:
+				b = array[z];
+				break;
+			case 2:
+				c = array[z];
+				break;
+			case 3:
+				d = array[z];
+				break;
+			case 4:
+				e = array[z];
+				break;
+			case 5:
+				f = array[z];
+				break;
+			case 6:
+				g = array[z];
+				break;
+			case 7:
+				h = array[z];
+				break;
+			case 8:
+				i = array[z];
+				break;
+			default:
+				break;
+			}
+			recipeBuilder(a, b, c, d, e, f, g, h, i, outPut);
+		}
+	}
+
+	public static boolean removeCraftingRecipe(Object x){
+		if (null == x){return false;}
+		if (x instanceof String){	
+			Item R = UtilsItems.getItem((String) x);
+			if (R != null){
+				x = R;
+			}
+			else {
+				return false;
+			}
+		}
+		if (x instanceof Item || x instanceof ItemStack){
+			if (x instanceof Item){
+				ItemStack r = new ItemStack((Item) x);
+				Utils.LOG_INFO("Removing Recipe for "+r.getUnlocalizedName());
+			}
+			else {
+				Utils.LOG_INFO("Removing Recipe for "+((ItemStack) x).getUnlocalizedName());
+			}
+			if (x instanceof ItemStack){
+				Item r = ((ItemStack) x).getItem();		
+				if (null != r){
+					x = r;
+				}
+				else {
+					Utils.LOG_INFO("Recipe removal failed - Tell Alkalus.");
+					return false;
+				}
+			}			
+			if (UtilsRecipe.attemptRecipeRemoval((Item) x)){
+				Utils.LOG_INFO("Recipe removal successful");
+				return true;
+			}
+			Utils.LOG_INFO("Recipe removal failed - Tell Alkalus.");
+			return false;			
+		}
+		return false;
+	}
+
+	private static boolean attemptRecipeRemoval(Item I){
+		Utils.LOG_WARNING("Create list of recipes.");
+		List<IRecipe> recipes = CraftingManager.getInstance().getRecipeList();
+		Iterator<IRecipe> items = recipes.iterator();
+		Utils.LOG_WARNING("Begin list iteration.");
+		while (items.hasNext()) {
+			ItemStack is = items.next().getRecipeOutput();
+			if (is != null && is.getItem() == I){
+				items.remove();
+				Utils.LOG_INFO("Remove a recipe with "+I.getUnlocalizedName()+" as output.");
+				continue;
+			}
+		}
+		Utils.LOG_WARNING("All recipes should be gone?");
+		if (!items.hasNext()){
+			Utils.LOG_WARNING("We iterated once, let's try again to double check.");
+			Iterator<IRecipe> items2 = recipes.iterator();
+			while (items2.hasNext()) {
+				ItemStack is = items2.next().getRecipeOutput();
+				if (is != null && is.getItem() == I){
+					items.remove();
+					Utils.LOG_WARNING("REMOVING MISSED RECIPE - RECHECK CONSTRUCTORS");
+					return true;
+				}
+			}
+			Utils.LOG_WARNING("Should be all gone now after double checking, so return true.");
+			return true;
+		}
+		Utils.LOG_INFO("Return false, because something went wrong.");
+		return false;
+	}
+
+
+
+
+
+
+	public static void addShapedGregtechRecipe( 
+			Object InputItem1, Object InputItem2, Object InputItem3,
+			Object InputItem4, Object InputItem5, Object InputItem6,
+			Object InputItem7, Object InputItem8, Object InputItem9,
+			ItemStack OutputItem){	
+
+		if ((!(InputItem1 instanceof ItemStack) && !(InputItem1 instanceof String) && (InputItem1 != null)) || 
+				(!(InputItem2 instanceof ItemStack) && !(InputItem2 instanceof String) && (InputItem2 != null)) || 
+				(!(InputItem3 instanceof ItemStack) && !(InputItem3 instanceof String) && (InputItem3 != null)) || 
+				(!(InputItem4 instanceof ItemStack) && !(InputItem4 instanceof String) && (InputItem4 != null)) || 
+				(!(InputItem5 instanceof ItemStack) && !(InputItem5 instanceof String) && (InputItem5 != null)) || 
+				(!(InputItem6 instanceof ItemStack) && !(InputItem6 instanceof String) && (InputItem6 != null)) || 
+				(!(InputItem7 instanceof ItemStack) && !(InputItem7 instanceof String) && (InputItem7 != null)) || 
+				(!(InputItem8 instanceof ItemStack) && !(InputItem8 instanceof String) && (InputItem8 != null)) || 
+				(!(InputItem9 instanceof ItemStack) && !(InputItem9 instanceof String) && (InputItem9 != null))){
+			Utils.LOG_INFO("One Input item was not an ItemStack of an OreDict String.");
+			return;
+		}
+
+		GT_ModHandler.addCraftingRecipe(OutputItem, 
+				GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | 
+				GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED,
+				new Object[]{"ABC", "DEF", "GHI", 
+				'A', InputItem1,  
+				'B', InputItem2,  
+				'C', InputItem3,  
+				'D', InputItem4,  
+				'E', InputItem5,  
+				'F', InputItem6,  
+				'G', InputItem7,  
+				'H', InputItem8,  
+				'I', InputItem9});	
+	}
+
+	public static void addShapelessGregtechRecipe(ItemStack OutputItem, Object... inputItems){
+
+		for(Object whatever : inputItems){
+	        if (!(whatever instanceof ItemStack) && !(whatever instanceof String)){
+				Utils.LOG_INFO("One Input item was not an ItemStack of an OreDict String.");
+	        	return;
+	        }
+	    }
+		
+		GT_ModHandler.addShapelessCraftingRecipe(OutputItem,
+				GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE,
+				new Object[]{inputItems});
+	}
+
+	public static ItemStack getItemStackFromOreDict(String oredictName){
+		ArrayList<ItemStack> oreDictList = OreDictionary.getOres(oredictName);
+		return oreDictList.get(0);
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/wrapper/var.java b/src/Java/gtPlusPlus/core/util/wrapper/var.java
new file mode 100644
index 0000000000..d5e55bd658
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/util/wrapper/var.java
@@ -0,0 +1,67 @@
+package gtPlusPlus.core.util.wrapper;
+
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.item.UtilsItems;
+import net.minecraft.item.ItemStack;
+
+public class var{
+		
+		private ItemStack temp = null;
+		private String sanitizedName;
+		private String fqrn;
+		
+		public var(String o){
+			String t = sanitize('<', o);
+			String t2 = sanitize('>', t);
+			sanitizedName = t2;
+			o = sanitize('"', t2);
+			fqrn = o;			
+		}
+		
+		private String sanitize(char token, String input){
+			 for (int i=0;i<input.length();i++) {
+		            if (input.charAt(i) == token) {
+		            input = input.replace(input.charAt(i), ' ');
+		                Utils.LOG_WARNING("MATCH FOUND");
+		            }
+		            input = input.replaceAll(" ", "");
+			 }
+			String output = input;
+			return output;			
+		}
+		
+		public String getFQRN(){
+			String s = fqrn;
+			return s;
+		}
+		
+		public String getsanitizedName(){
+			String s = sanitizedName;
+			return s;
+		}
+		
+		private ItemStack getOreDictStack(int stackSize){
+			ItemStack v = UtilsItems.getItemStack(sanitizedName, stackSize);
+			return v;
+		}
+		
+		public ItemStack getStack(int stackSize){
+			String oreDict = "ore:";
+			if (fqrn.toLowerCase().contains(oreDict.toLowerCase())){
+				ItemStack v = getOreDictStack(stackSize);
+				return v;
+			}
+			String[] fqrnSplit = fqrn.split(":");
+			String meta = "0";
+			try {
+			if(fqrnSplit[2] != null){meta = fqrnSplit[2];}
+			temp = UtilsItems.getItemStackWithMeta(LoadedMods.MiscUtils, fqrn, fqrnSplit[1], Integer.parseInt(meta), stackSize);
+			}
+			catch (ArrayIndexOutOfBoundsException a){
+				temp = UtilsItems.getItemStackWithMeta(LoadedMods.MiscUtils, fqrn, fqrnSplit[1], Integer.parseInt(meta), stackSize);
+			}
+			return temp;			
+		}		
+		
+	}
\ No newline at end of file