+ Added the basework for Super Conductivity related machines & cabling.

> Lossless power transfer is always nice, eh?

% Refactored a few tooltips on machines.
% Refactored some classes around.

- Removed some obscure legacy code, which added a Cobblestone fueled boiler (Why?)

33 files changed, 4816 insertions, 395 deletions

diff --git a/src/Java/miscutil/core/block/base/BlockBaseModular.java b/src/Java/miscutil/core/block/base/BlockBaseModular.java
index 106eb50954..5e0bc163c2 100644
--- a/src/Java/miscutil/core/block/base/BlockBaseModular.java
+++ b/src/Java/miscutil/core/block/base/BlockBaseModular.java
@@ -28,13 +28,13 @@ public class BlockBaseModular extends BasicBlock{
 		this.setBlockName(getLocalizedName());
 		
 		if (thisBlock == BlockTypes.STANDARD){
-			LanguageRegistry.addName(this, "Block of "+unlocalizedName);
+			LanguageRegistry.addName(this, "Block of "+blockMaterial);
 		}
 		else if (thisBlock == BlockTypes.FRAME){
-			LanguageRegistry.addName(this, unlocalizedName+ " Frame Box");
+			LanguageRegistry.addName(this, blockMaterial+ " Frame Box");
 		}
 		else {
-			LanguageRegistry.addName(this, unlocalizedName);
+			LanguageRegistry.addName(this, blockMaterial);
 		}		
 		
 		//setOreDict(unlocalizedName, blockType);
diff --git a/src/Java/miscutil/core/handler/COMPAT_HANDLER.java b/src/Java/miscutil/core/handler/COMPAT_HANDLER.java
index 174b9f005e..8c408bdd4f 100644
--- a/src/Java/miscutil/core/handler/COMPAT_HANDLER.java
+++ b/src/Java/miscutil/core/handler/COMPAT_HANDLER.java
@@ -33,6 +33,7 @@ import miscutil.core.handler.registration.gregtech.GregtechRocketFuelGenerator;
 import miscutil.core.handler.registration.gregtech.GregtechSafeBlock;
 import miscutil.core.handler.registration.gregtech.GregtechSolarGenerators;
 import miscutil.core.handler.registration.gregtech.GregtechSteamCondenser;
+import miscutil.core.handler.registration.gregtech.GregtechSuperConductionPoint;
 import miscutil.core.item.ModItems;
 import miscutil.core.lib.CORE;
 import miscutil.core.lib.LoadedMods;
@@ -84,6 +85,7 @@ public class COMPAT_HANDLER {
 		GregtechConduits.run();
 		GregtechSteamCondenser.run();
 		GregtechSafeBlock.run();
+		GregtechSuperConductionPoint.run();
 		GregtechIronBlastFurnace.run();
 		GregtechIndustrialCentrifuge.run();
 		GregtechIndustrialCokeOven.run();
diff --git a/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java b/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java
index 9f5cdb943e..c8865ee02e 100644
--- a/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java
+++ b/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java
@@ -5,7 +5,7 @@ import gregtech.api.metatileentity.BaseMetaPipeEntity;
 import gregtech.api.metatileentity.BaseMetaTileEntity;
 import gregtech.api.metatileentity.BaseTileEntity;
 import miscutil.core.util.Utils;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaSafeBlockBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.machines.GregtechMetaSafeBlockBase;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.tileentity.TileEntity;
diff --git a/src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java b/src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java
deleted file mode 100644
index eae786f4aa..0000000000
--- a/src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package miscutil.core.handler.registration.gregtech;
-
-import gregtech.api.enums.ItemList;
-import gregtech.api.enums.Materials;
-import gregtech.api.enums.OreDictNames;
-import gregtech.api.enums.OrePrefixes;
-import gregtech.api.util.GT_ModHandler;
-import miscutil.core.xmod.gregtech.api.enums.GregtechItemList;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechSteelBoiler;
-import cpw.mods.fml.common.FMLLog;
-
-public class GregtechCobbleGenerator
-{
-	public static void run()
-	{
-		if (miscutil.core.lib.LoadedMods.Gregtech){
-			FMLLog.info("Registering Cobblestone Powered Engines.");
-			run1();
-		}
-		
-	}
-
-	private static void run1()
-	{
-		//Cobble Generators
-		// ItemList.Machine_Steel_Boiler.set(new GT_MetaTileEntity_Boiler_Steel(101, "boiler.steel", "High Pressure Coal Boiler").getStackForm(1L));
-		// GT_ModHandler.addCraftingRecipe(ItemList.Machine_Steel_Boiler.get(1L, new Object[0]), GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PPP", "P P", "BFB", Character.valueOf('F'), OreDictNames.craftingFurnace, Character.valueOf('P'), OrePrefixes.plate.get(Materials.Steel), Character.valueOf('B'), new ItemStack(Blocks.brick_block, 1) });
-
-		GregtechItemList.Cobble_Generator_ULV.set(new GregtechSteelBoiler(760, "CobGen.01.tier.00", "Ultra Low Voltage Cobblestone Generator", 0, "You're shit.").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_LV.set(new GregtechSteelBoiler(761, "CobGen.01.tier.01", "Low Voltage Cobblestone Generator", 1, "Still Pretty garbage, bro.").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_MV.set(new GregtechSteelBoiler(762, "CobGen.01.tier.02", "Medium Voltage Cobblestone Generator", 2, "Testy Test.").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_HV.set(new GregtechSteelBoiler(763, "CobGen.01.tier.03", "High Voltage Cobblestone Generator", 3, "").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_EV.set(new GregtechSteelBoiler(764, "CobGen.01.tier.04", "Extreme Voltage Cobblestone Generator", 4, "").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_IV.set(new GregtechSteelBoiler(765, "CobGen.01.tier.05", "Insane Voltage Cobblestone Generator", 5, "").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_LuV.set(new GregtechSteelBoiler(766, "CobGen.01.tier.06", "Ludicrous Voltage Cobblestone Generator", 6, "").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_ZPM.set(new GregtechSteelBoiler(767, "CobGen.01.tier.07", "ZPM Voltage Cobblestone Generator", 7, "").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_UV.set(new GregtechSteelBoiler(768, "CobGen.01.tier.08", "Ultimate Voltage Cobblestone Generator", 8, "").getStackForm(1L));
-		GregtechItemList.Cobble_Generator_MAX.set(new GregtechSteelBoiler(769, "CobGen.01.tier.09", "MAX Voltage Cobblestone Generator", 9, "").getStackForm(1L));
-
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_ULV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_ULV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Lead), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_LV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_LV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Tin), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_MV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_MV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.AnyCopper), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_HV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_HV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Gold), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_EV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_EV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Aluminium), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_IV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_IV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Tungsten), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_LuV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_LuV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Osmium), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_ZPM.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_ZPM, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Osmium), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_UV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_UV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Osmium), Character.valueOf('T'), OreDictNames.craftingChest });
-		GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_MAX.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_MAX, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Superconductor), Character.valueOf('T'), OreDictNames.craftingChest });
-	}
-}
diff --git a/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java b/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java
index 9c10df196c..7a70e7873b 100644
--- a/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java
+++ b/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java
@@ -7,7 +7,9 @@ import gregtech.api.enums.OrePrefixes;
 import gregtech.api.util.GT_OreDictUnificator;
 import miscutil.core.lib.LoadedMods;
 import miscutil.core.util.Utils;
+import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
 import miscutil.core.xmod.gregtech.api.metatileentity.implementations.GregtechMetaPipeEntity_Cable;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.GregtechMetaPipeEntity_SuperConductor;
 
 public class GregtechConduits {
 	/**
@@ -37,6 +39,9 @@ public class GregtechConduits {
 			wireFactory("RedstoneAlloy", 32, 30645, 1, 4, 1);
 		}
 		
+		superConductorFactory("Superconductor", 524288, 30660, 0, 0, 8);
+		superConductorFactory("VoidMetal", 512, 30661, 0, 0, 8);
+		
 	}	
 	
 	private static void wireFactory(String Material, int Voltage, int ID, long insulatedLoss, long uninsulatedLoss, long Amps){
@@ -100,4 +105,54 @@ public class GregtechConduits {
 			GT_OreDictUnificator.registerOre(OrePrefixes.cableGt12, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 10, "cable." + aMaterial.name().toLowerCase() + ".12", "12x " + aMaterial.mDefaultLocalName + " Cable", 1.0F, aMaterial, aLossInsulated, 12L * aAmperage, aVoltage, true, false).getStackForm(1L));
 		}
 	}
+	
+	private static void superConductorFactory(String Material, int Voltage, int ID, long insulatedLoss, long uninsulatedLoss, long Amps){
+		GT_Materials T = GT_Materials.valueOf(Material);
+		int V = 0;
+		if (Voltage == 8){
+			V = 0;
+		}
+		else if (Voltage == 32){
+			V = 1;
+		}
+		else if (Voltage == 128){
+			V = 2;
+		}
+		else if (Voltage == 512){
+			V = 3;
+		}
+		else if (Voltage == 2048){
+			V = 4;
+		}
+		else if (Voltage == 8196){
+			V = 5;
+		}
+		else if (Voltage == 32768){
+			V = 6;
+		}
+		else if (Voltage == 131072){
+			V = 7;
+		}
+		else if (Voltage == 524288){
+			V = 8;
+		}
+		else if (Voltage == Integer.MAX_VALUE){
+			V = 9;
+		}
+		else {
+			Utils.LOG_ERROR("Failed to set voltage on "+Material+". Invalid voltage of "+Voltage+"V set.");
+			Utils.LOG_ERROR(Material+" has defaulted to 8v.");
+			V = 0;
+		}
+		//makeWires(T, ID, 2L, 4L, 2L, GT_Values.V[V], true, false);	 
+		makeSuperConductors(T, ID, insulatedLoss, uninsulatedLoss, Amps, GT_Values.V[V], true, false);	 
+		//makeWires(T, ID, bEC ? 2L : 2L, bEC ? 4L : 4L, 2L, gregtech.api.enums.GT_Values.V[V], true, false);	 
+	}	
+	
+	private static void makeSuperConductors(GT_Materials aMaterial, int aStartID, long aLossInsulated, long aLoss, long aAmperage, long aVoltage, boolean aInsulatable, boolean aAutoInsulated)
+	{
+		Utils.LOG_WARNING("Gregtech5u Content | Registered "+aMaterial.name() +" as a new Super Conductor.");
+		GT_OreDictUnificator.registerOre(OrePrefixes.wireGt16, aMaterial, new GregtechMetaPipeEntity_SuperConductor(aStartID + 5, "wire." + aMaterial.name().toLowerCase() + ".16", "16x " + aMaterial.mDefaultLocalName + " Wire", 1.0F, aMaterial, aLoss, 16L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L));
+		
+	}
 }
diff --git a/src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java b/src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java
new file mode 100644
index 0000000000..d2434dd46f
--- /dev/null
+++ b/src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java
@@ -0,0 +1,27 @@
+package miscutil.core.handler.registration.gregtech;
+
+import miscutil.core.util.Utils;
+import miscutil.core.xmod.gregtech.api.enums.GregtechItemList;
+import miscutil.core.xmod.gregtech.common.tileentities.generators.GregtechMetaTileEntitySuperCondensor;
+
+public class GregtechSuperConductionPoint
+{
+
+
+
+	public static void run()
+	{
+		if (miscutil.core.lib.LoadedMods.Gregtech){
+			Utils.LOG_INFO("Gregtech5u Content | Registering Super Conductor Input Node.");
+			run1();
+		}
+
+	}
+
+	private static void run1()
+	{
+		//Steam Condensors
+		GregtechItemList.SuperConductorInputNode.set(new GregtechMetaTileEntitySuperCondensor(801, "superconductor.01.input.single", "Super Condensor", 3).getStackForm(1L));
+		
+	}
+}
diff --git a/src/Java/miscutil/core/item/general/ItemCloakingDevice.java b/src/Java/miscutil/core/item/general/ItemCloakingDevice.java
index 64e45f34b9..b54bb08a87 100644
--- a/src/Java/miscutil/core/item/general/ItemCloakingDevice.java
+++ b/src/Java/miscutil/core/item/general/ItemCloakingDevice.java
@@ -27,7 +27,7 @@ public class ItemCloakingDevice extends Item implements IElectricItem, IElectric
 
 	private final String unlocalizedName = "personalCloakingDevice";
 	private final ItemStack thisStack;
-	private final static int maxValueEU = 100000000;
+	private final static int maxValueEU = 8196*20*5*60;
 	protected double chargeEU = 0;
 
 	public ItemCloakingDevice(){
@@ -131,7 +131,7 @@ public class ItemCloakingDevice extends Item implements IElectricItem, IElectric
 		list.add("");			
 		list.add(EnumChatFormatting.GOLD+"IC2/EU Information"+EnumChatFormatting.GRAY);	
 		list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Transfer Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+EnumChatFormatting.GRAY +"Eu/t]");
-		list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu]");
+		list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu] ["+EnumChatFormatting.YELLOW+MathUtils.findPercentage(getCharge(stack), getMaxCharge(stack))+EnumChatFormatting.GRAY +"%]");
 		list.add(EnumChatFormatting.GRAY+"Time Remaining: ["+EnumChatFormatting.YELLOW+secondsLeft(stack)+ EnumChatFormatting.GRAY +" seconds]");
 		super.addInformation(stack, aPlayer, list, bool);
 	}
diff --git a/src/Java/miscutil/core/item/general/ItemHealingDevice.java b/src/Java/miscutil/core/item/general/ItemHealingDevice.java
index 65c0dc2626..385ab06fdd 100644
--- a/src/Java/miscutil/core/item/general/ItemHealingDevice.java
+++ b/src/Java/miscutil/core/item/general/ItemHealingDevice.java
@@ -8,6 +8,7 @@ import java.util.List;
 
 import miscutil.core.creative.AddToCreativeTab;
 import miscutil.core.lib.CORE;
+import miscutil.core.util.Utils;
 import miscutil.core.util.item.UtilsItems;
 import miscutil.core.util.math.MathUtils;
 import net.minecraft.entity.Entity;
@@ -25,7 +26,7 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI
 
 	private final String unlocalizedName = "personalHealingDevice";
 	private final ItemStack thisStack;
-	private final static int maxValueEU = 100000000;
+	private final static int maxValueEU = 1000000000;
 	protected double chargeEU = 0;
 
 	public ItemHealingDevice(){
@@ -88,18 +89,18 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI
 
 	@Override
 	public int getTier(ItemStack itemStack) {
-		return 4;
+		return 5;
 	}
 
 	@Override
 	public double getTransferLimit(ItemStack itemStack) {
-		return 8196;
+		return 32784;
 	}
 
 	@Override
 	public String getItemStackDisplayName(ItemStack p_77653_1_) {
 
-		return (EnumChatFormatting.WHITE+"Personal Healing NanoBooster"+EnumChatFormatting.GRAY);
+		return (EnumChatFormatting.BLUE+"Personal Healing NanoBooster"+EnumChatFormatting.RESET);
 	}
 
 	@Override
@@ -118,8 +119,8 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI
 	public double secondsLeft(ItemStack stack){
 		
 		double r = 0;
-		r = getCharge(stack)/(8196*20);
-		return MathUtils.decimalRounding(r);
+		r = getCharge(stack)/(1638400/4);
+		return (int) r;
 	}
 
 	@Override
@@ -130,7 +131,7 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI
 		list.add("");			
 		list.add(EnumChatFormatting.GOLD+"IC2/EU Information"+EnumChatFormatting.GRAY);	
 		list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Transfer Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+EnumChatFormatting.GRAY +"Eu/t]");
-		list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu]");
+		list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu] ["+EnumChatFormatting.YELLOW+MathUtils.findPercentage(getCharge(stack), getMaxCharge(stack))+EnumChatFormatting.GRAY +"%]");
 		list.add(EnumChatFormatting.GRAY+"Uses Remaining: ["+EnumChatFormatting.YELLOW+secondsLeft(stack)+ EnumChatFormatting.GRAY +"]");
 		super.addInformation(stack, aPlayer, list, bool);
 	}
@@ -211,11 +212,15 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI
 	@Override //TODO
 	public void onWornTick(ItemStack arg0, EntityLivingBase arg1) {
 		if (!arg1.worldObj.isRemote){
-			if (getCharge(arg0) >= 1638400){
-				if (arg1.getHealth() < arg1.getMaxHealth()-2){
-				arg1.heal(2);
+			if (getCharge(arg0) >= 1638400/4){
+				if (arg1.getHealth() < arg1.getMaxHealth()){
+					float rx = arg1.getMaxHealth()-arg1.getHealth();
+					Utils.LOG_INFO("rx:"+rx);
+				arg1.heal(rx*2);
+				discharge(arg0, (1638400/4)*rx, 6, true, true, false);
+				Utils.messagePlayer((EntityPlayer) arg1, "Your NanoBooster Whirs! Leaving you feeling stronger. It Healed "+rx+" hp.");
+				Utils.messagePlayer((EntityPlayer) arg1, "You check it's remaining uses, it has "+secondsLeft(arg0)+".");
 				}
-				discharge(arg0, 1638400, 6, true, true, false);
 			}
 		}
 	}
diff --git a/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java b/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java
index 0e66f7aae3..667c57fddc 100644
--- a/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java
+++ b/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java
@@ -82,7 +82,7 @@ public class StaballoyAxe extends ItemAxe{
 	
 	private int check(World par1World, int x, int y, int z, int xo, int yo,int zo) {
 		int f=0;
-		int o=x+z*40+y*400;
+		int o=x+z*20+y*400;
 		if (tre[o]==needcheck){
 			tre[o]=ignore;
 			Block bit = par1World.getBlock(x+xo, y+yo, z+zo);
@@ -107,18 +107,18 @@ public class StaballoyAxe extends ItemAxe{
 		boolean f;
 		for (f=true;f==true;){
 			f=false;
-			for (int y=-10;y<110;y++)
-				for(int z=0;z<40;z++)
-					for(int x=0;x<40;x++){
+			for (int y=0;y<80;y++)
+				for(int z=0;z<20;z++)
+					for(int x=0;x<20;x++){
 						int r=check(par1World,x,y,z,xo,yo,zo);
 						if (r==3) return 3;
 						if (r==2) return 2;
 						if (r==1) f=true;
 					}
 			
-			for (int y=109;y>=-10;y--)
-				for(int z=39;z>=0;z--)
-					for(int x=39;x>=0;x--){
+			for (int y=79;y>=0;y--)
+				for(int z=19;z>=0;z--)
+					for(int x=19;x>=0;x--){
 						int r=check(par1World,x,y,z,xo,yo,zo);
 						if (r==2) return 3;
 						if (r==2) return 2;
@@ -130,11 +130,11 @@ public class StaballoyAxe extends ItemAxe{
 	
 	private int check2(World par1World, int x, int y, int z, int xo, int yo,int zo) {
 		int f=0;
-		int o=x+z*40+y*400;
+		int o=x+z*20+y*400;
 		if (tre[o]==needcheck){
 			tre[o]=ignore;
 			Block bit = par1World.getBlock(x+xo, y+yo, z+zo);
-			if (bit instanceof BlockLog  || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){
+			if (bit instanceof BlockLog){
 				f=1;
 				tre[o]=harvest;
 				//if (bit instanceof BlockLog){
@@ -156,18 +156,18 @@ public class StaballoyAxe extends ItemAxe{
 		boolean f;
 		for (f=true;f==true;){
 			f=false;
-			for (int y=-10;y<110;y++)
-				for(int z=0;z<40;z++)
-					for(int x=0;x<40;x++){
+			for (int y=0;y<80;y++)
+				for(int z=0;z<20;z++)
+					for(int x=0;x<20;x++){
 						int r=check2(par1World,x,y,z,xo,yo,zo);
 						if (r==3) return 3;
 						if (r==2) return 2;
 						if (r==1) f=true;
 					}
 			
-			for (int y=109;y>=-10;y--)
-				for(int z=39;z>=0;z--)
-					for(int x=39;x>=0;x--){
+			for (int y=79;y>=0;y--)
+				for(int z=19;z>=0;z--)
+					for(int x=19;x>=0;x--){
 						int r=check2(par1World,x,y,z,xo,yo,zo);
 						if (r==2) return 3;
 						if (r==2) return 2;
@@ -178,15 +178,15 @@ public class StaballoyAxe extends ItemAxe{
 	}
 	
 	public void exploadTree(World par1World,int xo,int yo,int zo, EntityPlayer plr){
-		for (int y=-10;y<110;y++)
-			for(int z=0;z<40;z++)
-				for(int x=0;x<40;x++){
-					int o=x+z*40+y*400;
+		for (int y=0;y<80;y++)
+			for(int z=0;z<20;z++)
+				for(int x=0;x<20;x++){
+					int o=x+z*20+y*400;
 					if (tre[o]==harvest){
 						Block bit = par1World.getBlock(x+xo, y+yo, z+zo);
 						int met = par1World.getBlockMetadata(x+xo, y+yo, z+zo);
 						
-						if ((bit instanceof BlockLog)||(bit instanceof BlockLeavesBase)  || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){
+						if ((bit instanceof BlockLog)||(bit instanceof BlockLeavesBase) || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){
 							bit.harvestBlock(par1World, plr, x+xo, y+yo, z+zo,met);
 							par1World.setBlockToAir(x+xo, y+yo, z+zo);
 						}
@@ -244,7 +244,7 @@ public class StaballoyAxe extends ItemAxe{
 				}
 			}
 			
-			if (bit instanceof BlockLog  || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){
+			if (bit instanceof BlockLog || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){
 				//LoonTools.log("cutting tree @ "+x+" "+y+" "+z+" ");
 				for (int n=0;n<32000;n++) tre[n]=unchecked;
 				int met = wld.getBlockMetadata(x, y, z);
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java
index 2000a1df34..6f8935c51d 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java
@@ -97,7 +97,9 @@ public enum GregtechItemList implements GregtechItemContainer {
 	
 	
 	Food_Baked_Raisin_Bread, 
-	Industrial_SinterFurnace;
+	Industrial_SinterFurnace, 
+	
+	SuperConductorInputNode;
 
 	public static final GregtechItemList[]
 			DYE_ONLY_ITEMS = {
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java
index ba6ad6ce41..824f7c99cb 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java
@@ -308,6 +308,7 @@ public enum GregtechOrePrefixes {
 		Neutronic(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "LuV Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 6), new TC_AspectStack(TC_Aspects.MACHINA, 6))),
 		Quantum(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "ZPM Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8), new TC_AspectStack(TC_Aspects.MACHINA, 8))),
 
+		Superconductor(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 190, 240, 190, 0, "Superconductor", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeGreen, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8))),
 		
 		Staballoy(30, TextureSet.SET_ROUGH, 10.0F, 5120, 4, 1 | 2  | 16 | 32 | 64 | 128, 248, 255, 46, 0, "Staballoy", 0, 0, 1500, 2800, true, false, 1, 3, 1, Dyes.dyeGreen, 2, Arrays.asList(new MaterialStack(Materials.Titanium, 1), new MaterialStack(Materials.Uranium, 9)), Arrays.asList(new TC_AspectStack(TC_Aspects.METALLUM, 8), new TC_AspectStack(TC_Aspects.STRONTIO, 3))),
 		Bedrockium(31, TextureSet.SET_FINE, 8.0F, 8196, 3, 1 | 2 | 16 | 32 | 64 | 128, 39, 39, 39, 0, "Bedrockium", 0, 0, -1, 0, false, false, 1, 5, 1, Dyes.dyeLightGray, 2, Arrays.asList(new MaterialStack(Materials.Carbon, 63), new MaterialStack(Materials.Carbon, 56)),   Arrays.asList(new TC_AspectStack(TC_Aspects.VACUOS, 8), new TC_AspectStack(TC_Aspects.TUTAMEN, 3))),
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java b/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java
index 0cc4fc259b..0b7d80c940 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java
@@ -5,7 +5,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 
 import java.util.Iterator;
 
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaBoilerBase;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.ICrafting;
 import net.minecraft.inventory.Slot;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
index d069ff2c83..4ab969c483 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
@@ -12,7 +12,7 @@ import miscutil.core.util.Utils;
 import miscutil.core.util.math.MathUtils;
 import miscutil.core.xmod.gregtech.api.gui.CONTAINER_SteamCondenser;
 import miscutil.core.xmod.gregtech.api.gui.GUI_SteamCondenser;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaBoilerBase;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java
new file mode 100644
index 0000000000..7b6c670be4
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java
@@ -0,0 +1,239 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations;
+
+import static gregtech.api.enums.GT_Values.VN;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntityCable;
+import gregtech.api.interfaces.tileentity.IColoredTileEntity;
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import miscutil.core.lib.CORE;
+import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaPipeEntityBase_Cable;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cofh.api.energy.IEnergyReceiver;
+
+public class GregtechMetaPipeEntity_SuperConductor extends GregtechMetaPipeEntityBase_Cable implements IMetaTileEntityCable {
+	public long mTransferredAmperage = 0, mTransferredAmperageLast20 = 0, mTransferredVoltageLast20 = 0;
+
+	public final float mThickNess;
+	public final GT_Materials mMaterial;
+	public final long mCableLossPerMeter, mAmperage, mVoltage;
+	public final boolean mInsulated, mCanShock;
+	public long mRestRF;
+
+	public GregtechMetaPipeEntity_SuperConductor(int aID, String aName, String aNameRegional, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aID, aName, aNameRegional, 0, aMaterial, 0, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = 0;
+	}
+
+	public GregtechMetaPipeEntity_SuperConductor(String aName, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aName, 0, aMaterial, 0, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = 0;
+	}
+
+	@Override
+	public byte getTileEntityBaseType() {
+		return (byte)(mInsulated?9:8);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaPipeEntity_SuperConductor(mName, mThickNess, mMaterial, mCableLossPerMeter, mAmperage, mVoltage, mInsulated, mCanShock);
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, byte aColorIndex, boolean aConnected, boolean aRedstone) {
+		if (!mInsulated) return new ITexture[]					{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa)};
+		if (aConnected) {
+			float tThickNess = getThickNess();
+			if (tThickNess < 0.37F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_TINY	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.49F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_SMALL	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.74F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_MEDIUM	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.99F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_LARGE	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			return new ITexture[]								{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_HUGE	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+		}
+		return new ITexture[]									{new GT_RenderedTexture(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+	}
+
+	@Override
+	public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity aEntity) {
+		if (mCanShock && (((BaseMetaPipeEntity)getBaseMetaTileEntity()).mConnections & -128) == 0 && aEntity instanceof EntityLivingBase) GT_Utility.applyElectricityDamage((EntityLivingBase)aEntity, mTransferredVoltageLast20, mTransferredAmperageLast20);
+	}
+
+	@Override
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+		if (!mCanShock) return super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+		return AxisAlignedBB.getBoundingBox(aX+0.125D, aY+0.125D, aZ+0.125D, aX+0.875D, aY+0.875D, aZ+0.875D);
+	}
+	
+	@Override public boolean isSimpleMachine()						{return true;}
+	@Override public boolean isFacingValid(byte aFacing)			{return false;}
+	@Override public boolean isValidSlot(int aIndex)				{return true;}
+   // @Override public final boolean renderInside(byte aSide)			{return false;}
+    @Override public int getProgresstime()							{return (int)mTransferredAmperage*64;}
+    @Override public int maxProgresstime()							{return (int)mAmperage*64;}
+
+	@Override
+	public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+		if (!getBaseMetaTileEntity().getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getBaseMetaTileEntity().getCoverIDAtSide(aSide), getBaseMetaTileEntity().getCoverDataAtSide(aSide), getBaseMetaTileEntity())) return 0;
+		return transferElectricity(aSide, aVoltage, aAmperage, new ArrayList<TileEntity>(Arrays.asList((TileEntity)getBaseMetaTileEntity())));
+	}
+
+	@Override
+	public long transferElectricity(byte aSide, long aVoltage, long aAmperage, ArrayList<TileEntity> aAlreadyPassedTileEntityList) {
+		long rUsedAmperes = 0;
+		aVoltage -= mCableLossPerMeter;
+		if (aVoltage > 0) for (byte i = 0; i < 6 && aAmperage > rUsedAmperes; i++) if (i != aSide && (mConnections & (1<<i)) != 0 && getBaseMetaTileEntity().getCoverBehaviorAtSide(i).letsEnergyOut(i, getBaseMetaTileEntity().getCoverIDAtSide(i), getBaseMetaTileEntity().getCoverDataAtSide(i), getBaseMetaTileEntity())) {
+			TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(i);
+			if (!aAlreadyPassedTileEntityList.contains(tTileEntity)) {
+				aAlreadyPassedTileEntityList.add(tTileEntity);
+				if (tTileEntity instanceof IEnergyConnected) {
+					if (getBaseMetaTileEntity().getColorization() >= 0) {
+						byte tColor = ((IEnergyConnected)tTileEntity).getColorization();
+						if (tColor >= 0 && tColor != getBaseMetaTileEntity().getColorization()) continue;
+					}
+					if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable && ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(GT_Utility.getOppositeSide(i)).letsEnergyIn(GT_Utility.getOppositeSide(i), ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity))) {
+						if (((IGregTechTileEntity)tTileEntity).getTimer() > 50) rUsedAmperes += ((IMetaTileEntityCable)((IGregTechTileEntity)tTileEntity).getMetaTileEntity()).transferElectricity(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes, aAlreadyPassedTileEntityList);
+					} else {
+						rUsedAmperes += ((IEnergyConnected)tTileEntity).injectEnergyUnits(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes);
+					}
+					//        		} else if (tTileEntity instanceof IEnergySink) {
+					//            		ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					//            		if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+					//            			if (((IEnergySink)tTileEntity).demandedEnergyUnits() > 0 && ((IEnergySink)tTileEntity).injectEnergyUnits(tDirection, aVoltage) < aVoltage) rUsedAmperes++;
+					//            		}
+				} else if (tTileEntity instanceof IEnergySink) {
+					ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+						if (((IEnergySink)tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink)tTileEntity).injectEnergy(tDirection, aVoltage, aVoltage) < aVoltage) rUsedAmperes++;
+					}
+				} else if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver){
+					ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					int rfOut = (int) (aVoltage * GregTech_API.mEUtoRF / 100);
+					if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)==rfOut){
+						((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, false); rUsedAmperes++;
+					}else if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)>0){
+						if(mRestRF==0){
+							int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) rfOut, false);rUsedAmperes++;
+							mRestRF = rfOut - RFtrans; 
+						}else{
+							int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) mRestRF, false); 
+							mRestRF = mRestRF - RFtrans;
+						}
+					}
+					if(GregTech_API.mRFExplosions && ((IEnergyReceiver)tTileEntity).getMaxEnergyStored(tDirection) < rfOut * 600){
+						if(rfOut > 32 * GregTech_API.mEUtoRF / 100) this.doExplosion(rfOut);
+					}
+				}
+			}
+		}
+		mTransferredAmperage += rUsedAmperes;
+		mTransferredVoltageLast20 = Math.max(mTransferredVoltageLast20, aVoltage);
+		mTransferredAmperageLast20 = Math.max(mTransferredAmperageLast20, mTransferredAmperage);
+		if (aVoltage > mVoltage || mTransferredAmperage > mAmperage) {
+			getBaseMetaTileEntity().setToFire();
+			return aAmperage;
+		}
+		return rUsedAmperes;
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		if (aBaseMetaTileEntity.isServerSide()) {
+			mTransferredAmperage = 0;
+
+			if (aTick % 20 == 0) {
+				mTransferredVoltageLast20 = 0;
+				mTransferredAmperageLast20 = 0;
+				mConnections = 0;
+				for (byte i = 0, j = 0; i < 6; i++) {
+					j = GT_Utility.getOppositeSide(i);
+					if (aBaseMetaTileEntity.getCoverBehaviorAtSide(i).alwaysLookConnected(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyIn(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyOut(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity)) {
+						TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(i);
+						if (tTileEntity instanceof IColoredTileEntity) {
+							if (aBaseMetaTileEntity.getColorization() >= 0) {
+								byte tColor = ((IColoredTileEntity)tTileEntity).getColorization();
+								if (tColor >= 0 && tColor != aBaseMetaTileEntity.getColorization()) continue;
+							}
+						}
+						if (tTileEntity instanceof IEnergyConnected && (((IEnergyConnected)tTileEntity).inputEnergyFrom(j) || ((IEnergyConnected)tTileEntity).outputsEnergyTo(j))) {
+							mConnections |= (1<<i);
+							continue;
+						}
+						if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable) {
+							if (((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).alwaysLookConnected(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity)) || ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).letsEnergyIn(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity)) || ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).letsEnergyOut(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity))) {
+								mConnections |= (1<<i);
+								continue;
+							}
+						}
+						if (tTileEntity instanceof IEnergySink && ((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+							mConnections |= (1<<i);
+							continue;
+						}
+						if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver && ((IEnergyReceiver)tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))){
+							mConnections |= (1<<i);
+							continue;					    	
+						}					    
+						/*
+					    if (tTileEntity instanceof IEnergyEmitter && ((IEnergyEmitter)tTileEntity).emitsEnergyTo((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+				    		mConnections |= (1<<i);
+				    		continue;
+					    }*/
+					}
+				}
+			}
+		}
+	}
+
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {
+				"Max Voltage: "			+ EnumChatFormatting.GREEN	+ mVoltage + " (" + VN[GT_Utility.getTier(mVoltage)]	+ ")" + EnumChatFormatting.GRAY,
+				"Max Amperage: "		+ EnumChatFormatting.YELLOW	+ mAmperage + EnumChatFormatting.GRAY,
+				"Loss/Meter/Ampere: "	+ EnumChatFormatting.RED	+ mCableLossPerMeter + EnumChatFormatting.GRAY + " EU-Volt",
+				CORE.GT_Tooltip,
+				" ",
+				"This Wire is Lossless.",
+				"Please, adhere to cooling directions."
+		};
+	}
+
+
+	@Override
+	public float getThickNess() {
+		return mThickNess;
+	}
+
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java
index 37c57be0e6..abe5832a9e 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java
@@ -9,7 +9,7 @@ import gregtech.api.util.GT_Utility;
 import miscutil.core.lib.CORE;
 import miscutil.core.xmod.gregtech.api.gui.CONTAINER_SafeBlock;
 import miscutil.core.xmod.gregtech.api.gui.GUI_SafeBlock;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaSafeBlockBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.machines.GregtechMetaSafeBlockBase;
 import net.minecraft.entity.player.InventoryPlayer;
 
 public class GregtechMetaSafeBlock
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java
new file mode 100644
index 0000000000..0c37078646
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java
@@ -0,0 +1,297 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gregtech.api.util.GT_Utility;
+
+import java.util.Collection;
+
+import miscutil.core.lib.CORE;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless.GregtechMetaTileEntityLosslessBasicTank;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public abstract class GregtechMetaSuperConductorNodeBase extends GregtechMetaTileEntityLosslessBasicTank {
+    public GregtechMetaSuperConductorNodeBase(int aID, String aName, String aNameRegional, int aTier, String aDescription, ITexture... aTextures) {
+        super(aID, aName, aNameRegional, aTier, 3, aDescription, aTextures);
+    }
+
+    public GregtechMetaSuperConductorNodeBase(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 3, aDescription, aTextures);
+    }
+
+    @Override
+    public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+        ITexture[][][] rTextures = new ITexture[10][17][];
+        for (byte i = -1; i < 16; i++) {
+            rTextures[0][i + 1] = getFront(i);
+            rTextures[1][i + 1] = getBack(i);
+            rTextures[2][i + 1] = getBottom(i);
+            rTextures[3][i + 1] = getTop(i);
+            rTextures[4][i + 1] = getSides(i);
+            rTextures[5][i + 1] = getFrontActive(i);
+            rTextures[6][i + 1] = getBackActive(i);
+            rTextures[7][i + 1] = getBottomActive(i);
+            rTextures[8][i + 1] = getTopActive(i);
+            rTextures[9][i + 1] = getSidesActive(i);
+        }
+        return rTextures;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        return mTextures[(aActive ? 5 : 0) + (aSide == aFacing ? 0 : aSide == GT_Utility.getOppositeSide(aFacing) ? 1 : aSide == 0 ? 2 : aSide == 1 ? 3 : 4)][aColorIndex + 1];
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[]{mDescription, "Cooling Efficiency: " + getEfficiency() + "%", CORE.GT_Tooltip};
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) return true;
+        aBaseMetaTileEntity.openGUI(aPlayer);
+        return true;
+    }
+
+    public ITexture[] getFront(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBack(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBottom(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getTop(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getSides(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getFrontActive(byte aColor) {
+        return getFront(aColor);
+    }
+
+    public ITexture[] getBackActive(byte aColor) {
+        return getBack(aColor);
+    }
+
+    public ITexture[] getBottomActive(byte aColor) {
+        return getBottom(aColor);
+    }
+
+    public ITexture[] getTopActive(byte aColor) {
+        return getTop(aColor);
+    }
+
+    public ITexture[] getSidesActive(byte aColor) {
+        return getSides(aColor);
+    }
+
+    @Override
+    public boolean isFacingValid(byte aSide) {
+        return aSide > 1;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex < 2;
+    }
+    
+    @Override
+    public boolean isEnetInput() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetOutput() {
+        return true;
+    }
+
+    @Override
+    public boolean isOutputFacing(byte aSide) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+    
+    @Override
+    public long getMinimumStoredEU() {
+        return V[mTier] * 16 * mInventory.length;
+    }
+
+    @Override
+    public long maxEUStore() {
+        return V[mTier] * 64;
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUOutput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return 16;
+    }
+
+    @Override
+    public long maxAmperesOut() {
+        return 16;
+    }
+
+    @Override
+    public boolean doesFillContainers() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean doesEmptyContainers() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean canTankBeFilled() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean canTankBeEmptied() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean displaysItemStack() {
+        return true;
+    }
+
+    @Override
+    public boolean displaysStackSize() {
+        return false;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return getFuelValue(aFluid) > 0;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+    	if (getEUVar() == maxEUStore() || mFluid == null){
+    		aBaseMetaTileEntity.disableWorking();
+    	}
+    	else {
+    		aBaseMetaTileEntity.enableWorking();            		
+    	}
+        if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && aTick % 10 == 0) {
+            if (mFluid == null) {
+                if (aBaseMetaTileEntity.getUniversalEnergyStored() < maxEUOutput() + getMinimumStoredEU()) {
+                    mInventory[getStackDisplaySlot()] = null;
+                } else {
+                    if (mInventory[getStackDisplaySlot()] == null)
+                        mInventory[getStackDisplaySlot()] = new ItemStack(Blocks.fire, 1);
+                    mInventory[getStackDisplaySlot()].setStackDisplayName("Generating: " + (aBaseMetaTileEntity.getUniversalEnergyStored() - getMinimumStoredEU()) + " EU");
+                }
+            } else {            	
+                int tFuelValue = getFuelValue(mFluid), tConsumed = consumedFluidPerOperation(mFluid);
+                if (tConsumed > 0 && mFluid.amount > tConsumed) {
+                    long tFluidAmountToUse = Math.min(mFluid.amount / tConsumed, (maxEUOutput() * 20 + getMinimumStoredEU() - aBaseMetaTileEntity.getUniversalEnergyStored()));
+                    if (tFluidAmountToUse > 0 /*&& aBaseMetaTileEntity.increaseStoredEnergyUnits(tFluidAmountToUse * tFuelValue, true)*/)
+                        mFluid.amount -= tFluidAmountToUse * tConsumed;
+                }
+            }
+            if (mInventory[getInputSlot()] != null && aBaseMetaTileEntity.getUniversalEnergyStored() < (maxEUOutput() * 20 + getMinimumStoredEU()) && GT_Utility.getFluidForFilledItem(mInventory[getInputSlot()], true) == null) {
+                int tFuelValue = getFuelValue(mInventory[getInputSlot()]);
+                if (tFuelValue >= 0) {
+                    ItemStack tEmptyContainer = getEmptyContainer(mInventory[getInputSlot()]);
+                    if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), tEmptyContainer)) {
+                        //aBaseMetaTileEntity.increaseStoredEnergyUnits(tFuelValue, true);
+                        aBaseMetaTileEntity.decrStackSize(getInputSlot(), 1);
+                    }
+                }
+            }
+        }
+
+        if (aBaseMetaTileEntity.isServerSide())
+            aBaseMetaTileEntity.setActive(aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.getUniversalEnergyStored() >= maxEUOutput() + getMinimumStoredEU());
+    }
+
+    public abstract GT_Recipe_Map getRecipes();
+
+    public abstract int getEfficiency();
+
+    public int consumedFluidPerOperation(FluidStack aLiquid) {
+        return 1;
+    }
+
+    public int getFuelValue(FluidStack aLiquid) {
+        if (aLiquid == null || getRecipes() == null) return 0;
+        FluidStack tLiquid;
+        Collection<GT_Recipe> tRecipeList = getRecipes().mRecipeList;
+        if (tRecipeList != null) for (GT_Recipe tFuel : tRecipeList)
+            if ((tLiquid = GT_Utility.getFluidForFilledItem(tFuel.getRepresentativeInput(0), true)) != null)
+                if (aLiquid.isFluidEqual(tLiquid))
+                	return 0;
+                    //return (int) (((long) tFuel.mSpecialValue * getEfficiency() * consumedFluidPerOperation(tLiquid)) / 100);
+        return 0;
+    }
+
+    public int getFuelValue(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack) || getRecipes() == null) return 0;
+        GT_Recipe tFuel = getRecipes().findRecipe(getBaseMetaTileEntity(), false, Long.MAX_VALUE, null, aStack);
+        if (tFuel != null)
+        	return 0;
+        	//return (int) ((tFuel.mSpecialValue * 1000L * getEfficiency()) / 100);
+        return 0;
+    }
+
+    public ItemStack getEmptyContainer(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack) || getRecipes() == null) return null;
+        GT_Recipe tFuel = getRecipes().findRecipe(getBaseMetaTileEntity(), false, Long.MAX_VALUE, null, aStack);
+        if (tFuel != null) return GT_Utility.copy(tFuel.getOutput(0));
+        return GT_Utility.getContainerItem(aStack, true);
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack) && (getFuelValue(aStack) > 0 || getFuelValue(GT_Utility.getFluidForFilledItem(aStack, true)) > 0);
+    }
+
+    @Override
+    public int getCapacity() {
+        return 16000;
+    }
+
+    @Override
+    public int getTankPressure() {
+        return -100;
+    }
+    
+    
+}
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java
new file mode 100644
index 0000000000..901dec8457
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java
@@ -0,0 +1,291 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
+
+import static gregtech.api.enums.GT_Values.VN;
+import gregtech.GT_Mod;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntityCable;
+import gregtech.api.interfaces.tileentity.IColoredTileEntity;
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.MetaPipeEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cofh.api.energy.IEnergyReceiver;
+
+public class GregtechMetaPipeEntityBase_Cable extends MetaPipeEntity implements IMetaTileEntityCable {
+    public final float mThickNess;
+    public final GT_Materials mMaterial;
+    public final long mCableLossPerMeter, mAmperage, mVoltage;
+    public final boolean mInsulated, mCanShock;
+    public long mTransferredAmperage = 0, mTransferredAmperageLast20 = 0, mTransferredVoltageLast20 = 0;
+    public long mRestRF;
+    public short mOverheat;
+
+    public GregtechMetaPipeEntityBase_Cable(int aID, String aName, String aNameRegional, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+        super(aID, aName, aNameRegional, 0);
+        mThickNess = aThickNess;
+        mMaterial = aMaterial;
+        mAmperage = aAmperage;
+        mVoltage = aVoltage;
+        mInsulated = aInsulated;
+        mCanShock = aCanShock;
+        mCableLossPerMeter = aCableLossPerMeter;
+    }
+
+    public GregtechMetaPipeEntityBase_Cable(String aName, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+        super(aName, 0);
+        mThickNess = aThickNess;
+        mMaterial = aMaterial;
+        mAmperage = aAmperage;
+        mVoltage = aVoltage;
+        mInsulated = aInsulated;
+        mCanShock = aCanShock;
+        mCableLossPerMeter = aCableLossPerMeter;
+    }
+
+    @Override
+    public byte getTileEntityBaseType() {
+        return (byte) (mInsulated ? 9 : 8);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaPipeEntityBase_Cable(mName, mThickNess, mMaterial, mCableLossPerMeter, mAmperage, mVoltage, mInsulated, mCanShock);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, byte aColorIndex, boolean aConnected, boolean aRedstone) {
+        if (!mInsulated)
+            return new ITexture[]{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa)};
+        if (aConnected) {
+            float tThickNess = getThickNess();
+            if (tThickNess < 0.37F)
+                return new ITexture[]{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_TINY, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+            if (tThickNess < 0.49F)
+                return new ITexture[]{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_SMALL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+            if (tThickNess < 0.74F)
+                return new ITexture[]{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_MEDIUM, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+            if (tThickNess < 0.99F)
+                return new ITexture[]{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_LARGE, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+            return new ITexture[]{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_HUGE, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+        }
+        return new ITexture[]{new GT_RenderedTexture(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity aEntity) {
+        if (mCanShock && (((BaseMetaPipeEntity) getBaseMetaTileEntity()).mConnections & -128) == 0 && aEntity instanceof EntityLivingBase)
+            GT_Utility.applyElectricityDamage((EntityLivingBase) aEntity, mTransferredVoltageLast20, mTransferredAmperageLast20);
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        if (!mCanShock) return super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+        return AxisAlignedBB.getBoundingBox(aX + 0.125D, aY + 0.125D, aZ + 0.125D, aX + 0.875D, aY + 0.875D, aZ + 0.875D);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return true;
+    }
+
+    @Override
+    public final boolean renderInside(byte aSide) {
+        return false;
+    }
+
+    @Override
+    public int getProgresstime() {
+        return (int) mTransferredAmperage * 64;
+    }
+
+    @Override
+    public int maxProgresstime() {
+        return (int) mAmperage * 64;
+    }
+
+    @Override
+    public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+        if (!getBaseMetaTileEntity().getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getBaseMetaTileEntity().getCoverIDAtSide(aSide), getBaseMetaTileEntity().getCoverDataAtSide(aSide), getBaseMetaTileEntity()))
+            return 0;
+        return transferElectricity(aSide, aVoltage, aAmperage, new ArrayList<TileEntity>(Arrays.asList((TileEntity) getBaseMetaTileEntity())));
+    }
+
+    @Override
+    public long transferElectricity(byte aSide, long aVoltage, long aAmperage, ArrayList<TileEntity> aAlreadyPassedTileEntityList) {
+        long rUsedAmperes = 0;
+        aVoltage -= mCableLossPerMeter;
+        if (aVoltage > 0) for (byte i = 0; i < 6 && aAmperage > rUsedAmperes; i++)
+            if (i != aSide && (mConnections & (1 << i)) != 0 && getBaseMetaTileEntity().getCoverBehaviorAtSide(i).letsEnergyOut(i, getBaseMetaTileEntity().getCoverIDAtSide(i), getBaseMetaTileEntity().getCoverDataAtSide(i), getBaseMetaTileEntity())) {
+                TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(i);
+                if (!aAlreadyPassedTileEntityList.contains(tTileEntity)) {
+                    aAlreadyPassedTileEntityList.add(tTileEntity);
+                    if (tTileEntity instanceof IEnergyConnected) {
+                        if (getBaseMetaTileEntity().getColorization() >= 0) {
+                            byte tColor = ((IEnergyConnected) tTileEntity).getColorization();
+                            if (tColor >= 0 && tColor != getBaseMetaTileEntity().getColorization()) continue;
+                        }
+                        if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable && ((IGregTechTileEntity) tTileEntity).getCoverBehaviorAtSide(GT_Utility.getOppositeSide(i)).letsEnergyIn(GT_Utility.getOppositeSide(i), ((IGregTechTileEntity) tTileEntity).getCoverIDAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity) tTileEntity).getCoverDataAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity) tTileEntity))) {
+                            if (((IGregTechTileEntity) tTileEntity).getTimer() > 50)
+                                rUsedAmperes += ((IMetaTileEntityCable) ((IGregTechTileEntity) tTileEntity).getMetaTileEntity()).transferElectricity(GT_Utility.getOppositeSide(i), aVoltage, aAmperage - rUsedAmperes, aAlreadyPassedTileEntityList);
+                        } else {
+                            rUsedAmperes += ((IEnergyConnected) tTileEntity).injectEnergyUnits(GT_Utility.getOppositeSide(i), aVoltage, aAmperage - rUsedAmperes);
+                        }
+//        		} else if (tTileEntity instanceof IEnergySink) {
+//            		ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+//            		if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+//            			if (((IEnergySink)tTileEntity).demandedEnergyUnits() > 0 && ((IEnergySink)tTileEntity).injectEnergyUnits(tDirection, aVoltage) < aVoltage) rUsedAmperes++;
+//            		}
+                    } else if (tTileEntity instanceof IEnergySink) {
+                        ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+                        if (((IEnergySink) tTileEntity).acceptsEnergyFrom((TileEntity) getBaseMetaTileEntity(), tDirection)) {
+                            if (((IEnergySink) tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink) tTileEntity).injectEnergy(tDirection, aVoltage, aVoltage) < aVoltage)
+                                rUsedAmperes++;
+                        }
+                    } else if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver) {
+                        ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+                        int rfOut = (int) (aVoltage * GregTech_API.mEUtoRF / 100);
+                        if (((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, true) == rfOut) {
+                            ((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, false);
+                            rUsedAmperes++;
+                        } else if (((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, true) > 0) {
+                            if (mRestRF == 0) {
+                                int RFtrans = ((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, (int) rfOut, false);
+                                rUsedAmperes++;
+                                mRestRF = rfOut - RFtrans;
+                            } else {
+                                int RFtrans = ((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, (int) mRestRF, false);
+                                mRestRF = mRestRF - RFtrans;
+                            }
+                        }
+                        if (GregTech_API.mRFExplosions && ((IEnergyReceiver) tTileEntity).getMaxEnergyStored(tDirection) < rfOut * 600) {
+                            if (rfOut > 32 * GregTech_API.mEUtoRF / 100) this.doExplosion(rfOut);
+                        }
+                    }
+                }
+            }
+        mTransferredAmperage += rUsedAmperes;
+        mTransferredVoltageLast20 = Math.max(mTransferredVoltageLast20, aVoltage);
+        mTransferredAmperageLast20 = Math.max(mTransferredAmperageLast20, mTransferredAmperage);
+        if (aVoltage > mVoltage || mTransferredAmperage > mAmperage) {
+        	if(mOverheat>GT_Mod.gregtechproxy.mWireHeatingTicks * 100){
+        	   getBaseMetaTileEntity().setToFire();}else{mOverheat +=100;}
+            return aAmperage;
+        }
+        return rUsedAmperes;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            mTransferredAmperage = 0;
+            if(mOverheat>0)mOverheat--;
+     
+            if (aTick % 20 == 0) {
+                mTransferredVoltageLast20 = 0;
+                mTransferredAmperageLast20 = 0;
+                mConnections = 0;
+                for (byte i = 0, j = 0; i < 6; i++) {
+                    j = GT_Utility.getOppositeSide(i);
+                    if (aBaseMetaTileEntity.getCoverBehaviorAtSide(i).alwaysLookConnected(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyIn(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyOut(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity)) {
+                        TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(i);
+                        if (tTileEntity instanceof IColoredTileEntity) {
+                            if (aBaseMetaTileEntity.getColorization() >= 0) {
+                                byte tColor = ((IColoredTileEntity) tTileEntity).getColorization();
+                                if (tColor >= 0 && tColor != aBaseMetaTileEntity.getColorization()) continue;
+                            }
+                        }
+                        if (tTileEntity instanceof IEnergyConnected && (((IEnergyConnected) tTileEntity).inputEnergyFrom(j) || ((IEnergyConnected) tTileEntity).outputsEnergyTo(j))) {
+                            mConnections |= (1 << i);
+                            continue;
+                        }
+                        if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable) {
+                            if (((IGregTechTileEntity) tTileEntity).getCoverBehaviorAtSide(j).alwaysLookConnected(j, ((IGregTechTileEntity) tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity) tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity) tTileEntity)) || ((IGregTechTileEntity) tTileEntity).getCoverBehaviorAtSide(j).letsEnergyIn(j, ((IGregTechTileEntity) tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity) tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity) tTileEntity)) || ((IGregTechTileEntity) tTileEntity).getCoverBehaviorAtSide(j).letsEnergyOut(j, ((IGregTechTileEntity) tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity) tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity) tTileEntity))) {
+                                mConnections |= (1 << i);
+                                continue;
+                            }
+                        }
+                        if (tTileEntity instanceof IEnergySink && ((IEnergySink) tTileEntity).acceptsEnergyFrom((TileEntity) aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+                            mConnections |= (1 << i);
+                            continue;
+                        }
+                        if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver && ((IEnergyReceiver) tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))) {
+                            mConnections |= (1 << i);
+                            continue;
+                        }
+                        /*
+					    if (tTileEntity instanceof IEnergyEmitter && ((IEnergyEmitter)tTileEntity).emitsEnergyTo((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+				    		mConnections |= (1<<i);
+				    		continue;
+					    }*/
+                    }
+                }
+            }
+        }
+    }
+
+    @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;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[]{
+                "Max Voltage: " + EnumChatFormatting.GREEN + mVoltage + " (" + VN[GT_Utility.getTier(mVoltage)] + ")" + EnumChatFormatting.GRAY,
+                "Max Amperage: " + EnumChatFormatting.YELLOW + mAmperage + EnumChatFormatting.GRAY,
+                "Loss/Meter/Ampere: " + EnumChatFormatting.RED + mCableLossPerMeter + EnumChatFormatting.GRAY + " EU-Volt"
+        };
+    }
+
+    @Override
+    public float getThickNess() {
+        return mThickNess;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        //
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        //
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java
index 02962a6dcb..8a1dbf78b1 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java
@@ -3,7 +3,7 @@ package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
 import static gregtech.api.enums.GT_Values.GT;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.metatileentity.MetaTileEntity;
-import net.minecraft.util.EnumChatFormatting;
+import miscutil.core.lib.CORE;
 
 public abstract class GregtechMetaTileEntity extends MetaTileEntity {
 	/**
@@ -55,7 +55,7 @@ public abstract class GregtechMetaTileEntity extends MetaTileEntity {
     
 	@Override
 	public String[] getDescription() {
-		return new String[] {mDescription, "Added by: "	+ EnumChatFormatting.DARK_GREEN+"Alkalus"};
+		return new String[] {mDescription, CORE.GT_Tooltip};
 	}
 	
 	/**
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java
deleted file mode 100644
index 5d017024e9..0000000000
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java
+++ /dev/null
@@ -1,290 +0,0 @@
-package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
-
-import gregtech.api.enums.Dyes;
-import gregtech.api.enums.Materials;
-import gregtech.api.enums.OrePrefixes;
-import gregtech.api.enums.Textures;
-import gregtech.api.interfaces.ITexture;
-import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.metatileentity.MetaTileEntity;
-import gregtech.api.objects.GT_RenderedTexture;
-import gregtech.api.util.GT_ModHandler;
-import gregtech.api.util.GT_OreDictUnificator;
-import gregtech.common.gui.GT_Container_Boiler;
-import gregtech.common.gui.GT_GUIContainer_Boiler;
-import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidHandler;
-
-public class GregtechSteelBoiler
-  extends GT_MetaTileEntity_Boiler
-{
-  public GregtechSteelBoiler(int aID, String aName, String aNameRegional, int aTier, String aDescription)
-  {
-    super(aID, aName, aNameRegional, "Put it to good use!", new ITexture[0]);
-  }
-  
-  public GregtechSteelBoiler(String aName, int aTier, String aDescription, ITexture[][][] aTextures)
-  {
-    super(aName, aTier, aDescription, aTextures);
-  }
-  
-  public ITexture[][][] getTextureSet(ITexture[] aTextures)
-  {
-    ITexture[][][] rTextures = new ITexture[5][17][];
-    for (byte i = -1; i < 16; i = (byte)(i + 1))
-    {ITexture[] tmp0 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) };
-      rTextures[0][(i + 1)] = tmp0;
-      ITexture[] tmp1 ={ new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_SIDE)};
-rTextures[1][(i + 1)] = tmp1;
-      ITexture[] tmp2 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) };
-rTextures[2][(i + 1)] = tmp2;
-      ITexture[] tmp4 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT) };
-rTextures[3][(i + 1)] = tmp4;
-     ITexture[] tmp5 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT_ACTIVE) };
-rTextures[4][(i + 1)] = tmp5;
-    }
-    return rTextures;
-  }
-  
-  public int maxProgresstime()
-  {
-    return 1000;
-  }
-  
-  public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity)
-  {
-    return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 32000);
-  }
-  
-  public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity)
-  {
-    return new GT_GUIContainer_Boiler(aPlayerInventory, aBaseMetaTileEntity, "SteelBoiler.png", 32000);
-  }
-  
-  public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity)
-  {
-    return new GregtechSteelBoiler(this.mName, this.mTier, this.mDescription, this.mTextures);
-  }
-  
-  public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick)
-  {
-    if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L))
-    {
-      if (this.mTemperature <= 20)
-      {
-        this.mTemperature = 20;
-        this.mLossTimer = 0;
-      }
-      if (++this.mLossTimer > 40)
-      {
-        this.mTemperature -= 1;
-        this.mLossTimer = 0;
-      }
-      for (byte i = 1; (this.mSteam != null) && (i < 6); i = (byte)(i + 1)) {
-        if (i != aBaseMetaTileEntity.getFrontFacing())
-        {
-          IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i);
-          if (tTileEntity != null)
-          {
-            FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false);
-            if (tDrained != null)
-            {
-              int tFilledAmount = tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), tDrained, false);
-              if (tFilledAmount > 0) {
-                tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), tFilledAmount, true), true);
-              }
-            }
-          }
-        }
-      }
-      if (aTick % 10L == 0L) {
-        if (this.mTemperature > 100)
-        {
-          if ((this.mFluid == null) || (!GT_ModHandler.isWater(this.mFluid)) || (this.mFluid.amount <= 0))
-          {
-            this.mHadNoWater = true;
-          }
-          else
-          {
-            if (this.mHadNoWater)
-            {
-              aBaseMetaTileEntity.doExplosion(2048L);
-              return;
-            }
-            this.mFluid.amount -= 1;
-            if (this.mSteam == null) {
-              this.mSteam = GT_ModHandler.getSteam(150L);
-            } else if (GT_ModHandler.isSteam(this.mSteam)) {
-              this.mSteam.amount += 150;
-            } else {
-              this.mSteam = GT_ModHandler.getSteam(150L);
-            }
-          }
-        }
-        else {
-          this.mHadNoWater = false;
-        }
-      }
-      if ((this.mSteam != null) && 
-        (this.mSteam.amount > 32000))
-      {
-        sendSound((byte)1);
-        this.mSteam.amount = 24000;
-      }
-      if ((this.mProcessingEnergy <= 0) && (aBaseMetaTileEntity.isAllowedToWork()) && 
-        (this.mInventory[2] != null)) {
-        if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Coal))))
-        {
-          this.mProcessingEnergy += 160;
-          aBaseMetaTileEntity.decrStackSize(2, 1);
-          if (aBaseMetaTileEntity.getRandomNumber(3) == 0) {
-            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L));
-          }
-        }
-        else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Charcoal))))
-        {
-          this.mProcessingEnergy += 160;
-          aBaseMetaTileEntity.decrStackSize(2, 1);
-          if (aBaseMetaTileEntity.getRandomNumber(3) == 0) {
-            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L));
-          }
-        }
-        else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], "fuelCoke"))
-        {
-          this.mProcessingEnergy += 640;
-          aBaseMetaTileEntity.decrStackSize(2, 1);
-          if (aBaseMetaTileEntity.getRandomNumber(2) == 0) {
-            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L));
-          }
-        }
-        else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Lignite))))
-        {
-          this.mProcessingEnergy += 40;
-          aBaseMetaTileEntity.decrStackSize(2, 1);
-          if (aBaseMetaTileEntity.getRandomNumber(8) == 0) {
-            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L));
-          }
-        }
-      }
-      if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L))
-      {
-        this.mProcessingEnergy -= 2;
-        this.mTemperature += 1;
-      }
-      aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0);
-    }
-  }
-
-@Override
-public int[] getAccessibleSlotsFromSide(int p_94128_1_) {
-	// TODO Auto-generated method stub
-	return null;
-}
-
-@Override
-public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_,
-		int p_102007_3_) {
-	// TODO Auto-generated method stub
-	return false;
-}
-
-@Override
-public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_,
-		int p_102008_3_) {
-	// TODO Auto-generated method stub
-	return false;
-}
-
-@Override
-public int getSizeInventory() {
-	// TODO Auto-generated method stub
-	return 0;
-}
-
-@Override
-public ItemStack getStackInSlot(int p_70301_1_) {
-	// TODO Auto-generated method stub
-	return null;
-}
-
-@Override
-public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_) {
-	// TODO Auto-generated method stub
-	return null;
-}
-
-@Override
-public ItemStack getStackInSlotOnClosing(int p_70304_1_) {
-	// TODO Auto-generated method stub
-	return null;
-}
-
-@Override
-public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) {
-	// TODO Auto-generated method stub
-	
-}
-
-@Override
-public String getInventoryName() {
-	// TODO Auto-generated method stub
-	return null;
-}
-
-@Override
-public boolean hasCustomInventoryName() {
-	// TODO Auto-generated method stub
-	return false;
-}
-
-@Override
-public int getInventoryStackLimit() {
-	// TODO Auto-generated method stub
-	return 0;
-}
-
-@Override
-public void markDirty() {
-	// TODO Auto-generated method stub
-	
-}
-
-@Override
-public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
-	// TODO Auto-generated method stub
-	return false;
-}
-
-@Override
-public void openInventory() {
-	// TODO Auto-generated method stub
-	
-}
-
-@Override
-public void closeInventory() {
-	// TODO Auto-generated method stub
-	
-}
-
-@Override
-public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) {
-	// TODO Auto-generated method stub
-	return false;
-}
-}
-
-
-
-/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar
-
- * Qualified Name:     gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Steel
-
- * JD-Core Version:    0.7.0.1
-
- */
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechMetaBoilerBase.java
index 40ab96469b..b38bd019be 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechMetaBoilerBase.java
@@ -1,4 +1,4 @@
-package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators;
 
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.Materials;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaSolarGenerator.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechMetaSolarGenerator.java
index 1985a985dd..23ab350f7c 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaSolarGenerator.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechMetaSolarGenerator.java
@@ -1,4 +1,4 @@
-package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators;
 
 import static gregtech.api.enums.GT_Values.V;
 import gregtech.api.enums.Textures;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechRocketFuelGeneratorBase.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechRocketFuelGeneratorBase.java
index de35f79403..75f771ff38 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechRocketFuelGeneratorBase.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechRocketFuelGeneratorBase.java
@@ -1,4 +1,4 @@
-package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators;
 
 import static gregtech.api.enums.GT_Values.V;
 import gregtech.api.enums.Textures;
@@ -11,10 +11,10 @@ import gregtech.api.util.GT_Utility;
 
 import java.util.Collection;
 
+import miscutil.core.lib.CORE;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumChatFormatting;
 import net.minecraftforge.fluids.FluidStack;
 
 public abstract class GregtechRocketFuelGeneratorBase extends GT_MetaTileEntity_BasicTank {
@@ -49,10 +49,10 @@ public abstract class GregtechRocketFuelGeneratorBase extends GT_MetaTileEntity_
         return mTextures[(aActive ? 5 : 0) + (aSide == aFacing ? 0 : aSide == GT_Utility.getOppositeSide(aFacing) ? 1 : aSide == 0 ? 2 : aSide == 1 ? 3 : 4)][aColorIndex + 1];
     }
 
-    String formattedName = "Added by: "	+ EnumChatFormatting.DARK_GREEN+"Alkalus";
+    
     @Override
     public String[] getDescription() {
-        return new String[]{mDescription, "Fuel Efficiency: " + getEfficiency() + "%", formattedName};
+        return new String[]{mDescription, "Fuel Efficiency: " + getEfficiency() + "%", CORE.GT_Tooltip};
     }
     
 
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechBaseMetaTileEntityLossless.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechBaseMetaTileEntityLossless.java
new file mode 100644
index 0000000000..d0ac4ab204
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechBaseMetaTileEntityLossless.java
@@ -0,0 +1,1849 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless;
+
+import static gregtech.api.enums.GT_Values.NW;
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.GT_Mod;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.net.GT_Packet_TileEntity;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_CoverBehavior;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import ic2.api.Direction;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockFire;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.Packet;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.EnumSkyBlock;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * This is the main TileEntity for EVERYTHING.
+ */
+public class GregtechBaseMetaTileEntityLossless extends BaseTileEntity implements IGregTechTileEntity {
+    private final GT_CoverBehavior[] mCoverBehaviors = new GT_CoverBehavior[]{GregTech_API.sNoBehavior, GregTech_API.sNoBehavior, GregTech_API.sNoBehavior, GregTech_API.sNoBehavior, GregTech_API.sNoBehavior, GregTech_API.sNoBehavior};
+    protected MetaTileEntity mMetaTileEntity;
+    protected long mStoredEnergy = 0, mStoredSteam = 0;
+    protected int mAverageEUInputIndex = 0, mAverageEUOutputIndex = 0;
+    protected boolean mReleaseEnergy = false;
+    protected int[] mAverageEUInput = new int[]{0, 0, 0, 0, 0}, mAverageEUOutput = new int[]{0, 0, 0, 0, 0};
+    private boolean[] mActiveEUInputs = new boolean[]{false, false, false, false, false, false}, mActiveEUOutputs = new boolean[]{false, false, false, false, false, false};
+    private byte[] mSidedRedstone = new byte[]{15, 15, 15, 15, 15, 15};
+    private int[] mCoverSides = new int[]{0, 0, 0, 0, 0, 0}, mCoverData = new int[]{0, 0, 0, 0, 0, 0}, mTimeStatistics = new int[GregTech_API.TICKS_FOR_LAG_AVERAGING];
+    private boolean mHasEnoughEnergy = true, mRunningThroughTick = false, mInputDisabled = false, mOutputDisabled = false, mMuffler = false, mLockUpgrade = false, mActive = false, mRedstone = false, mWorkUpdate = false, mSteamConverter = false, mInventoryChanged = false, mWorks = true, mNeedsUpdate = true, mNeedsBlockUpdate = true, mSendClientData = false, oRedstone = false;
+    private byte mColor = 0, oColor = 0, mStrongRedstone = 0, oRedstoneData = 63, oTextureData = 0, oUpdateData = 0, oLightValueClient = -1, oLightValue = -1, mLightValue = 0, mOtherUpgrades = 0, mFacing = 0, oFacing = 0, mWorkData = 0;
+    private int mDisplayErrorCode = 0, oX = 0, oY = 0, oZ = 0, mTimeStatisticsIndex = 0, mLagWarningCount = 0;
+    private short mID = 0;
+    private long mTickTimer = 0, oOutput = 0, mAcceptedAmperes = Long.MAX_VALUE;
+    private String mOwnerName = "";
+    private NBTTagCompound mRecipeStuff = new NBTTagCompound();
+
+    public GregtechBaseMetaTileEntityLossless() {
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound aNBT) {
+        try {
+            super.writeToNBT(aNBT);
+        } catch (Throwable e) {
+            GT_Log.err.println("Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+            e.printStackTrace(GT_Log.err);
+        }
+        try {
+            aNBT.setInteger("mID", mID);
+            aNBT.setLong("mStoredSteam", mStoredSteam);
+            aNBT.setLong("mStoredEnergy", mStoredEnergy);
+            aNBT.setIntArray("mCoverData", mCoverData);
+            aNBT.setIntArray("mCoverSides", mCoverSides);
+            aNBT.setByteArray("mRedstoneSided", mSidedRedstone);
+            aNBT.setByte("mColor", mColor);
+            aNBT.setByte("mLightValue", mLightValue);
+            aNBT.setByte("mOtherUpgrades", mOtherUpgrades);
+            aNBT.setByte("mWorkData", mWorkData);
+            aNBT.setByte("mStrongRedstone", mStrongRedstone);
+            aNBT.setShort("mFacing", mFacing);
+            aNBT.setString("mOwnerName", mOwnerName);
+            aNBT.setBoolean("mLockUpgrade", mLockUpgrade);
+            aNBT.setBoolean("mMuffler", mMuffler);
+            aNBT.setBoolean("mSteamConverter", mSteamConverter);
+            aNBT.setBoolean("mActive", mActive);
+            aNBT.setBoolean("mRedstone", mRedstone);
+            aNBT.setBoolean("mWorks", !mWorks);
+            aNBT.setBoolean("mInputDisabled", mInputDisabled);
+            aNBT.setBoolean("mOutputDisabled", mOutputDisabled);
+            aNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+        } catch (Throwable e) {
+            GT_Log.err.println("Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+            e.printStackTrace(GT_Log.err);
+        }
+        try {
+            if (hasValidMetaTileEntity()) {
+                NBTTagList tItemList = new NBTTagList();
+                for (int i = 0; i < mMetaTileEntity.getRealInventory().length; i++) {
+                    ItemStack tStack = mMetaTileEntity.getRealInventory()[i];
+                    if (tStack != null) {
+                        NBTTagCompound tTag = new NBTTagCompound();
+                        tTag.setInteger("IntSlot", i);
+                        tStack.writeToNBT(tTag);
+                        tItemList.appendTag(tTag);
+                    }
+                }
+                aNBT.setTag("Inventory", tItemList);
+
+                try {
+                    mMetaTileEntity.saveNBTData(aNBT);
+                } catch (Throwable e) {
+                    GT_Log.err.println("Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+                    e.printStackTrace(GT_Log.err);
+                }
+            }
+        } catch (Throwable e) {
+            GT_Log.err.println("Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound aNBT) {
+        super.readFromNBT(aNBT);
+        setInitialValuesAsNBT(aNBT, (short) 0);
+    }
+
+    @Override
+    public void setInitialValuesAsNBT(NBTTagCompound aNBT, short aID) {
+        if (aNBT == null) {
+            if (aID > 0) mID = aID;
+            else mID = mID > 0 ? mID : 0;
+            if (mID != 0) createNewMetatileEntity(mID);
+            mSidedRedstone = (hasValidMetaTileEntity() && mMetaTileEntity.hasSidedRedstoneOutputBehavior() ? new byte[]{0, 0, 0, 0, 0, 0} : new byte[]{15, 15, 15, 15, 15, 15});
+        } else {
+            if (aID <= 0) mID = (short) aNBT.getInteger("mID");
+            else mID = aID;
+            mStoredSteam = aNBT.getInteger("mStoredSteam");
+            mStoredEnergy = aNBT.getInteger("mStoredEnergy");
+            mColor = aNBT.getByte("mColor");
+            mLightValue = aNBT.getByte("mLightValue");
+            mWorkData = aNBT.getByte("mWorkData");
+            mStrongRedstone = aNBT.getByte("mStrongRedstone");
+            mFacing = oFacing = (byte) aNBT.getShort("mFacing");
+            mOwnerName = aNBT.getString("mOwnerName");
+            mLockUpgrade = aNBT.getBoolean("mLockUpgrade");
+            mMuffler = aNBT.getBoolean("mMuffler");
+            mSteamConverter = aNBT.getBoolean("mSteamConverter");
+            mActive = aNBT.getBoolean("mActive");
+            mRedstone = aNBT.getBoolean("mRedstone");
+            mWorks = !aNBT.getBoolean("mWorks");
+            mInputDisabled = aNBT.getBoolean("mInputDisabled");
+            mOutputDisabled = aNBT.getBoolean("mOutputDisabled");
+            mOtherUpgrades = (byte) (aNBT.getByte("mOtherUpgrades") + aNBT.getByte("mBatteries") + aNBT.getByte("mLiBatteries"));
+            mCoverSides = aNBT.getIntArray("mCoverSides");
+            mCoverData = aNBT.getIntArray("mCoverData");
+            mSidedRedstone = aNBT.getByteArray("mRedstoneSided");
+            mRecipeStuff = aNBT.getCompoundTag("GT.CraftingComponents");
+
+            if (mCoverData.length != 6) mCoverData = new int[]{0, 0, 0, 0, 0, 0};
+            if (mCoverSides.length != 6) mCoverSides = new int[]{0, 0, 0, 0, 0, 0};
+            if (mSidedRedstone.length != 6)
+                if (hasValidMetaTileEntity() && mMetaTileEntity.hasSidedRedstoneOutputBehavior())
+                    mSidedRedstone = new byte[]{0, 0, 0, 0, 0, 0};
+                else mSidedRedstone = new byte[]{15, 15, 15, 15, 15, 15};
+
+            for (byte i = 0; i < 6; i++) mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+
+            if (mID != 0 && createNewMetatileEntity(mID)) {
+                NBTTagList tItemList = aNBT.getTagList("Inventory", 10);
+                for (int i = 0; i < tItemList.tagCount(); i++) {
+                    NBTTagCompound tTag = tItemList.getCompoundTagAt(i);
+                    int tSlot = tTag.getInteger("IntSlot");
+                    if (tSlot >= 0 && tSlot < mMetaTileEntity.getRealInventory().length) {
+                        mMetaTileEntity.getRealInventory()[tSlot] = GT_Utility.loadItem(tTag);
+                    }
+                }
+
+                try {
+                    mMetaTileEntity.loadNBTData(aNBT);
+                } catch (Throwable e) {
+                    GT_Log.err.println("Encountered Exception while loading MetaTileEntity, the Server should've crashed now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+                    e.printStackTrace(GT_Log.err);
+                }
+            }
+        }
+
+        if (mCoverData.length != 6) mCoverData = new int[]{0, 0, 0, 0, 0, 0};
+        if (mCoverSides.length != 6) mCoverSides = new int[]{0, 0, 0, 0, 0, 0};
+        if (mSidedRedstone.length != 6)
+            if (hasValidMetaTileEntity() && mMetaTileEntity.hasSidedRedstoneOutputBehavior())
+                mSidedRedstone = new byte[]{0, 0, 0, 0, 0, 0};
+            else mSidedRedstone = new byte[]{15, 15, 15, 15, 15, 15};
+
+        for (byte i = 0; i < 6; i++) mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+    }
+
+    private boolean createNewMetatileEntity(short aID) {
+        if (aID <= 0 || aID >= GregTech_API.METATILEENTITIES.length || GregTech_API.METATILEENTITIES[aID] == null) {
+            GT_Log.err.println("MetaID " + aID + " not loadable => locking TileEntity!");
+        } else {
+            if (aID != 0) {
+                if (hasValidMetaTileEntity()) mMetaTileEntity.setBaseMetaTileEntity(null);
+                GregTech_API.METATILEENTITIES[aID].newMetaEntity(this).setBaseMetaTileEntity(this);
+                mTickTimer = 0;
+                mID = aID;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Used for ticking special BaseMetaTileEntities, which need that for Energy Conversion
+     * It's called right before onPostTick()
+     */
+    public void updateStatus() {
+        //
+    }
+
+    /**
+     * Called when trying to charge Items
+     */
+    public void chargeItem(ItemStack aStack) {
+        decreaseStoredEU(GT_ModHandler.chargeElectricItem(aStack, (int) Math.min(Integer.MAX_VALUE, getStoredEU()), (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getOutputTier()), false, false), true);
+    }
+
+    /**
+     * Called when trying to discharge Items
+     */
+    public void dischargeItem(ItemStack aStack) {
+        increaseStoredEnergyUnits(GT_ModHandler.dischargeElectricItem(aStack, (int) Math.min(Integer.MAX_VALUE, getEUCapacity() - getStoredEU()), (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getInputTier()), false, false, false), true);
+    }
+
+    @Override
+    public void updateEntity() {
+        super.updateEntity();
+
+        if (!hasValidMetaTileEntity()) {
+            if (mMetaTileEntity == null) return;
+            mMetaTileEntity.setBaseMetaTileEntity(this);
+        }
+
+        mRunningThroughTick = true;
+        long tTime = System.currentTimeMillis();
+
+        for (int tCode = 0; hasValidMetaTileEntity() && tCode >= 0; ) {
+            try {
+                switch (tCode) {
+                    case 0:
+                        tCode++;
+                        if (mTickTimer++ == 0) {
+                            oX = xCoord;
+                            oY = yCoord;
+                            oZ = zCoord;
+                            if (isServerSide()) for (byte i = 0; i < 6; i++)
+                                if (getCoverIDAtSide(i) != 0)
+                                    if (!mMetaTileEntity.allowCoverOnSide(i, new GT_ItemStack(getCoverIDAtSide(i))))
+                                        dropCover(i, i, true);
+
+                            worldObj.markTileEntityChunkModified(xCoord, yCoord, zCoord, this);
+
+                            mMetaTileEntity.onFirstTick(this);
+                            if (!hasValidMetaTileEntity()) {
+                                mRunningThroughTick = false;
+                                return;
+                            }
+                        }
+                    case 1:
+                        tCode++;
+                        if (isClientSide()) {
+                            if (mColor != oColor) {
+                                mMetaTileEntity.onColorChangeClient(oColor = mColor);
+                                issueTextureUpdate();
+                            }
+
+                            if (mLightValue != oLightValueClient) {
+                                worldObj.setLightValue(EnumSkyBlock.Block, xCoord, yCoord, zCoord, mLightValue);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord + 1, yCoord, zCoord);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord - 1, yCoord, zCoord);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord + 1, zCoord);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord - 1, zCoord);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord + 1);
+                                worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord - 1);
+                                oLightValueClient = mLightValue;
+                                issueTextureUpdate();
+                            }
+
+                            if (mNeedsUpdate) {
+                                worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+                                //worldObj.func_147479_m(xCoord, yCoord, zCoord);
+                                mNeedsUpdate = false;
+                            }
+                        }
+                    case 2:
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (isServerSide() && mTickTimer > 10) {
+                            for (byte i = (byte) (tCode - 2); i < 6; i++)
+                                if (getCoverIDAtSide(i) != 0) {
+                                    tCode++;
+                                    GT_CoverBehavior tCover = getCoverBehaviorAtSide(i);
+                                    int tCoverTickRate = tCover.getTickRate(i, getCoverIDAtSide(i), mCoverData[i], this);
+                                    if (tCoverTickRate > 0 && mTickTimer % tCoverTickRate == 0) {
+                                        mCoverData[i] = tCover.doCoverThings(i, getInputRedstoneSignal(i), getCoverIDAtSide(i), mCoverData[i], this, mTickTimer);
+                                        if (!hasValidMetaTileEntity()) {
+                                            mRunningThroughTick = false;
+                                            return;
+                                        }
+                                    }
+                                }
+
+                        }
+                    case 8:
+                        tCode = 9;
+                        if (isServerSide()) {
+                            if (++mAverageEUInputIndex >= mAverageEUInput.length) mAverageEUInputIndex = 0;
+                            if (++mAverageEUOutputIndex >= mAverageEUOutput.length) mAverageEUOutputIndex = 0;
+
+                            mAverageEUInput[mAverageEUInputIndex] = 0;
+                            mAverageEUOutput[mAverageEUOutputIndex] = 0;
+                        }
+                    case 9:
+                        tCode++;
+                        mMetaTileEntity.onPreTick(this, mTickTimer);
+                        if (!hasValidMetaTileEntity()) {
+                            mRunningThroughTick = false;
+                            return;
+                        }
+                    case 10:
+                        tCode++;
+                        if (isServerSide()) {
+                            if (mRedstone != oRedstone || mTickTimer == 10) {
+                                for (byte i = 0; i < 6; i++)
+                                    mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+                                oRedstone = mRedstone;
+                                issueBlockUpdate();
+                            }
+
+                            if (xCoord != oX || yCoord != oY || zCoord != oZ) {
+                                oX = xCoord;
+                                oY = yCoord;
+                                oZ = zCoord;
+                                issueClientUpdate();
+                                clearTileEntityBuffer();
+                            }
+
+                            if (mFacing != oFacing) {
+                                oFacing = mFacing;
+                                for (byte i = 0; i < 6; i++)
+                                    if (getCoverIDAtSide(i) != 0)
+                                        if (!mMetaTileEntity.allowCoverOnSide(i, new GT_ItemStack(getCoverIDAtSide(i))))
+                                            dropCover(i, i, true);
+                                issueBlockUpdate();
+                            }
+
+                            if (mTickTimer > 20 && mMetaTileEntity.isElectric()) {
+                                mAcceptedAmperes = 0;
+
+                                if (getOutputVoltage() != oOutput) {
+                                    oOutput = getOutputVoltage();
+                                }
+
+                                if (mMetaTileEntity.isEnetOutput() || mMetaTileEntity.isEnetInput()) {
+                                    for (byte i = 0; i < 6; i++) {
+                                        boolean
+                                                temp = isEnergyInputSide(i);
+                                        if (temp != mActiveEUInputs[i]) {
+                                            mActiveEUInputs[i] = temp;
+                                        }
+                                        temp = isEnergyOutputSide(i);
+                                        if (temp != mActiveEUOutputs[i]) {
+                                            mActiveEUOutputs[i] = temp;
+                                        }
+                                    }
+                                }
+
+
+
+                                if (mMetaTileEntity.isEnetOutput() && oOutput > 0) {
+                                    long tOutputVoltage = oOutput, tUsableAmperage = Math.min(getOutputAmperage(), (getStoredEU() - mMetaTileEntity.getMinimumStoredEU()) / tOutputVoltage);
+                                        if (tUsableAmperage > 0) {
+                                            long tEU = tOutputVoltage * IEnergyConnected.Util.emitEnergyToNetwork(oOutput, tUsableAmperage, this);
+                                            mAverageEUOutput[mAverageEUOutputIndex] += tEU;
+                                            decreaseStoredEU(tEU, true);
+                                        }
+                                }
+
+
+                                if (getEUCapacity() > 0) {
+                                    if (GregTech_API.sMachineFireExplosions && getRandomNumber(1000) == 0) {
+                                        Block tBlock = getBlockAtSide((byte) getRandomNumber(6));
+                                        if (tBlock != null && tBlock instanceof BlockFire) doEnergyExplosion();
+                                    }
+
+                                    if (!hasValidMetaTileEntity()) {
+                                        mRunningThroughTick = false;
+                                        return;
+                                    }
+
+                                    if (getRandomNumber(1000) == 0) {
+                                        if ((getCoverIDAtSide((byte) 1) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord) - 2 < yCoord)
+                                                || (getCoverIDAtSide((byte) 2) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord - 1) - 1 < yCoord)
+                                                || (getCoverIDAtSide((byte) 3) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord + 1) - 1 < yCoord)
+                                                || (getCoverIDAtSide((byte) 4) == 0 && worldObj.getPrecipitationHeight(xCoord - 1, zCoord) - 1 < yCoord)
+                                                || (getCoverIDAtSide((byte) 5) == 0 && worldObj.getPrecipitationHeight(xCoord + 1, zCoord) - 1 < yCoord)) {
+                                            if (GregTech_API.sMachineRainExplosions && worldObj.isRaining() && getBiome().rainfall > 0) {
+                                                if (getRandomNumber(10) == 0) {
+                                                    try {
+                                                        GT_Mod.instance.achievements.issueAchievement(this.getWorldObj().getPlayerEntityByName(mOwnerName), "badweather");
+                                                    } catch (Exception e) {
+                                                    }
+                                                    doEnergyExplosion();
+                                                } else setOnFire();
+                                            }
+                                            if (!hasValidMetaTileEntity()) {
+                                                mRunningThroughTick = false;
+                                                return;
+                                            }
+                                            if (GregTech_API.sMachineThunderExplosions && worldObj.isThundering() && getBiome().rainfall > 0 && getRandomNumber(3) == 0) {
+                                                try {
+                                                    GT_Mod.instance.achievements.issueAchievement(this.getWorldObj().getPlayerEntityByName(mOwnerName), "badweather");
+                                                } catch (Exception e) {
+                                                }
+                                                doEnergyExplosion();
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (!hasValidMetaTileEntity()) {
+                                mRunningThroughTick = false;
+                                return;
+                            }
+                        }
+                    case 11:
+                        tCode++;
+                        if (isServerSide()) {
+                            if (mMetaTileEntity.dechargerSlotCount() > 0 && getStoredEU() < getEUCapacity()) {
+                                for (int i = mMetaTileEntity.dechargerSlotStartIndex(), k = mMetaTileEntity.dechargerSlotCount() + i; i < k; i++) {
+                                    if (mMetaTileEntity.mInventory[i] != null && getStoredEU() < getEUCapacity()) {
+                                        dischargeItem(mMetaTileEntity.mInventory[i]);
+                                        if (mMetaTileEntity.mInventory[i].stackSize <= 0)
+                                            mMetaTileEntity.mInventory[i] = null;
+                                        mInventoryChanged = true;
+                                    }
+                                }
+                            }
+                        }
+                    case 12:
+                        tCode++;
+                        if (isServerSide()) {
+                            if (mMetaTileEntity.rechargerSlotCount() > 0 && getStoredEU() > 0) {
+                                for (int i = mMetaTileEntity.rechargerSlotStartIndex(), k = mMetaTileEntity.rechargerSlotCount() + i; i < k; i++) {
+                                    if (getStoredEU() > 0 && mMetaTileEntity.mInventory[i] != null) {
+                                        chargeItem(mMetaTileEntity.mInventory[i]);
+                                        if (mMetaTileEntity.mInventory[i].stackSize <= 0)
+                                            mMetaTileEntity.mInventory[i] = null;
+                                        mInventoryChanged = true;
+                                    }
+                                }
+                            }
+                        }
+                    case 13:
+                        tCode++;
+                        updateStatus();
+                        if (!hasValidMetaTileEntity()) {
+                            mRunningThroughTick = false;
+                            return;
+                        }
+                    case 14:
+                        tCode++;
+                        mMetaTileEntity.onPostTick(this, mTickTimer);
+                        if (!hasValidMetaTileEntity()) {
+                            mRunningThroughTick = false;
+                            return;
+                        }
+                    case 15:
+                        tCode++;
+                        if (isServerSide()) {
+                            if (mTickTimer % 10 == 0) {
+                                if (mSendClientData) {
+                                    NW.sendPacketToAllPlayersInRange(worldObj, new GT_Packet_TileEntity(xCoord, (short) yCoord, zCoord, mID, mCoverSides[0], mCoverSides[1], mCoverSides[2], mCoverSides[3], mCoverSides[4], mCoverSides[5], oTextureData = (byte) ((mFacing & 7) | (mActive ? 8 : 0) | (mRedstone ? 16 : 0) | (mLockUpgrade ? 32 : 0)), oUpdateData = hasValidMetaTileEntity() ? mMetaTileEntity.getUpdateData() : 0, oRedstoneData = (byte) (((mSidedRedstone[0] > 0) ? 1 : 0) | ((mSidedRedstone[1] > 0) ? 2 : 0) | ((mSidedRedstone[2] > 0) ? 4 : 0) | ((mSidedRedstone[3] > 0) ? 8 : 0) | ((mSidedRedstone[4] > 0) ? 16 : 0) | ((mSidedRedstone[5] > 0) ? 32 : 0)), oColor = mColor), xCoord, zCoord);
+                                    mSendClientData = false;
+                                }
+                            }
+
+                            if (mTickTimer > 10) {
+                                byte tData = (byte) ((mFacing & 7) | (mActive ? 8 : 0) | (mRedstone ? 16 : 0) | (mLockUpgrade ? 32 : 0));
+                                if (tData != oTextureData) sendBlockEvent((byte) 0, oTextureData = tData);
+                                tData = mMetaTileEntity.getUpdateData();
+                                if (tData != oUpdateData) sendBlockEvent((byte) 1, oUpdateData = tData);
+                                if (mColor != oColor) sendBlockEvent((byte) 2, oColor = mColor);
+                                tData = (byte) (((mSidedRedstone[0] > 0) ? 1 : 0) | ((mSidedRedstone[1] > 0) ? 2 : 0) | ((mSidedRedstone[2] > 0) ? 4 : 0) | ((mSidedRedstone[3] > 0) ? 8 : 0) | ((mSidedRedstone[4] > 0) ? 16 : 0) | ((mSidedRedstone[5] > 0) ? 32 : 0));
+                                if (tData != oRedstoneData) sendBlockEvent((byte) 3, oRedstoneData = tData);
+                                if (mLightValue != oLightValue) {
+                                    worldObj.setLightValue(EnumSkyBlock.Block, xCoord, yCoord, zCoord, mLightValue);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord + 1, yCoord, zCoord);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord - 1, yCoord, zCoord);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord + 1, zCoord);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord - 1, zCoord);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord + 1);
+                                    worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord - 1);
+                                    issueTextureUpdate();
+                                    sendBlockEvent((byte) 7, oLightValue = mLightValue);
+                                }
+                            }
+
+                            if (mNeedsBlockUpdate) {
+                                worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, getBlockOffset(0, 0, 0));
+                                mNeedsBlockUpdate = false;
+                            }
+                        }
+                    default:
+                        tCode = -1;
+                        break;
+                }
+            } catch (Throwable e) {
+                GT_Log.err.println("Encountered Exception while ticking MetaTileEntity in Step " + (tCode - 1) + ". The Game should've crashed now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+                e.printStackTrace(GT_Log.err);
+            }
+        }
+
+        if (isServerSide() && hasValidMetaTileEntity()) {
+            tTime = System.currentTimeMillis() - tTime;
+            if (mTimeStatistics.length > 0)
+                mTimeStatistics[mTimeStatisticsIndex = (mTimeStatisticsIndex + 1) % mTimeStatistics.length] = (int) tTime;
+            if (tTime > 0 && tTime > GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING && mTickTimer > 1000 && getMetaTileEntity().doTickProfilingMessageDuringThisTick() && mLagWarningCount++ < 10)
+                System.out.println("WARNING: Possible Lag Source at [" + xCoord + ", " + yCoord + ", " + zCoord + "] in Dimension " + worldObj.provider.dimensionId + " with " + tTime + "ms caused by an instance of " + getMetaTileEntity().getClass());
+        }
+
+        mWorkUpdate = mInventoryChanged = mRunningThroughTick = false;
+    }
+
+    @Override
+    public Packet getDescriptionPacket() {
+        issueClientUpdate();
+        return null;
+    }
+
+    public final void receiveMetaTileEntityData(short aID, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4, int aCover5, byte aTextureData, byte aUpdateData, byte aRedstoneData, byte aColorData) {
+        issueTextureUpdate();
+        if (mID != aID && aID > 0) {
+            mID = aID;
+            createNewMetatileEntity(mID);
+        }
+
+        mCoverSides[0] = aCover0;
+        mCoverSides[1] = aCover1;
+        mCoverSides[2] = aCover2;
+        mCoverSides[3] = aCover3;
+        mCoverSides[4] = aCover4;
+        mCoverSides[5] = aCover5;
+
+        for (byte i = 0; i < 6; i++) mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+
+        receiveClientEvent(0, aTextureData);
+        receiveClientEvent(1, aUpdateData);
+        receiveClientEvent(2, aColorData);
+        receiveClientEvent(3, aRedstoneData);
+    }
+
+    @Override
+    public boolean receiveClientEvent(int aEventID, int aValue) {
+        super.receiveClientEvent(aEventID, aValue);
+
+        if (hasValidMetaTileEntity()) {
+            try {
+                mMetaTileEntity.receiveClientEvent((byte) aEventID, (byte) aValue);
+            } catch (Throwable e) {
+                GT_Log.err.println("Encountered Exception while receiving Data from the Server, the Client should've been crashed by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+                e.printStackTrace(GT_Log.err);
+            }
+        }
+
+        if (isClientSide()) {
+            issueTextureUpdate();
+            switch (aEventID) {
+                case 0:
+                    mFacing = (byte) (aValue & 7);
+                    mActive = ((aValue & 8) != 0);
+                    mRedstone = ((aValue & 16) != 0);
+                    //mLockUpgrade	= ((aValue&32) != 0);
+                    break;
+                case 1:
+                    if (hasValidMetaTileEntity()) mMetaTileEntity.onValueUpdate((byte) aValue);
+                    break;
+                case 2:
+                    if (aValue > 16 || aValue < 0) aValue = 0;
+                    mColor = (byte) aValue;
+                    break;
+                case 3:
+                    mSidedRedstone[0] = (byte) ((aValue & 1) > 0 ? 15 : 0);
+                    mSidedRedstone[1] = (byte) ((aValue & 2) > 0 ? 15 : 0);
+                    mSidedRedstone[2] = (byte) ((aValue & 4) > 0 ? 15 : 0);
+                    mSidedRedstone[3] = (byte) ((aValue & 8) > 0 ? 15 : 0);
+                    mSidedRedstone[4] = (byte) ((aValue & 16) > 0 ? 15 : 0);
+                    mSidedRedstone[5] = (byte) ((aValue & 32) > 0 ? 15 : 0);
+                    break;
+                case 4:
+                    if (hasValidMetaTileEntity() && mTickTimer > 20)
+                        mMetaTileEntity.doSound((byte) aValue, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+                    break;
+                case 5:
+                    if (hasValidMetaTileEntity() && mTickTimer > 20)
+                        mMetaTileEntity.startSoundLoop((byte) aValue, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+                    break;
+                case 6:
+                    if (hasValidMetaTileEntity() && mTickTimer > 20)
+                        mMetaTileEntity.stopSoundLoop((byte) aValue, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+                    break;
+                case 7:
+                    mLightValue = (byte) aValue;
+                    break;
+            }
+        }
+        return true;
+    }
+
+    public ArrayList<String> getDebugInfo(EntityPlayer aPlayer, int aLogLevel) {
+        ArrayList<String> tList = new ArrayList<String>();
+        if (aLogLevel > 2) {
+            tList.add("Meta-ID: " + mID + (canAccessData() ? " valid" : " invalid") + (mMetaTileEntity == null ? " MetaTileEntity == null!" : " "));
+        }
+        if (aLogLevel > 1) {
+            if (mTimeStatistics.length > 0) {
+                double tAverageTime = 0;
+                for (int tTime : mTimeStatistics) tAverageTime += tTime;
+                tList.add("This particular TileEntity has caused an average CPU-load of ~" + (tAverageTime / mTimeStatistics.length) + "ms over the last " + mTimeStatistics.length + " ticks.");
+            }
+            if (mLagWarningCount > 0) {
+                tList.add("This TileEntity has also caused " + (mLagWarningCount >= 10 ? "more than 10" : mLagWarningCount) + " Lag Spike Warnings (anything taking longer than " + GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING + "ms) on the Server.");
+            }
+            tList.add("Is" + (mMetaTileEntity.isAccessAllowed(aPlayer) ? " " : " not ") + "accessible for you");
+        }
+        if (aLogLevel > 0) {
+            if (getSteamCapacity() > 0 && hasSteamEngineUpgrade())
+                tList.add(getStoredSteam() + " of " + getSteamCapacity() + " Steam");
+            tList.add("Machine is " + (mActive ? "active" : "inactive"));
+            if (!mHasEnoughEnergy)
+                tList.add("ATTENTION: This Device consumes Energy at a higher Rate than you input. You could insert more to speed up the process.");
+        }
+        return mMetaTileEntity.getSpecialDebugInfo(this, aPlayer, aLogLevel, tList);
+    }
+
+    @Override
+    public void issueTextureUpdate() {
+        mNeedsUpdate = true;
+    }
+
+    @Override
+    public void issueBlockUpdate() {
+        mNeedsBlockUpdate = true;
+    }
+
+    @Override
+    public void issueClientUpdate() {
+        mSendClientData = true;
+    }
+
+    @Override
+    public void issueCoverUpdate(byte aSide) {
+        issueClientUpdate();
+    }
+
+    @Override
+    public byte getStrongestRedstone() {
+        return (byte) Math.max(getInternalInputRedstoneSignal((byte) 0), Math.max(getInternalInputRedstoneSignal((byte) 1), Math.max(getInternalInputRedstoneSignal((byte) 2), Math.max(getInternalInputRedstoneSignal((byte) 3), Math.max(getInternalInputRedstoneSignal((byte) 4), getInternalInputRedstoneSignal((byte) 5))))));
+    }
+
+    @Override
+    public boolean getRedstone() {
+        return getRedstone((byte) 0) || getRedstone((byte) 1) || getRedstone((byte) 2) || getRedstone((byte) 3) || getRedstone((byte) 4) || getRedstone((byte) 5);
+    }
+
+    @Override
+    public boolean getRedstone(byte aSide) {
+        return getInternalInputRedstoneSignal(aSide) > 0;
+    }
+
+    public ITexture getCoverTexture(byte aSide) {
+        return GregTech_API.sCovers.get(new GT_ItemStack(getCoverIDAtSide(aSide)));
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        if (canAccessData()) return mMetaTileEntity.isGivingInformation();
+        return false;
+    }
+
+    @Override
+    public boolean isValidFacing(byte aSide) {
+        if (canAccessData()) return mMetaTileEntity.isFacingValid(aSide);
+        return false;
+    }
+
+    @Override
+    public byte getBackFacing() {
+        return GT_Utility.getOppositeSide(mFacing);
+    }
+
+    @Override
+    public byte getFrontFacing() {
+        return mFacing;
+    }
+
+    @Override
+    public void setFrontFacing(byte aFacing) {
+        if (isValidFacing(aFacing)) {
+            mFacing = aFacing;
+            mMetaTileEntity.onFacingChange();
+            onMachineBlockUpdate();
+        }
+    }
+
+    @Override
+    public int getSizeInventory() {
+        if (canAccessData()) return mMetaTileEntity.getSizeInventory();
+        return 0;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int aIndex) {
+        if (canAccessData()) return mMetaTileEntity.getStackInSlot(aIndex);
+        return null;
+    }
+
+    @Override
+    public void setInventorySlotContents(int aIndex, ItemStack aStack) {
+        mInventoryChanged = true;
+        if (canAccessData())
+            mMetaTileEntity.setInventorySlotContents(aIndex, worldObj.isRemote ? aStack : GT_OreDictUnificator.setStack(true, aStack));
+    }
+
+    @Override
+    public String getInventoryName() {
+        if (canAccessData()) return mMetaTileEntity.getInventoryName();
+        if (GregTech_API.METATILEENTITIES[mID] != null) return GregTech_API.METATILEENTITIES[mID].getInventoryName();
+        return "";
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        if (canAccessData()) return mMetaTileEntity.getInventoryStackLimit();
+        return 64;
+    }
+
+    @Override
+    public void openInventory() {
+        if (canAccessData()) mMetaTileEntity.onOpenGUI();
+    }
+
+    @Override
+    public void closeInventory() {
+        if (canAccessData()) mMetaTileEntity.onCloseGUI();
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer aPlayer) {
+        return canAccessData() && playerOwnsThis(aPlayer, false) && mTickTimer > 40 && getTileEntityOffset(0, 0, 0) == this && aPlayer.getDistanceSq(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5) < 64 && mMetaTileEntity.isAccessAllowed(aPlayer);
+    }
+
+    @Override
+    public void validate() {
+        super.validate();
+        mTickTimer = 0;
+    }
+
+    @Override
+    public void invalidate() {
+        tileEntityInvalid = false;
+        if (canAccessData()) {
+            mMetaTileEntity.onRemoval();
+            mMetaTileEntity.setBaseMetaTileEntity(null);
+        }
+        super.invalidate();
+    }
+
+    @Override
+    public void onChunkUnload() {
+        super.onChunkUnload();
+    }
+
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot) {
+        ItemStack stack = getStackInSlot(slot);
+        if (stack != null) setInventorySlotContents(slot, null);
+        return stack;
+    }
+
+    @Override
+    public void onMachineBlockUpdate() {
+        if (canAccessData()) mMetaTileEntity.onMachineBlockUpdate();
+    }
+
+    @Override
+    public int getProgress() {
+        return canAccessData() ? mMetaTileEntity.getProgresstime() : 0;
+    }
+
+    @Override
+    public int getMaxProgress() {
+        return canAccessData() ? mMetaTileEntity.maxProgresstime() : 0;
+    }
+
+    @Override
+    public boolean increaseProgress(int aProgressAmountInTicks) {
+        return canAccessData() ? mMetaTileEntity.increaseProgress(aProgressAmountInTicks) != aProgressAmountInTicks : false;
+    }
+
+    @Override
+    public boolean hasThingsToDo() {
+        return getMaxProgress() > 0;
+    }
+
+    @Override
+    public void enableWorking() {
+        if (!mWorks) mWorkUpdate = true;
+        mWorks = true;
+    }
+
+    @Override
+    public void disableWorking() {
+        mWorks = false;
+    }
+
+    @Override
+    public boolean isAllowedToWork() {
+        return mWorks;
+    }
+
+    @Override
+    public boolean hasWorkJustBeenEnabled() {
+        return mWorkUpdate;
+    }
+
+    @Override
+    public byte getWorkDataValue() {
+        return mWorkData;
+    }
+
+    @Override
+    public void setWorkDataValue(byte aValue) {
+        mWorkData = aValue;
+    }
+
+    @Override
+    public int getMetaTileID() {
+        return mID;
+    }
+
+    @Override
+    public int setMetaTileID(short aID) {
+        return mID = aID;
+    }
+
+    @Override
+    public boolean isActive() {
+        return mActive;
+    }
+
+    @Override
+    public void setActive(boolean aActive) {
+        mActive = aActive;
+    }
+
+    @Override
+    public long getTimer() {
+        return mTickTimer;
+    }
+
+    @Override
+    public boolean decreaseStoredEnergyUnits(long aEnergy, boolean aIgnoreTooLessEnergy) {
+        if (!canAccessData()) return false;
+        return mHasEnoughEnergy = decreaseStoredEU(aEnergy, aIgnoreTooLessEnergy) || decreaseStoredSteam(aEnergy, false) || (aIgnoreTooLessEnergy && (decreaseStoredSteam(aEnergy, true)));
+    }
+
+    @Override
+    public boolean increaseStoredEnergyUnits(long aEnergy, boolean aIgnoreTooMuchEnergy) {
+        if (!canAccessData()) return false;
+        if (getStoredEU() < getEUCapacity() || aIgnoreTooMuchEnergy) {
+            setStoredEU(mMetaTileEntity.getEUVar() + aEnergy);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean inputEnergyFrom(byte aSide) {
+        if (aSide == 6) return true;
+        if (isServerSide()) return (aSide >= 0 && aSide < 6 ? mActiveEUInputs[aSide] : false) && !mReleaseEnergy;
+        return isEnergyInputSide(aSide);
+    }
+
+    @Override
+    public boolean outputsEnergyTo(byte aSide) {
+        if (aSide == 6) return true;
+        if (isServerSide()) return (aSide >= 0 && aSide < 6 ? mActiveEUOutputs[aSide] : false) || mReleaseEnergy;
+        return isEnergyOutputSide(aSide);
+    }
+
+    @Override
+    public long getOutputAmperage() {
+        if (canAccessData() && mMetaTileEntity.isElectric()) return mMetaTileEntity.maxAmperesOut();
+        return 0;
+    }
+
+    @Override
+    public long getOutputVoltage() {
+        if (canAccessData() && mMetaTileEntity.isElectric() && mMetaTileEntity.isEnetOutput())
+            return mMetaTileEntity.maxEUOutput();
+        return 0;
+    }
+
+    @Override
+    public long getInputAmperage() {
+        if (canAccessData() && mMetaTileEntity.isElectric()) return mMetaTileEntity.maxAmperesIn();
+        return 0;
+    }
+
+    @Override
+    public long getInputVoltage() {
+        if (canAccessData() && mMetaTileEntity.isElectric()) return mMetaTileEntity.maxEUInput();
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public boolean increaseStoredSteam(long aEnergy, boolean aIgnoreTooMuchEnergy) {
+        if (!canAccessData()) return false;
+        if (mMetaTileEntity.getSteamVar() < getSteamCapacity() || aIgnoreTooMuchEnergy) {
+            setStoredSteam(mMetaTileEntity.getSteamVar() + aEnergy);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public String[] getDescription() {
+        if (canAccessData()) return mMetaTileEntity.getDescription();
+        return new String[0];
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        if (canAccessData()) return mMetaTileEntity.isValidSlot(aIndex);
+        return false;
+    }
+
+    @Override
+    public long getUniversalEnergyStored() {
+        return Math.max(getStoredEU(), getStoredSteam());
+    }
+
+    @Override
+    public long getUniversalEnergyCapacity() {
+        return Math.max(getEUCapacity(), getSteamCapacity());
+    }
+
+    @Override
+    public long getStoredEU() {
+        if (canAccessData()) return Math.min(mMetaTileEntity.getEUVar(), getEUCapacity());
+        return 0;
+    }
+
+    @Override
+    public long getEUCapacity() {
+        if (canAccessData()) return mMetaTileEntity.maxEUStore();
+        return 0;
+    }
+
+    @Override
+    public long getStoredSteam() {
+        if (canAccessData()) return Math.min(mMetaTileEntity.getSteamVar(), getSteamCapacity());
+        return 0;
+    }
+
+    @Override
+    public long getSteamCapacity() {
+        if (canAccessData()) return mMetaTileEntity.maxSteamStore();
+        return 0;
+    }
+
+    @Override
+    public ITexture[] getTexture(byte aSide) {
+        ITexture rIcon = getCoverTexture(aSide);
+        if (rIcon != null) return new ITexture[]{rIcon};
+        if (hasValidMetaTileEntity())
+            return mMetaTileEntity.getTexture(this, aSide, mFacing, (byte) (mColor - 1), mActive, getOutputRedstoneSignal(aSide) > 0);
+        return Textures.BlockIcons.ERROR_RENDERING;
+    }
+
+    private boolean isEnergyInputSide(byte aSide) {
+        if (aSide >= 0 && aSide < 6) {
+            if (!getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))
+                return false;
+            if (isInvalid() || mReleaseEnergy) return false;
+            if (canAccessData() && mMetaTileEntity.isElectric() && mMetaTileEntity.isEnetInput())
+                return mMetaTileEntity.isInputFacing(aSide);
+        }
+        return false;
+    }
+
+    private boolean isEnergyOutputSide(byte aSide) {
+        if (aSide >= 0 && aSide < 6) {
+            if (!getCoverBehaviorAtSide(aSide).letsEnergyOut(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))
+                return false;
+            if (isInvalid() || mReleaseEnergy) return mReleaseEnergy;
+            if (canAccessData() && mMetaTileEntity.isElectric() && mMetaTileEntity.isEnetOutput())
+                return mMetaTileEntity.isOutputFacing(aSide);
+        }
+        return false;
+    }
+
+    protected boolean hasValidMetaTileEntity() {
+        return mMetaTileEntity != null && mMetaTileEntity.getBaseMetaTileEntity() == this;
+    }
+
+    protected boolean canAccessData() {
+        return !isDead && hasValidMetaTileEntity();
+    }
+
+    public boolean setStoredEU(long aEnergy) {
+        if (!canAccessData()) return false;
+        if (aEnergy < 0) aEnergy = 0;
+        mMetaTileEntity.setEUVar(aEnergy);
+        return true;
+    }
+
+    public boolean setStoredSteam(long aEnergy) {
+        if (!canAccessData()) return false;
+        if (aEnergy < 0) aEnergy = 0;
+        mMetaTileEntity.setSteamVar(aEnergy);
+        return true;
+    }
+
+    public boolean decreaseStoredEU(long aEnergy, boolean aIgnoreTooLessEnergy) {
+        if (!canAccessData()) {
+            return false;
+        }
+        if (mMetaTileEntity.getEUVar() - aEnergy >= 0 || aIgnoreTooLessEnergy) {
+            setStoredEU(mMetaTileEntity.getEUVar() - aEnergy);
+            if (mMetaTileEntity.getEUVar() < 0) {
+                setStoredEU(0);
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean decreaseStoredSteam(long aEnergy, boolean aIgnoreTooLessEnergy) {
+        if (!canAccessData()) return false;
+        if (mMetaTileEntity.getSteamVar() - aEnergy >= 0 || aIgnoreTooLessEnergy) {
+            setStoredSteam(mMetaTileEntity.getSteamVar() - aEnergy);
+            if (mMetaTileEntity.getSteamVar() < 0) {
+                setStoredSteam(0);
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean playerOwnsThis(EntityPlayer aPlayer, boolean aCheckPrecicely) {
+        if (!canAccessData()) return false;
+        if (aCheckPrecicely || privateAccess() || mOwnerName.equals(""))
+            if (mOwnerName.equals("") && isServerSide()) setOwnerName(aPlayer.getDisplayName());
+            else if (privateAccess() && !aPlayer.getDisplayName().equals("Player") && !mOwnerName.equals("Player") && !mOwnerName.equals(aPlayer.getDisplayName()))
+                return false;
+        return true;
+    }
+
+    public boolean privateAccess() {
+        if (!canAccessData()) return mLockUpgrade;
+        return mLockUpgrade || mMetaTileEntity.ownerControl();
+    }
+
+    public void doEnergyExplosion() {
+        if (getUniversalEnergyCapacity() > 0 && getUniversalEnergyStored() >= getUniversalEnergyCapacity() / 5) {
+            doExplosion(oOutput * (getUniversalEnergyStored() >= getUniversalEnergyCapacity() ? 4 : getUniversalEnergyStored() >= getUniversalEnergyCapacity() / 2 ? 2 : 1));
+            GT_Mod.instance.achievements.issueAchievement(this.getWorldObj().getPlayerEntityByName(mOwnerName), "electricproblems");
+        }
+    }
+
+    @Override
+    public void doExplosion(long aAmount) {
+        if (canAccessData()) {
+            // This is only for Electric Machines
+            if (GregTech_API.sMachineWireFire && mMetaTileEntity.isElectric()) {
+                try {
+                    mReleaseEnergy = true;
+                    IEnergyConnected.Util.emitEnergyToNetwork(V[5], Math.max(1, getStoredEU() / V[5]), this);
+                } catch (Exception e) {/* Fun Fact: all these "do nothing" Comments you see in my Code, are just there to let Eclipse shut up about the intended empty Brackets, but I need eclipse to yell at me in some of the regular Cases where I forget to add Code */}
+            }
+            mReleaseEnergy = false;
+            // Normal Explosion Code
+            mMetaTileEntity.onExplosion();
+            mMetaTileEntity.doExplosion(aAmount);
+        }
+    }
+
+    @Override
+    public ArrayList<ItemStack> getDrops() {
+        ItemStack rStack = new ItemStack(GregTech_API.sBlockMachines, 1, mID);
+        NBTTagCompound tNBT = new NBTTagCompound();
+        if (mRecipeStuff != null && !mRecipeStuff.hasNoTags()) tNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+        if (mMuffler) tNBT.setBoolean("mMuffler", mMuffler);
+        if (mLockUpgrade) tNBT.setBoolean("mLockUpgrade", mLockUpgrade);
+        if (mSteamConverter) tNBT.setBoolean("mSteamConverter", mSteamConverter);
+        if (mColor > 0) tNBT.setByte("mColor", mColor);
+        if (mOtherUpgrades > 0) tNBT.setByte("mOtherUpgrades", mOtherUpgrades);
+        if (mStrongRedstone > 0) tNBT.setByte("mStrongRedstone", mStrongRedstone);
+        for (byte i = 0; i < mCoverSides.length; i++) {
+            if (mCoverSides[i] != 0) {
+                tNBT.setIntArray("mCoverData", mCoverData);
+                tNBT.setIntArray("mCoverSides", mCoverSides);
+                break;
+            }
+        }
+        if (hasValidMetaTileEntity()) mMetaTileEntity.setItemNBT(tNBT);
+        if (!tNBT.hasNoTags()) rStack.setTagCompound(tNBT);
+        return new ArrayList<ItemStack>(Arrays.asList(rStack));
+    }
+
+    public int getUpgradeCount() {
+        return (mMuffler ? 1 : 0) + (mLockUpgrade ? 1 : 0) + (mSteamConverter ? 1 : 0) + mOtherUpgrades;
+    }
+
+    @Override
+    public boolean onRightclick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) {
+        if (isClientSide()) {
+            if (getCoverBehaviorAtSide(aSide).onCoverRightclickClient(aSide, this, aPlayer, aX, aY, aZ)) return true;
+            if (!getCoverBehaviorAtSide(aSide).isGUIClickable(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))
+                return false;
+        }
+        if (isServerSide()) {
+            if (!privateAccess() || aPlayer.getDisplayName().equalsIgnoreCase(getOwnerName())) {
+                ItemStack tCurrentItem = aPlayer.inventory.getCurrentItem();
+                if (tCurrentItem != null) {
+                    if (getColorization() >= 0 && GT_Utility.areStacksEqual(new ItemStack(Items.water_bucket, 1), tCurrentItem)) {
+                        tCurrentItem.func_150996_a(Items.bucket);
+                        setColorization((byte) (getColorization() >= 16 ? -2 : -1));
+                        return true;
+                    }
+                    if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWrenchList)) {
+                        if (mMetaTileEntity.onWrenchRightClick(aSide, GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ), aPlayer, aX, aY, aZ)) {
+                            GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer);
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(100), 1.0F, -1, xCoord, yCoord, zCoord);
+                        }
+                        return true;
+                    }
+
+                    if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sScrewdriverList)) {
+                        if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 200, aPlayer)) {
+                            setCoverDataAtSide(aSide, getCoverBehaviorAtSide(aSide).onCoverScrewdriverclick(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this, aPlayer, aX, aY, aZ));
+                            mMetaTileEntity.onScrewdriverRightClick(aSide, aPlayer, aX, aY, aZ);
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(100), 1.0F, -1, xCoord, yCoord, zCoord);
+                        }
+                        return true;
+                    }
+
+                    if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sHardHammerList)) {
+                        if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer)) {
+                            mInputDisabled = !mInputDisabled;
+                            if (mInputDisabled) mOutputDisabled = !mOutputDisabled;
+                            GT_Utility.sendChatToPlayer(aPlayer, "Auto-Input: " + (mInputDisabled ? "Disabled" : "Enabled") + "  Auto-Output: " + (mOutputDisabled ? "Disabled" : "Enabled"));
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(1), 1.0F, -1, xCoord, yCoord, zCoord);
+                        }
+                        return true;
+                    }
+
+                    if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sSoftHammerList)) {
+                        if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer)) {
+                            if (mWorks) disableWorking();
+                            else enableWorking();
+                            GT_Utility.sendChatToPlayer(aPlayer, "Machine Processing: " + (isAllowedToWork() ? "Enabled" : "Disabled"));
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(101), 1.0F, -1, xCoord, yCoord, zCoord);
+                        }
+                        return true;
+                    }
+
+                    if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sSolderingToolList)) {
+                        byte tSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ);
+                        if (GT_ModHandler.useSolderingIron(tCurrentItem, aPlayer)) {
+                            mStrongRedstone ^= (1 << tSide);
+                            GT_Utility.sendChatToPlayer(aPlayer, "Redstone Output at Side " + tSide + " set to: " + ((mStrongRedstone & (1 << tSide)) != 0 ? "Strong" : "Weak"));
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(103), 3.0F, -1, xCoord, yCoord, zCoord);
+                        }
+                        return true;
+                    }
+
+                    if (getCoverIDAtSide(aSide) == 0) {
+                        if (GregTech_API.sCovers.containsKey(new GT_ItemStack(tCurrentItem))) {
+                            if (GregTech_API.getCoverBehavior(tCurrentItem).isCoverPlaceable(aSide, new GT_ItemStack(tCurrentItem), this) && mMetaTileEntity.allowCoverOnSide(aSide, new GT_ItemStack(tCurrentItem))) {
+                                setCoverItemAtSide(aSide, tCurrentItem);
+                                if (!aPlayer.capabilities.isCreativeMode) tCurrentItem.stackSize--;
+                                GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(100), 1.0F, -1, xCoord, yCoord, zCoord);
+                            }
+                            return true;
+                        }
+                    } else {
+                        if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sCrowbarList)) {
+                            if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer)) {
+                                GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(0), 1.0F, -1, xCoord, yCoord, zCoord);
+                                dropCover(aSide, aSide, false);
+                            }
+                            return true;
+                        }
+                    }
+                }
+
+                if (getCoverBehaviorAtSide(aSide).onCoverRightclick(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this, aPlayer, aX, aY, aZ))
+                    return true;
+
+                if (!getCoverBehaviorAtSide(aSide).isGUIClickable(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))
+                    return false;
+
+                if (isUpgradable() && aPlayer.inventory.getCurrentItem() != null) {/*
+                    if (ItemList.Upgrade_SteamEngine.isStackEqual(aPlayer.inventory.getCurrentItem())) {
+						if (addSteamEngineUpgrade()) {
+							GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(3), 1.0F, -1, xCoord, yCoord, zCoord);
+							if (!aPlayer.capabilities.isCreativeMode) aPlayer.inventory.getCurrentItem().stackSize--;
+						}
+						return true;
+					}*/
+                    if (ItemList.Upgrade_Muffler.isStackEqual(aPlayer.inventory.getCurrentItem())) {
+                        if (addMufflerUpgrade()) {
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(3), 1.0F, -1, xCoord, yCoord, zCoord);
+                            if (!aPlayer.capabilities.isCreativeMode) aPlayer.inventory.getCurrentItem().stackSize--;
+                        }
+                        return true;
+                    }
+                    if (ItemList.Upgrade_Lock.isStackEqual(aPlayer.inventory.getCurrentItem())) {
+                        if (isUpgradable() && !mLockUpgrade) {
+                            mLockUpgrade = true;
+                            setOwnerName(aPlayer.getDisplayName());
+                            GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(3), 1.0F, -1, xCoord, yCoord, zCoord);
+                            if (!aPlayer.capabilities.isCreativeMode) aPlayer.inventory.getCurrentItem().stackSize--;
+                        }
+                        return true;
+                    }
+                }
+            }
+        }
+
+        try {
+            if (hasValidMetaTileEntity()) return mMetaTileEntity.onRightclick(this, aPlayer, aSide, aX, aY, aZ);
+        } catch (Throwable e) {
+            GT_Log.err.println("Encountered Exception while rightclicking TileEntity, the Game should've crashed now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+            e.printStackTrace(GT_Log.err);
+        }
+
+        return true;
+    }
+
+    @Override
+    public void onLeftclick(EntityPlayer aPlayer) {
+        try {
+            if (aPlayer != null && hasValidMetaTileEntity()) mMetaTileEntity.onLeftclick(this, aPlayer);
+        } catch (Throwable e) {
+            GT_Log.err.println("Encountered Exception while leftclicking TileEntity, the Game should've crashed now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+            e.printStackTrace(GT_Log.err);
+        }
+    }
+
+    @Override
+    public boolean isDigitalChest() {
+        if (canAccessData()) return mMetaTileEntity.isDigitalChest();
+        return false;
+    }
+
+    @Override
+    public ItemStack[] getStoredItemData() {
+        if (canAccessData()) return mMetaTileEntity.getStoredItemData();
+        return null;
+    }
+
+    @Override
+    public void setItemCount(int aCount) {
+        if (canAccessData()) mMetaTileEntity.setItemCount(aCount);
+    }
+
+    @Override
+    public int getMaxItemCount() {
+        if (canAccessData()) return mMetaTileEntity.getMaxItemCount();
+        return 0;
+    }
+
+    /**
+     * Can put aStack into Slot
+     */
+    @Override
+    public boolean isItemValidForSlot(int aIndex, ItemStack aStack) {
+        return canAccessData() && mMetaTileEntity.isItemValidForSlot(aIndex, aStack);
+    }
+
+    /**
+     * returns all valid Inventory Slots, no matter which Side (Unless it's covered).
+     * The Side Stuff is done in the following two Functions.
+     */
+    @Override
+    public int[] getAccessibleSlotsFromSide(int aSide) {
+        if (canAccessData() && (getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), -1, this) || getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), -1, this)))
+            return mMetaTileEntity.getAccessibleSlotsFromSide(aSide);
+        return new int[0];
+    }
+
+    /**
+     * Can put aStack into Slot at Side
+     */
+    @Override
+    public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) {
+        return canAccessData() && (mRunningThroughTick || !mInputDisabled) && getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), aIndex, this) && mMetaTileEntity.canInsertItem(aIndex, aStack, aSide);
+    }
+
+    /**
+     * Can pull aStack out of Slot from Side
+     */
+    @Override
+    public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) {
+        return canAccessData() && (mRunningThroughTick || !mOutputDisabled) && getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), aIndex, this) && mMetaTileEntity.canExtractItem(aIndex, aStack, aSide);
+    }
+
+    @Override
+    public boolean isUpgradable() {
+        return canAccessData() && getUpgradeCount() < 8;
+    }
+
+    @Override
+    public byte getInternalInputRedstoneSignal(byte aSide) {
+        return (byte) (getCoverBehaviorAtSide(aSide).getRedstoneInput(aSide, getInputRedstoneSignal(aSide), getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this) & 15);
+    }
+
+    @Override
+    public byte getInputRedstoneSignal(byte aSide) {
+        return (byte) (worldObj.getIndirectPowerLevelTo(getOffsetX(aSide, 1), getOffsetY(aSide, 1), getOffsetZ(aSide, 1), aSide) & 15);
+    }
+
+    @Override
+    public byte getOutputRedstoneSignal(byte aSide) {
+        return getCoverBehaviorAtSide(aSide).manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this) ? mSidedRedstone[aSide] : 0;
+//		return (byte)(getCoverBehaviorAtSide(aSide).manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this) || (mRedstone && getCoverBehaviorAtSide(aSide).letsRedstoneGoOut(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))?mSidedRedstone[aSide]&15:0);
+    }
+
+    @Override
+    public void setInternalOutputRedstoneSignal(byte aSide, byte aStrength) {
+        if (!getCoverBehaviorAtSide(aSide).manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))
+            setOutputRedstoneSignal(aSide, aStrength);
+    }
+
+    @Override
+    public void setOutputRedstoneSignal(byte aSide, byte aStrength) {
+        aStrength = (byte) Math.min(Math.max(0, aStrength), 15);
+        if (aSide >= 0 && aSide < 6 && mSidedRedstone[aSide] != aStrength) {
+            mSidedRedstone[aSide] = aStrength;
+            issueBlockUpdate();
+        }
+    }
+
+    @Override
+    public boolean isSteamEngineUpgradable() {
+        return isUpgradable() && !hasSteamEngineUpgrade() && getSteamCapacity() > 0;
+    }
+
+    @Override
+    public boolean addSteamEngineUpgrade() {
+        if (isSteamEngineUpgradable()) {
+            issueBlockUpdate();
+            mSteamConverter = true;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean hasSteamEngineUpgrade() {
+        if (canAccessData() && mMetaTileEntity.isSteampowered()) return true;
+        return mSteamConverter;
+    }
+
+    @Override
+    public boolean hasMufflerUpgrade() {
+        return mMuffler;
+    }
+
+    @Override
+    public boolean isMufflerUpgradable() {
+        return isUpgradable() && !hasMufflerUpgrade();
+    }
+
+    @Override
+    public boolean addMufflerUpgrade() {
+        if (isMufflerUpgradable()) return mMuffler = true;
+        return false;
+    }
+
+    @Override
+    public boolean hasInventoryBeenModified() {
+        return mInventoryChanged;
+    }
+
+    @Override
+    public void setGenericRedstoneOutput(boolean aOnOff) {
+        mRedstone = aOnOff;
+    }
+
+    @Override
+    public int getErrorDisplayID() {
+        return mDisplayErrorCode;
+    }
+
+    @Override
+    public void setErrorDisplayID(int aErrorID) {
+        mDisplayErrorCode = aErrorID;
+    }
+
+    @Override
+    public IMetaTileEntity getMetaTileEntity() {
+        return hasValidMetaTileEntity() ? mMetaTileEntity : null;
+    }
+
+    @Override
+    public void setMetaTileEntity(IMetaTileEntity aMetaTileEntity) {
+        mMetaTileEntity = (MetaTileEntity) aMetaTileEntity;
+    }
+
+    @Override
+    public GT_CoverBehavior getCoverBehaviorAtSide(byte aSide) {
+        return aSide >= 0 && aSide < mCoverBehaviors.length ? mCoverBehaviors[aSide] : GregTech_API.sNoBehavior;
+    }
+
+    @Override
+    public void setCoverIDAtSide(byte aSide, int aID) {
+        if (aSide >= 0 && aSide < 6) {
+            mCoverSides[aSide] = aID;
+            mCoverData[aSide] = 0;
+            mCoverBehaviors[aSide] = GregTech_API.getCoverBehavior(aID);
+            issueCoverUpdate(aSide);
+            issueBlockUpdate();
+        }
+    }
+
+    @Override
+    public void setCoverItemAtSide(byte aSide, ItemStack aCover) {
+        GregTech_API.getCoverBehavior(aCover).placeCover(aSide, aCover, this);
+    }
+
+    @Override
+    public int getCoverIDAtSide(byte aSide) {
+        if (aSide >= 0 && aSide < 6) return mCoverSides[aSide];
+        return 0;
+    }
+
+    @Override
+    public ItemStack getCoverItemAtSide(byte aSide) {
+        return GT_Utility.intToStack(getCoverIDAtSide(aSide));
+    }
+
+    @Override
+    public boolean canPlaceCoverIDAtSide(byte aSide, int aID) {
+        return getCoverIDAtSide(aSide) == 0;
+    }
+
+    @Override
+    public boolean canPlaceCoverItemAtSide(byte aSide, ItemStack aCover) {
+        return getCoverIDAtSide(aSide) == 0;
+    }
+
+    @Override
+    public void setCoverDataAtSide(byte aSide, int aData) {
+        if (aSide >= 0 && aSide < 6) mCoverData[aSide] = aData;
+    }
+
+    @Override
+    public int getCoverDataAtSide(byte aSide) {
+        if (aSide >= 0 && aSide < 6) return mCoverData[aSide];
+        return 0;
+    }
+
+    public byte getLightValue() {
+        return mLightValue;
+    }
+
+    @Override
+    public void setLightValue(byte aLightValue) {
+        mLightValue = (byte) (aLightValue & 15);
+    }
+
+    @Override
+    public long getAverageElectricInput() {
+        int rEU = 0;
+        for (int tEU : mAverageEUInput) rEU += tEU;
+        return rEU / mAverageEUInput.length;
+    }
+
+    @Override
+    public long getAverageElectricOutput() {
+        int rEU = 0;
+        for (int tEU : mAverageEUOutput) rEU += tEU;
+        return rEU / mAverageEUOutput.length;
+    }
+
+    @Override
+    public boolean dropCover(byte aSide, byte aDroppedSide, boolean aForced) {
+        if (getCoverBehaviorAtSide(aSide).onCoverRemoval(aSide, getCoverIDAtSide(aSide), mCoverData[aSide], this, aForced) || aForced) {
+            ItemStack tStack = getCoverBehaviorAtSide(aSide).getDrop(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this);
+            if (tStack != null) {
+                tStack.setTagCompound(null);
+                EntityItem tEntity = new EntityItem(worldObj, getOffsetX(aDroppedSide, 1) + 0.5, getOffsetY(aDroppedSide, 1) + 0.5, getOffsetZ(aDroppedSide, 1) + 0.5, tStack);
+                tEntity.motionX = 0;
+                tEntity.motionY = 0;
+                tEntity.motionZ = 0;
+                worldObj.spawnEntityInWorld(tEntity);
+            }
+            setCoverIDAtSide(aSide, 0);
+            if (mMetaTileEntity.hasSidedRedstoneOutputBehavior()) {
+                setOutputRedstoneSignal(aSide, (byte) 0);
+            } else {
+                setOutputRedstoneSignal(aSide, (byte) 15);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public String getOwnerName() {
+        if (GT_Utility.isStringInvalid(mOwnerName)) return "Player";
+        return mOwnerName;
+    }
+
+    @Override
+    public String setOwnerName(String aName) {
+        if (GT_Utility.isStringInvalid(aName)) return mOwnerName = "Player";
+        return mOwnerName = aName;
+    }
+
+    @Override
+    public byte getComparatorValue(byte aSide) {
+        return canAccessData() ? mMetaTileEntity.getComparatorValue(aSide) : 0;
+    }
+
+    @Override
+    public byte getStrongOutputRedstoneSignal(byte aSide) {
+        return aSide >= 0 && aSide < 6 && (mStrongRedstone & (1 << aSide)) != 0 ? (byte) (mSidedRedstone[aSide] & 15) : 0;
+    }
+
+    @Override
+    public void setStrongOutputRedstoneSignal(byte aSide, byte aStrength) {
+        mStrongRedstone |= (1 << aSide);
+        setOutputRedstoneSignal(aSide, aStrength);
+    }
+
+    @Override
+    public ItemStack decrStackSize(int aIndex, int aAmount) {
+        if (canAccessData()) {
+            mInventoryChanged = true;
+            return mMetaTileEntity.decrStackSize(aIndex, aAmount);
+        }
+        return null;
+    }
+
+    @Override
+    public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+        if (!canAccessData() || !mMetaTileEntity.isElectric() || !inputEnergyFrom(aSide) || aAmperage <= 0 || aVoltage <= 0 || getStoredEU() >= getEUCapacity() || mMetaTileEntity.maxAmperesIn() <= mAcceptedAmperes)
+            return 0;
+        if (aVoltage > getInputVoltage()) {
+            doExplosion(aVoltage);
+            return 0;
+        }
+        if (increaseStoredEnergyUnits(aVoltage * (aAmperage = Math.min(aAmperage, Math.min(mMetaTileEntity.maxAmperesIn() - mAcceptedAmperes, 1 + ((getEUCapacity() - getStoredEU()) / aVoltage)))), true)) {
+            mAverageEUInput[mAverageEUInputIndex] += aVoltage * aAmperage;
+            mAcceptedAmperes += aAmperage;
+            return aAmperage;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+        if (!canAccessData() || !mMetaTileEntity.isElectric() || !outputsEnergyTo(aSide) || getStoredEU() - (aVoltage * aAmperage) < mMetaTileEntity.getMinimumStoredEU())
+            return false;
+        if (decreaseStoredEU(aVoltage * aAmperage, false)) {
+            mAverageEUOutput[mAverageEUOutputIndex] += aVoltage * aAmperage;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean acceptsRotationalEnergy(byte aSide) {
+        if (!canAccessData() || getCoverIDAtSide(aSide) != 0) return false;
+        return mMetaTileEntity.acceptsRotationalEnergy(aSide);
+    }
+
+    @Override
+    public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) {
+        if (!canAccessData() || getCoverIDAtSide(aSide) != 0) return false;
+        return mMetaTileEntity.injectRotationalEnergy(aSide, aSpeed, aEnergy);
+    }
+
+    @Override
+    public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mInputDisabled) && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidIn((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid == null ? null : aFluid.getFluid(), this))))
+            return mMetaTileEntity.fill(aSide, aFluid, doFill);
+        return 0;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), mMetaTileEntity.getFluid() == null ? null : mMetaTileEntity.getFluid().getFluid(), this))))
+            return mMetaTileEntity.drain(aSide, maxDrain, doDrain);
+        return null;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid == null ? null : aFluid.getFluid(), this))))
+            return mMetaTileEntity.drain(aSide, aFluid, doDrain);
+        return null;
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection aSide, Fluid aFluid) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mInputDisabled) && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidIn((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid, this))))
+            return mMetaTileEntity.canFill(aSide, aFluid);
+        return false;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection aSide, Fluid aFluid) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid, this))))
+            return mMetaTileEntity.canDrain(aSide, aFluid);
+        return false;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection aSide) {
+        if (canAccessData() && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidIn((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), null, this)) || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), null, this))))
+            return mMetaTileEntity.getTankInfo(aSide);
+        return new FluidTankInfo[]{};
+    }
+
+    public double getOutputEnergyUnitsPerTick() {
+        return oOutput;
+    }
+
+    public boolean isTeleporterCompatible(ForgeDirection aSide) {
+        return canAccessData() && mMetaTileEntity.isTeleporterCompatible();
+    }
+
+    public double demandedEnergyUnits() {
+        if (mReleaseEnergy || !canAccessData() || !mMetaTileEntity.isEnetInput()) return 0;
+        return getEUCapacity() - getStoredEU();
+    }
+
+    public double injectEnergyUnits(ForgeDirection aDirection, double aAmount) {
+        return injectEnergyUnits((byte) aDirection.ordinal(), (int) aAmount, 1) > 0 ? 0 : aAmount;
+    }
+
+    public boolean acceptsEnergyFrom(TileEntity aEmitter, ForgeDirection aDirection) {
+        return inputEnergyFrom((byte) aDirection.ordinal());
+    }
+
+    public boolean emitsEnergyTo(TileEntity aReceiver, ForgeDirection aDirection) {
+        return outputsEnergyTo((byte) aDirection.ordinal());
+    }
+
+    public double getOfferedEnergy() {
+        return (canAccessData() && getStoredEU() - mMetaTileEntity.getMinimumStoredEU() >= oOutput) ? Math.max(0, oOutput) : 0;
+    }
+
+    public void drawEnergy(double amount) {
+        mAverageEUOutput[mAverageEUOutputIndex] += amount;
+        decreaseStoredEU((int) amount, true);
+    }
+
+    public int injectEnergy(ForgeDirection aForgeDirection, int aAmount) {
+        return injectEnergyUnits((byte) aForgeDirection.ordinal(), aAmount, 1) > 0 ? 0 : aAmount;
+    }
+
+    public int addEnergy(int aEnergy) {
+        if (!canAccessData()) return 0;
+        if (aEnergy > 0)
+            increaseStoredEnergyUnits(aEnergy, true);
+        else
+            decreaseStoredEU(-aEnergy, true);
+        return (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getEUVar());
+    }
+
+    public boolean isAddedToEnergyNet() {
+        return false;
+    }
+
+    public int demandsEnergy() {
+        if (mReleaseEnergy || !canAccessData() || !mMetaTileEntity.isEnetInput()) return 0;
+        return getCapacity() - getStored();
+    }
+
+    public int getCapacity() {
+        return (int) Math.min(Integer.MAX_VALUE, getEUCapacity());
+    }
+
+    public int getStored() {
+        return (int) Math.min(Integer.MAX_VALUE, Math.min(getStoredEU(), getCapacity()));
+    }
+
+    public void setStored(int aEU) {
+        if (canAccessData()) setStoredEU(aEU);
+    }
+
+    public int getMaxSafeInput() {
+        return (int) Math.min(Integer.MAX_VALUE, getInputVoltage());
+    }
+
+    public int getMaxEnergyOutput() {
+        if (mReleaseEnergy) return Integer.MAX_VALUE;
+        return getOutput();
+    }
+
+    public int getOutput() {
+        return (int) Math.min(Integer.MAX_VALUE, oOutput);
+    }
+
+    public int injectEnergy(Direction aDirection, int aAmount) {
+        return injectEnergyUnits((byte) aDirection.toSideValue(), aAmount, 1) > 0 ? 0 : aAmount;
+    }
+
+    public boolean isTeleporterCompatible(Direction aSide) {
+        return canAccessData() && mMetaTileEntity.isTeleporterCompatible();
+    }
+
+    public boolean acceptsEnergyFrom(TileEntity aReceiver, Direction aDirection) {
+        return inputEnergyFrom((byte) aDirection.toSideValue());
+    }
+
+    public boolean emitsEnergyTo(TileEntity aReceiver, Direction aDirection) {
+        return outputsEnergyTo((byte) aDirection.toSideValue());
+    }
+
+    @Override
+    public boolean isInvalidTileEntity() {
+        return isInvalid();
+    }
+
+    @Override
+    public boolean addStackToSlot(int aIndex, ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack)) return true;
+        if (aIndex < 0 || aIndex >= getSizeInventory()) return false;
+        ItemStack tStack = getStackInSlot(aIndex);
+        if (GT_Utility.isStackInvalid(tStack)) {
+            setInventorySlotContents(aIndex, aStack);
+            return true;
+        }
+        aStack = GT_OreDictUnificator.get(aStack);
+        if (GT_Utility.areStacksEqual(tStack, aStack) && tStack.stackSize + aStack.stackSize <= Math.min(aStack.getMaxStackSize(), getInventoryStackLimit())) {
+            tStack.stackSize += aStack.stackSize;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean addStackToSlot(int aIndex, ItemStack aStack, int aAmount) {
+        return addStackToSlot(aIndex, GT_Utility.copyAmount(aAmount, aStack));
+    }
+
+    @Override
+    public byte getColorization() {
+        return (byte) (mColor - 1);
+    }
+
+    @Override
+    public byte setColorization(byte aColor) {
+        if (aColor > 15 || aColor < -1) aColor = -1;
+        if (canAccessData()) mMetaTileEntity.onColorChangeServer(aColor);
+        return mColor = (byte) (aColor + 1);
+    }
+
+    @Override
+    public float getBlastResistance(byte aSide) {
+        return canAccessData() ? Math.max(0, getMetaTileEntity().getExplosionResistance(aSide)) : 10.0F;
+    }
+
+    @Override
+    public boolean isUniversalEnergyStored(long aEnergyAmount) {
+        if (getUniversalEnergyStored() >= aEnergyAmount) return true;
+        mHasEnoughEnergy = false;
+        return false;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        {
+            if (canAccessData()) return getMetaTileEntity().getInfoData();
+            return new String[]{};
+        }
+    }
+
+    @Override
+    public void markDirty() {
+        super.markDirty();
+        mInventoryChanged = true;
+    }
+
+    @Override
+    public int getLightOpacity() {
+        return mMetaTileEntity == null ? getLightValue() > 0 ? 0 : 255 : mMetaTileEntity.getLightOpacity();
+    }
+
+    @Override
+    public void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB inputAABB, List<AxisAlignedBB> outputAABB, Entity collider) {
+        mMetaTileEntity.addCollisionBoxesToList(aWorld, aX, aY, aZ, inputAABB, outputAABB, collider);
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        return mMetaTileEntity.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity collider) {
+        mMetaTileEntity.onEntityCollidedWithBlock(aWorld, aX, aY, aZ, collider);
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaPipeEntity_BaseSuperConductor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaPipeEntity_BaseSuperConductor.java
new file mode 100644
index 0000000000..c48234cdb0
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaPipeEntity_BaseSuperConductor.java
@@ -0,0 +1,640 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless;
+
+import static gregtech.api.enums.GT_Values.GT;
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_Config;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Utility;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * Extend this Class to add a new MetaPipe
+ * Call the Constructor with the desired ID at the load-phase (not preload and also not postload!)
+ * Implement the newMetaEntity-Method to return a new ready instance of your MetaTileEntity
+ * <p/>
+ * Call the Constructor like the following example inside the Load Phase, to register it.
+ * "new GT_MetaTileEntity_E_Furnace(54, "GT_E_Furnace", "Automatic E-Furnace");"
+ */
+public abstract class GregtechMetaPipeEntity_BaseSuperConductor implements IMetaTileEntity {
+    /**
+     * The Inventory of the MetaTileEntity. Amount of Slots can be larger than 256. HAYO!
+     */
+    public final ItemStack[] mInventory;
+    /**
+     * This variable tells, which directions the Block is connected to. It is a Bitmask.
+     */
+    public byte mConnections = 0;
+    /**
+     * Only assigned for the MetaTileEntity in the List! Also only used to get the localized Name for the ItemStack and for getInvName.
+     */
+    public String mName;
+    public boolean doTickProfilingInThisTick = true;
+    /**
+     * accessibility to this Field is no longer given, see below
+     */
+    private IGregTechTileEntity mBaseMetaTileEntity;
+
+    /**
+     * This registers your Machine at the List.
+     * Use only ID's larger than 2048, because i reserved these ones.
+     * See also the List in the API, as it has a Description containing all the reservations.
+     *
+     * @param aID the ID
+     * @example for Constructor overload.
+     * <p/>
+     * public GT_MetaTileEntity_EBench(int aID, String mName, String mNameRegional) {
+     * super(aID, mName, mNameRegional);
+     * }
+     */
+    public GregtechMetaPipeEntity_BaseSuperConductor(int aID, String aBasicName, String aRegionalName, int aInvSlotCount) {
+        if (GregTech_API.sPostloadStarted || !GregTech_API.sPreloadStarted)
+            throw new IllegalAccessError("This Constructor has to be called in the load Phase");
+        if (GregTech_API.METATILEENTITIES[aID] == null) {
+            GregTech_API.METATILEENTITIES[aID] = this;
+        } else {
+            throw new IllegalArgumentException("MetaMachine-Slot Nr. " + aID + " is already occupied!");
+        }
+        mName = aBasicName.replaceAll(" ", "_").toLowerCase();
+        setBaseMetaTileEntity(new BaseMetaPipeEntity());
+        getBaseMetaTileEntity().setMetaTileID((short) aID);
+        GT_LanguageManager.addStringLocalization("gt.blockmachines." + mName + ".name", aRegionalName);
+        mInventory = new ItemStack[aInvSlotCount];
+
+        if (GT.isClientSide()) {
+            ItemStack tStack = new ItemStack(GregTech_API.sBlockMachines, 1, aID);
+            tStack.getItem().addInformation(tStack, null, new ArrayList<String>(), true);
+        }
+    }
+
+    /**
+     * This is the normal Constructor.
+     */
+    public GregtechMetaPipeEntity_BaseSuperConductor(String aName, int aInvSlotCount) {
+        mInventory = new ItemStack[aInvSlotCount];
+        mName = aName;
+    }
+
+    /**
+     * For Pipe Rendering
+     */
+    public abstract float getThickNess();
+
+    /**
+     * For Pipe Rendering
+     */
+    public abstract boolean renderInside(byte aSide);
+
+    @Override
+    public IGregTechTileEntity getBaseMetaTileEntity() {
+        return mBaseMetaTileEntity;
+    }
+
+    @Override
+    public void setBaseMetaTileEntity(IGregTechTileEntity aBaseMetaTileEntity) {
+        if (mBaseMetaTileEntity != null && aBaseMetaTileEntity == null) {
+            mBaseMetaTileEntity.getMetaTileEntity().inValidate();
+            mBaseMetaTileEntity.setMetaTileEntity(null);
+        }
+        mBaseMetaTileEntity = aBaseMetaTileEntity;
+        if (mBaseMetaTileEntity != null) {
+            mBaseMetaTileEntity.setMetaTileEntity(this);
+        }
+    }
+
+    @Override
+    public ItemStack getStackForm(long aAmount) {
+        return new ItemStack(GregTech_API.sBlockMachines, (int) aAmount, getBaseMetaTileEntity().getMetaTileID());
+    }
+
+    @Override
+    public void onServerStart() {/*Do nothing*/}
+
+    @Override
+    public void onWorldSave(File aSaveDirectory) {/*Do nothing*/}
+
+    @Override
+    public void onWorldLoad(File aSaveDirectory) {/*Do nothing*/}
+
+    @Override
+    public void onConfigLoad(GT_Config aConfig) {/*Do nothing*/}
+
+    @Override
+    public void setItemNBT(NBTTagCompound aNBT) {/*Do nothing*/}
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {/*Do nothing*/}
+
+    @Override
+    public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) {
+        return true;
+    }
+
+    @Override
+    public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {/*Do nothing*/}
+
+    @Override
+    public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        return false;
+    }
+
+    @Override
+    public void onExplosion() {/*Do nothing*/}
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {/*Do nothing*/}
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {/*Do nothing*/}
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {/*Do nothing*/}
+
+    @Override
+    public void inValidate() {/*Do nothing*/}
+
+    @Override
+    public void onRemoval() {/*Do nothing*/}
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {/*Do nothing*/}
+
+    /**
+     * When a GUI is opened
+     */
+    public void onOpenGUI() {/*Do nothing*/}
+
+    /**
+     * When a GUI is closed
+     */
+    public void onCloseGUI() {/*Do nothing*/}
+
+    /**
+     * a Player rightclicks the Machine
+     * Sneaky rightclicks are not getting passed to this!
+     */
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) {
+        return false;
+    }
+
+    @Override
+    public void onLeftclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {/*Do nothing*/}
+
+    @Override
+    public void onValueUpdate(byte aValue) {/*Do nothing*/}
+
+    @Override
+    public byte getUpdateData() {
+        return 0;
+    }
+
+    @Override
+    public void doSound(byte aIndex, double aX, double aY, double aZ) {/*Do nothing*/}
+
+    @Override
+    public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) {/*Do nothing*/}
+
+    @Override
+    public void stopSoundLoop(byte aValue, double aX, double aY, double aZ) {/*Do nothing*/}
+
+    @Override
+    public final void sendSound(byte aIndex) {
+        if (!getBaseMetaTileEntity().hasMufflerUpgrade()) getBaseMetaTileEntity().sendBlockEvent((byte) 4, aIndex);
+    }
+
+    @Override
+    public final void sendLoopStart(byte aIndex) {
+        if (!getBaseMetaTileEntity().hasMufflerUpgrade()) getBaseMetaTileEntity().sendBlockEvent((byte) 5, aIndex);
+    }
+
+    @Override
+    public final void sendLoopEnd(byte aIndex) {
+        if (!getBaseMetaTileEntity().hasMufflerUpgrade()) getBaseMetaTileEntity().sendBlockEvent((byte) 6, aIndex);
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return false;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return true;
+    }
+
+    @Override
+    public boolean setStackToZeroInsteadOfNull(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public ArrayList<String> getSpecialDebugInfo(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, int aLogLevel, ArrayList<String> aList) {
+        return aList;
+    }
+
+    @Override
+    public boolean isLiquidInput(byte aSide) {
+        return true;
+    }
+
+    @Override
+    public boolean isLiquidOutput(byte aSide) {
+        return true;
+    }
+
+    /**
+     * gets the contained Liquid
+     */
+    @Override
+    public FluidStack getFluid() {
+        return null;
+    }
+
+    /**
+     * tries to fill this Tank
+     */
+    @Override
+    public int fill(FluidStack resource, boolean doFill) {
+        return 0;
+    }
+
+    /**
+     * tries to empty this Tank
+     */
+    @Override
+    public FluidStack drain(int maxDrain, boolean doDrain) {
+        return null;
+    }
+
+    /**
+     * Tank pressure
+     */
+    public int getTankPressure() {
+        return 0;
+    }
+
+    /**
+     * Liquid Capacity
+     */
+    @Override
+    public int getCapacity() {
+        return 0;
+    }
+
+    /**
+     * Progress this machine has already made
+     */
+    public int getProgresstime() {
+        return 0;
+    }
+
+    /**
+     * Progress this Machine has to do to produce something
+     */
+    public int maxProgresstime() {
+        return 0;
+    }
+
+    /**
+     * Increases the Progress, returns the overflown Progress.
+     */
+    public int increaseProgress(int aProgress) {
+        return 0;
+    }
+
+    @Override
+    public void onMachineBlockUpdate() {/*Do nothing*/}
+
+    @Override
+    public void receiveClientEvent(byte aEventID, byte aValue) {/*Do nothing*/}
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public byte getComparatorValue(byte aSide) {
+        return 0;
+    }
+
+    @Override
+    public boolean acceptsRotationalEnergy(byte aSide) {
+        return false;
+    }
+
+    @Override
+    public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) {
+        return false;
+    }
+
+    @Override
+    public String getSpecialVoltageToolTip() {
+        return null;
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return false;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[]{};
+    }
+
+    public boolean isDigitalChest() {
+        return false;
+    }
+
+    public ItemStack[] getStoredItemData() {
+        return null;
+    }
+
+    public void setItemCount(int aCount) {/*Do nothing*/}
+
+    public int getMaxItemCount() {
+        return 0;
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return mInventory.length;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int aIndex) {
+        if (aIndex >= 0 && aIndex < mInventory.length) return mInventory[aIndex];
+        return null;
+    }
+
+    @Override
+    public void setInventorySlotContents(int aIndex, ItemStack aStack) {
+        if (aIndex >= 0 && aIndex < mInventory.length) mInventory[aIndex] = aStack;
+    }
+
+    @Override
+    public String getInventoryName() {
+        if (GregTech_API.METATILEENTITIES[getBaseMetaTileEntity().getMetaTileID()] != null)
+            return GregTech_API.METATILEENTITIES[getBaseMetaTileEntity().getMetaTileID()].getMetaName();
+        return "";
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 64;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int aIndex, ItemStack aStack) {
+        return getBaseMetaTileEntity().isValidSlot(aIndex);
+    }
+
+    @Override
+    public ItemStack decrStackSize(int aIndex, int aAmount) {
+        ItemStack tStack = getStackInSlot(aIndex), rStack = GT_Utility.copy(tStack);
+        if (tStack != null) {
+            if (tStack.stackSize <= aAmount) {
+                if (setStackToZeroInsteadOfNull(aIndex)) tStack.stackSize = 0;
+                else setInventorySlotContents(aIndex, null);
+            } else {
+                rStack = tStack.splitStack(aAmount);
+                if (tStack.stackSize == 0 && !setStackToZeroInsteadOfNull(aIndex))
+                    setInventorySlotContents(aIndex, null);
+            }
+        }
+        return rStack;
+    }
+
+    @Override
+    public int[] getAccessibleSlotsFromSide(int aSide) {
+        ArrayList<Integer> tList = new ArrayList<Integer>();
+        IGregTechTileEntity tTileEntity = getBaseMetaTileEntity();
+        boolean tSkip = tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), -2, tTileEntity) || tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), -2, tTileEntity);
+        for (int i = 0; i < getSizeInventory(); i++)
+            if (isValidSlot(i) && (tSkip || tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), i, tTileEntity) || tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), i, tTileEntity)))
+                tList.add(i);
+        int[] rArray = new int[tList.size()];
+        for (int i = 0; i < rArray.length; i++) rArray[i] = tList.get(i);
+        return rArray;
+    }
+
+    @Override
+    public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) {
+        return isValidSlot(aIndex) && aStack != null && aIndex < mInventory.length && (mInventory[aIndex] == null || GT_Utility.areStacksEqual(aStack, mInventory[aIndex])) && allowPutStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack);
+    }
+
+    @Override
+    public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) {
+        return isValidSlot(aIndex) && aStack != null && aIndex < mInventory.length && allowPullStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack);
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection aSide, Fluid aFluid) {
+        return fill(aSide, new FluidStack(aFluid, 1), false) == 1;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection aSide, Fluid aFluid) {
+        return drain(aSide, new FluidStack(aFluid, 1), false) != null;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection aSide) {
+        if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[]{};
+        return new FluidTankInfo[]{getInfo()};
+    }
+
+    public int fill_default(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+        return fill(aFluid, doFill);
+    }
+
+    @Override
+    public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+        return fill_default(aSide, aFluid, doFill);
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) {
+        if (getFluid() != null && aFluid != null && getFluid().isFluidEqual(aFluid))
+            return drain(aFluid.amount, doDrain);
+        return null;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) {
+        return drain(maxDrain, doDrain);
+    }
+
+    @Override
+    public int getFluidAmount() {
+        return 0;
+    }
+
+    @Override
+    public FluidTankInfo getInfo() {
+        return new FluidTankInfo(this);
+    }
+
+    @Override
+    public String getMetaName() {
+        return mName;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int i) {
+        return null;
+    }
+
+    @Override
+    public boolean doTickProfilingMessageDuringThisTick() {
+        return doTickProfilingInThisTick;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer entityplayer) {
+        return false;
+    }
+
+    @Override
+    public boolean connectsToItemPipe(byte aSide) {
+        return false;
+    }
+
+    @Override
+    public void openInventory() {
+        //
+    }
+
+    @Override
+    public void closeInventory() {
+        //
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return null;
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return null;
+    }
+
+    @Override
+    public float getExplosionResistance(byte aSide) {
+        return 10.0F;
+    }
+
+    @Override
+    public ItemStack[] getRealInventory() {
+        return mInventory;
+    }
+
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
+
+    @Override
+    public void markDirty() {
+        //
+    }
+
+    @Override
+    public void onColorChangeServer(byte aColor) {
+        //
+    }
+
+    @Override
+    public void onColorChangeClient(byte aColor) {
+        //
+    }
+
+    public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+        return 0;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean renderInInventory(Block aBlock, int aMeta, RenderBlocks aRenderer) {
+        return false;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean renderInWorld(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) {
+        return false;
+    }
+
+    @Override
+    public void doExplosion(long aExplosionPower) {
+        float tStrength = aExplosionPower < V[0] ? 1.0F : aExplosionPower < V[1] ? 2.0F : aExplosionPower < V[2] ? 3.0F : aExplosionPower < V[3] ? 4.0F : aExplosionPower < V[4] ? 5.0F : aExplosionPower < V[4] * 2 ? 6.0F : aExplosionPower < V[5] ? 7.0F : aExplosionPower < V[6] ? 8.0F : aExplosionPower < V[7] ? 9.0F : 10.0F;
+        int tX = getBaseMetaTileEntity().getXCoord(), tY = getBaseMetaTileEntity().getYCoord(), tZ = getBaseMetaTileEntity().getZCoord();
+        World tWorld = getBaseMetaTileEntity().getWorld();
+        tWorld.setBlock(tX, tY, tZ, Blocks.air);
+        if (GregTech_API.sMachineExplosions)
+            tWorld.createExplosion(null, tX + 0.5, tY + 0.5, tZ + 0.5, tStrength, true);
+    }
+
+    @Override
+    public int getLightOpacity() {
+        return 0;
+    }
+
+    @Override
+    public void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB inputAABB, List<AxisAlignedBB> outputAABB, Entity collider) {
+        AxisAlignedBB axisalignedbb1 = getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+        if (axisalignedbb1 != null && inputAABB.intersectsWith(axisalignedbb1)) outputAABB.add(axisalignedbb1);
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        return AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX + 1, aY + 1, aZ + 1);
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity collider) {
+        //
+    }
+
+    @Override
+    public void onCreated(ItemStack aStack, World aWorld, EntityPlayer aPlayer) {
+        //
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLossless.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLossless.java
new file mode 100644
index 0000000000..bc4403ec6d
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLossless.java
@@ -0,0 +1,66 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless;
+
+import static gregtech.api.enums.GT_Values.GT;
+import gregtech.api.interfaces.ITexture;
+import miscutil.core.lib.CORE;
+
+public abstract class GregtechMetaTileEntityLossless extends MetaTileEntityLossless {
+	/**
+	 * Value between [0 - 9] to describe the Tier of this Machine.
+	 */
+	public final byte mTier;
+	
+	/**
+	 * A simple Description.
+	 */
+	public final String mDescription;
+	
+	/**
+	 * Contains all Textures used by this Block.
+	 */
+	public final ITexture[][][] mTextures;
+	
+	public GregtechMetaTileEntityLossless(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription, ITexture... aTextures) {
+		super(aID, aName, aNameRegional, aInvSlotCount);
+		mTier = (byte)Math.max(0, Math.min(aTier, 9));
+		mDescription = aDescription;
+		
+		// must always be the last call!
+		if (GT.isClientSide()) mTextures = getTextureSet(aTextures); else mTextures = null;
+	}
+	
+	public GregtechMetaTileEntityLossless(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aInvSlotCount);
+		mTier = (byte)aTier;
+		mDescription = aDescription;
+		mTextures = aTextures;
+		
+	}
+	
+	@Override
+	public byte getTileEntityBaseType() {
+		return (byte)(Math.min(3, mTier<=0?0:1+((mTier-1) / 4)));
+	}
+	
+    @Override
+	public long getInputTier() {
+    	return mTier;
+    }
+    
+    @Override
+	public long getOutputTier() {
+    	return mTier;
+    }
+    
+	@Override
+	public String[] getDescription() {
+		return new String[] {mDescription, CORE.GT_Tooltip};
+	}
+	
+	/**
+	 * Used Client Side to get a Texture Set for this Block.
+	 * Called after setting the Tier and the Description so that those two are accessible.
+	 * @param aTextures is the optional Array you can give to the Constructor.
+	 */
+	public abstract ITexture[][][] getTextureSet(ITexture[] aTextures);
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessBasicTank.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessBasicTank.java
new file mode 100644
index 0000000000..507bd4de94
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessBasicTank.java
@@ -0,0 +1,251 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.gui.GT_Container_BasicTank;
+import gregtech.api.gui.GT_GUIContainer_BasicTank;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Utility;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * This is the main construct for my generic Tanks. Filling and emptying behavior have to be implemented manually
+ */
+public abstract class GregtechMetaTileEntityLosslessBasicTank extends GregtechMetaTileEntityLosslessTieredMachineBlock {
+
+    public FluidStack mFluid;
+
+    /**
+     * @param aInvSlotCount should be 3
+     */
+    public GregtechMetaTileEntityLosslessBasicTank(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription, ITexture... aTextures) {
+        super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    public GregtechMetaTileEntityLosslessBasicTank(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex != getStackDisplaySlot();
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        if (mFluid != null) aNBT.setTag("mFluid", mFluid.writeToNBT(new NBTTagCompound()));
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        mFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluid"));
+    }
+
+    public abstract boolean doesFillContainers();
+
+    public abstract boolean doesEmptyContainers();
+
+    public abstract boolean canTankBeFilled();
+
+    public abstract boolean canTankBeEmptied();
+
+    public abstract boolean displaysItemStack();
+
+    public abstract boolean displaysStackSize();
+
+    public int getInputSlot() {
+        return 0;
+    }
+
+    public int getOutputSlot() {
+        return 1;
+    }
+
+    public int getStackDisplaySlot() {
+        return 2;
+    }
+
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return true;
+    }
+
+    public boolean isFluidChangingAllowed() {
+        return true;
+    }
+
+    public FluidStack getFillableStack() {
+        return mFluid;
+    }
+
+    public FluidStack setFillableStack(FluidStack aFluid) {
+        mFluid = aFluid;
+        return mFluid;
+    }
+
+    public FluidStack getDrainableStack() {
+        return mFluid;
+    }
+
+    public FluidStack setDrainableStack(FluidStack aFluid) {
+        mFluid = aFluid;
+        return mFluid;
+    }
+
+    public FluidStack getDisplayedFluid() {
+        return getDrainableStack();
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_Container_BasicTank(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_BasicTank(aPlayerInventory, aBaseMetaTileEntity, getLocalName());
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (isFluidChangingAllowed() && getFillableStack() != null && getFillableStack().amount <= 0)
+                setFillableStack(null);
+
+            if (displaysItemStack() && getStackDisplaySlot() >= 0 && getStackDisplaySlot() < mInventory.length) {
+                if (getDisplayedFluid() == null) {
+                    if (ItemList.Display_Fluid.isStackEqual(mInventory[getStackDisplaySlot()], true, true))
+                        mInventory[getStackDisplaySlot()] = null;
+                } else {
+                    mInventory[getStackDisplaySlot()] = GT_Utility.getFluidDisplayStack(getDisplayedFluid(), displaysStackSize());
+                }
+            }
+
+            if (doesEmptyContainers()) {
+                FluidStack tFluid = GT_Utility.getFluidForFilledItem(mInventory[getInputSlot()], true);
+                if (tFluid != null && isFluidInputAllowed(tFluid)) {
+                    if (getFillableStack() == null) {
+                        if (isFluidInputAllowed(tFluid) && tFluid.amount <= getCapacity()) {
+                            if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), GT_Utility.getContainerItem(mInventory[getInputSlot()], true), 1)) {
+                                setFillableStack(tFluid.copy());
+                                aBaseMetaTileEntity.decrStackSize(getInputSlot(), 1);
+                            }
+                        }
+                    } else {
+                        if (tFluid.isFluidEqual(getFillableStack()) && tFluid.amount + getFillableStack().amount <= getCapacity()) {
+                            if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), GT_Utility.getContainerItem(mInventory[getInputSlot()], true), 1)) {
+                                getFillableStack().amount += tFluid.amount;
+                                aBaseMetaTileEntity.decrStackSize(getInputSlot(), 1);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (doesFillContainers()) {
+                ItemStack tOutput = GT_Utility.fillFluidContainer(getDrainableStack(), mInventory[getInputSlot()], false, true);
+                if (tOutput != null && aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), tOutput, 1)) {
+                    FluidStack tFluid = GT_Utility.getFluidForFilledItem(tOutput, true);
+                    aBaseMetaTileEntity.decrStackSize(getInputSlot(), 1);
+                    if (tFluid != null) getDrainableStack().amount -= tFluid.amount;
+                    if (getDrainableStack().amount <= 0 && isFluidChangingAllowed()) setDrainableStack(null);
+                }
+            }
+        }
+    }
+
+    @Override
+    public FluidStack getFluid() {
+        return getDrainableStack();
+    }
+
+    @Override
+    public int getFluidAmount() {
+        return getDrainableStack() != null ? getDrainableStack().amount : 0;
+    }
+
+    @Override
+    public int fill(FluidStack aFluid, boolean doFill) {
+        if (aFluid == null || aFluid.getFluid().getID() <= 0 || aFluid.amount <= 0 || !canTankBeFilled() || !isFluidInputAllowed(aFluid))
+            return 0;
+
+        if (getFillableStack() == null || getFillableStack().getFluid().getID() <= 0) {
+            if (aFluid.amount <= getCapacity()) {
+                if (doFill) {
+                    setFillableStack(aFluid.copy());
+                    getBaseMetaTileEntity().markDirty();
+                }
+                return aFluid.amount;
+            }
+            if (doFill) {
+                setFillableStack(aFluid.copy());
+                getFillableStack().amount = getCapacity();
+                getBaseMetaTileEntity().markDirty();
+            }
+            return getCapacity();
+        }
+
+        if (!getFillableStack().isFluidEqual(aFluid))
+            return 0;
+
+        int space = getCapacity() - getFillableStack().amount;
+        if (aFluid.amount <= space) {
+            if (doFill) {
+                getFillableStack().amount += aFluid.amount;
+                getBaseMetaTileEntity().markDirty();
+            }
+            return aFluid.amount;
+        }
+        if (doFill)
+            getFillableStack().amount = getCapacity();
+        return space;
+    }
+
+    @Override
+    public FluidStack drain(int maxDrain, boolean doDrain) {
+        if (getDrainableStack() == null || !canTankBeEmptied()) return null;
+        if (getDrainableStack().amount <= 0 && isFluidChangingAllowed()) {
+            setDrainableStack(null);
+            getBaseMetaTileEntity().markDirty();
+            return null;
+        }
+
+        int used = maxDrain;
+        if (getDrainableStack().amount < used)
+            used = getDrainableStack().amount;
+
+        if (doDrain) {
+            getDrainableStack().amount -= used;
+            getBaseMetaTileEntity().markDirty();
+        }
+
+        FluidStack drained = getDrainableStack().copy();
+        drained.amount = used;
+
+        if (getDrainableStack().amount <= 0 && isFluidChangingAllowed()) {
+            setDrainableStack(null);
+            getBaseMetaTileEntity().markDirty();
+        }
+
+        return drained;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return aIndex == getOutputSlot();
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return aIndex == getInputSlot();
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessTieredMachineBlock.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessTieredMachineBlock.java
new file mode 100644
index 0000000000..a092f85f7a
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessTieredMachineBlock.java
@@ -0,0 +1,67 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless;
+
+import static gregtech.api.enums.GT_Values.GT;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.metatileentity.MetaTileEntity;
+
+public abstract class GregtechMetaTileEntityLosslessTieredMachineBlock extends MetaTileEntity {
+    /**
+     * Value between [0 - 9] to describe the Tier of this Machine.
+     */
+    public final byte mTier;
+
+    /**
+     * A simple Description.
+     */
+    public final String mDescription;
+
+    /**
+     * Contains all Textures used by this Block.
+     */
+    public final ITexture[][][] mTextures;
+
+    public GregtechMetaTileEntityLosslessTieredMachineBlock(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription, ITexture... aTextures) {
+        super(aID, aName, aNameRegional, aInvSlotCount);
+        mTier = (byte) Math.max(0, Math.min(aTier, 9));
+        mDescription = aDescription;
+
+        // must always be the last call!
+        if (GT.isClientSide()) mTextures = getTextureSet(aTextures);
+        else mTextures = null;
+    }
+
+    public GregtechMetaTileEntityLosslessTieredMachineBlock(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aInvSlotCount);
+        mTier = (byte) aTier;
+        mDescription = aDescription;
+        mTextures = aTextures;
+    }
+
+    @Override
+    public byte getTileEntityBaseType() {
+        return (byte) (Math.min(3, mTier <= 0 ? 0 : 1 + ((mTier - 1) / 4)));
+    }
+
+    @Override
+    public long getInputTier() {
+        return mTier;
+    }
+
+    @Override
+    public long getOutputTier() {
+        return mTier;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[]{mDescription};
+    }
+
+    /**
+     * Used Client Side to get a Texture Set for this Block.
+     * Called after setting the Tier and the Description so that those two are accessible.
+     *
+     * @param aTextures is the optional Array you can give to the Constructor.
+     */
+    public abstract ITexture[][][] getTextureSet(ITexture[] aTextures);
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/MetaTileEntityLossless.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/MetaTileEntityLossless.java
new file mode 100644
index 0000000000..75919f76e4
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/MetaTileEntityLossless.java
@@ -0,0 +1,865 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless;
+
+import static gregtech.api.enums.GT_Values.GT;
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_Config;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Utility;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * Extend this Class to add a new MetaMachine
+ * Call the Constructor with the desired ID at the load-phase (not preload and also not postload!)
+ * Implement the newMetaEntity-Method to return a new ready instance of your MetaTileEntity
+ * <p/>
+ * Call the Constructor like the following example inside the Load Phase, to register it.
+ * "new GT_MetaTileEntity_E_Furnace(54, "GT_E_Furnace", "Automatic E-Furnace");"
+ */
+public abstract class MetaTileEntityLossless implements IMetaTileEntity {
+    /**
+     * Only assigned for the MetaTileEntity in the List! Also only used to get the localized Name for the ItemStack and for getInvName.
+     */
+    public final String mName;
+    /**
+     * The Inventory of the MetaTileEntity. Amount of Slots can be larger than 256. HAYO!
+     */
+    public final ItemStack[] mInventory;
+    public boolean doTickProfilingInThisTick = true;
+    /**
+     * accessibility to this Field is no longer given, see below
+     */
+    private IGregTechTileEntity mBaseMetaTileEntity;
+
+    /**
+     * This registers your Machine at the List.
+     * Use only ID's larger than 2048, because i reserved these ones.
+     * See also the List in the API, as it has a Description containing all the reservations.
+     *
+     * @param aID the ID
+     * @example for Constructor overload.
+     * <p/>
+     * public GT_MetaTileEntity_EBench(int aID, String mName, String mNameRegional) {
+     * super(aID, mName, mNameRegional);
+     * }
+     */
+    public MetaTileEntityLossless(int aID, String aBasicName, String aRegionalName, int aInvSlotCount) {
+        if (GregTech_API.sPostloadStarted || !GregTech_API.sPreloadStarted)
+            throw new IllegalAccessError("This Constructor has to be called in the load Phase");
+        if (GregTech_API.METATILEENTITIES[aID] == null) {
+            GregTech_API.METATILEENTITIES[aID] = this;
+        } else {
+            throw new IllegalArgumentException("MetaMachine-Slot Nr. " + aID + " is already occupied!");
+        }
+        mName = aBasicName.replaceAll(" ", "_").toLowerCase();
+        setBaseMetaTileEntity(GregTech_API.constructBaseMetaTileEntity());
+        getBaseMetaTileEntity().setMetaTileID((short) aID);
+        GT_LanguageManager.addStringLocalization("gt.blockmachines." + mName + ".name", aRegionalName);
+        mInventory = new ItemStack[aInvSlotCount];
+
+        if (GT.isClientSide()) {
+            ItemStack tStack = new ItemStack(GregTech_API.sBlockMachines, 1, aID);
+            tStack.getItem().addInformation(tStack, null, new ArrayList<String>(), true);
+        }
+    }
+
+    /**
+     * This is the normal Constructor.
+     */
+    public MetaTileEntityLossless(String aName, int aInvSlotCount) {
+        mInventory = new ItemStack[aInvSlotCount];
+        mName = aName;
+    }
+
+    @Override
+    public IGregTechTileEntity getBaseMetaTileEntity() {
+        return mBaseMetaTileEntity;
+    }
+
+    @Override
+    public void setBaseMetaTileEntity(IGregTechTileEntity aBaseMetaTileEntity) {
+        if (mBaseMetaTileEntity != null && aBaseMetaTileEntity == null) {
+            mBaseMetaTileEntity.getMetaTileEntity().inValidate();
+            mBaseMetaTileEntity.setMetaTileEntity(null);
+        }
+        mBaseMetaTileEntity = aBaseMetaTileEntity;
+        if (mBaseMetaTileEntity != null) {
+            mBaseMetaTileEntity.setMetaTileEntity(this);
+        }
+    }
+
+    @Override
+    public ItemStack getStackForm(long aAmount) {
+        return new ItemStack(GregTech_API.sBlockMachines, (int) aAmount, getBaseMetaTileEntity().getMetaTileID());
+    }
+
+    public String getLocalName() {
+        return GT_LanguageManager.getTranslation("gt.blockmachines." + mName + ".name");
+    }
+
+    @Override
+    public void onServerStart() {/*Do nothing*/}
+
+    @Override
+    public void onWorldSave(File aSaveDirectory) {/*Do nothing*/}
+
+    @Override
+    public void onWorldLoad(File aSaveDirectory) {/*Do nothing*/}
+
+    @Override
+    public void onConfigLoad(GT_Config aConfig) {/*Do nothing*/}
+
+    @Override
+    public void setItemNBT(NBTTagCompound aNBT) {/*Do nothing*/}
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {/*Do nothing*/}
+
+    @Override
+    public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {/*Do nothing*/}
+
+    @Override
+    public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (getBaseMetaTileEntity().isValidFacing(aWrenchingSide)) {
+            getBaseMetaTileEntity().setFrontFacing(aWrenchingSide);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onExplosion() {/*Do nothing*/}
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {/*Do nothing*/}
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {/*Do nothing*/}
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {/*Do nothing*/}
+
+    @Override
+    public void inValidate() {/*Do nothing*/}
+
+    @Override
+    public void onRemoval() {/*Do nothing*/}
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {/*Do nothing*/}
+
+    /**
+     * When a GUI is opened
+     */
+    public void onOpenGUI() {/*Do nothing*/}
+
+    /**
+     * When a GUI is closed
+     */
+    public void onCloseGUI() {/*Do nothing*/}
+
+    /**
+     * a Player rightclicks the Machine
+     * Sneaky rightclicks are not getting passed to this!
+     */
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        return false;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) {
+        return onRightclick(aBaseMetaTileEntity, aPlayer);
+    }
+
+    @Override
+    public void onLeftclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {/*Do nothing*/}
+
+    @Override
+    public void onValueUpdate(byte aValue) {/*Do nothing*/}
+
+    @Override
+    public byte getUpdateData() {
+        return 0;
+    }
+
+    @Override
+    public void doSound(byte aIndex, double aX, double aY, double aZ) {/*Do nothing*/}
+
+    @Override
+    public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) {/*Do nothing*/}
+
+    @Override
+    public void stopSoundLoop(byte aValue, double aX, double aY, double aZ) {/*Do nothing*/}
+
+    @Override
+    public final void sendSound(byte aIndex) {
+        if (!getBaseMetaTileEntity().hasMufflerUpgrade()) getBaseMetaTileEntity().sendBlockEvent((byte) 4, aIndex);
+    }
+
+    @Override
+    public final void sendLoopStart(byte aIndex) {
+        if (!getBaseMetaTileEntity().hasMufflerUpgrade()) getBaseMetaTileEntity().sendBlockEvent((byte) 5, aIndex);
+    }
+
+    @Override
+    public final void sendLoopEnd(byte aIndex) {
+        if (!getBaseMetaTileEntity().hasMufflerUpgrade()) getBaseMetaTileEntity().sendBlockEvent((byte) 6, aIndex);
+    }
+
+    /**
+     * @return true if this Device emits Energy at all
+     */
+    public boolean isElectric() {
+        return true;
+    }
+
+    /**
+     * @return true if this Device emits Energy at all
+     */
+    public boolean isPneumatic() {
+        return false;
+    }
+
+    /**
+     * @return true if this Device emits Energy at all
+     */
+    public boolean isSteampowered() {
+        return false;
+    }
+
+    /**
+     * @return true if this Device emits Energy at all
+     */
+    public boolean isEnetOutput() {
+        return false;
+    }
+
+    /**
+     * @return true if this Device consumes Energy at all
+     */
+    public boolean isEnetInput() {
+        return false;
+    }
+
+    /**
+     * @return the amount of EU, which can be stored in this Device. Default is 0 EU.
+     */
+    public long maxEUStore() {
+        return 0;
+    }
+
+    /**
+     * @return the amount of EU/t, which can be accepted by this Device before it explodes.
+     */
+    public long maxEUInput() {
+        return 0;
+    }
+
+    /**
+     * @return the amount of EU/t, which can be outputted by this Device.
+     */
+    public long maxEUOutput() {
+        return 0;
+    }
+
+    /**
+     * @return the amount of E-net Impulses of the maxEUOutput size, which can be outputted by this Device.
+     * Default is 1 Pulse, this shouldn't be set to smaller Values than 1, as it won't output anything in that Case!
+     */
+    public long maxAmperesOut() {
+        return 1;
+    }
+
+    /**
+     * How many Amperes this Block can suck at max. Surpassing this value won't blow it up.
+     */
+    public long maxAmperesIn() {
+        return 1;
+    }
+
+    /**
+     * @return true if that Side is an Output.
+     */
+    public boolean isOutputFacing(byte aSide) {
+        return false;
+    }
+
+    /**
+     * @return true if that Side is an Input.
+     */
+    public boolean isInputFacing(byte aSide) {
+        return false;
+    }
+
+    /**
+     * @return true if Transformer Upgrades increase Packet Amount.
+     */
+    public boolean isTransformingLowEnergy() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return false;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return true;
+    }
+
+    @Override
+    public boolean setStackToZeroInsteadOfNull(int aIndex) {
+        return false;
+    }
+
+    /**
+     * This is used to get the internal Energy. I use this for the IDSU.
+     */
+    public long getEUVar() {
+        return ((GregtechBaseMetaTileEntityLossless) mBaseMetaTileEntity).mStoredEnergy;
+    }
+
+    /**
+     * This is used to set the internal Energy to the given Parameter. I use this for the IDSU.
+     */
+    public void setEUVar(long aEnergy) {
+        ((GregtechBaseMetaTileEntityLossless) mBaseMetaTileEntity).mStoredEnergy = aEnergy;
+    }
+
+    /**
+     * This is used to get the internal Steam Energy.
+     */
+    public long getSteamVar() {
+        return ((GregtechBaseMetaTileEntityLossless) mBaseMetaTileEntity).mStoredSteam;
+    }
+
+    /**
+     * This is used to set the internal Steam Energy to the given Parameter.
+     */
+    public void setSteamVar(long aSteam) {
+        ((GregtechBaseMetaTileEntityLossless) mBaseMetaTileEntity).mStoredSteam = aSteam;
+    }
+
+    /**
+     * @return the amount of Steam, which can be stored in this Device. Default is 0 EU.
+     */
+    public long maxSteamStore() {
+        return 0;
+    }
+
+    /**
+     * @return the amount of EU, which this Device stores before starting to emit Energy.
+     * useful if you don't want to emit stored Energy until a certain Level is reached.
+     */
+    public long getMinimumStoredEU() {
+        return 512;
+    }
+
+    /**
+     * Determines the Tier of the Machine, used for de-charging Tools.
+     */
+    public long getInputTier() {
+        return GT_Utility.getTier(getBaseMetaTileEntity().getInputVoltage());
+    }
+
+    /**
+     * Determines the Tier of the Machine, used for charging Tools.
+     */
+    public long getOutputTier() {
+        return GT_Utility.getTier(getBaseMetaTileEntity().getOutputVoltage());
+    }
+
+    /**
+     * gets the first RechargerSlot
+     */
+    public int rechargerSlotStartIndex() {
+        return 0;
+    }
+
+    /**
+     * gets the amount of RechargerSlots
+     */
+    public int rechargerSlotCount() {
+        return 0;
+    }
+
+    /**
+     * gets the first DechargerSlot
+     */
+    public int dechargerSlotStartIndex() {
+        return 0;
+    }
+
+    /**
+     * gets the amount of DechargerSlots
+     */
+    public int dechargerSlotCount() {
+        return 0;
+    }
+
+    /**
+     * gets if this is protected from other Players per default or not
+     */
+    public boolean ownerControl() {
+        return false;
+    }
+
+    @Override
+    public ArrayList<String> getSpecialDebugInfo(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, int aLogLevel, ArrayList<String> aList) {
+        return aList;
+    }
+
+    @Override
+    public boolean isLiquidInput(byte aSide) {
+        return true;
+    }
+
+    @Override
+    public boolean isLiquidOutput(byte aSide) {
+        return true;
+    }
+
+    /**
+     * gets the contained Liquid
+     */
+    @Override
+    public FluidStack getFluid() {
+        return null;
+    }
+
+    /**
+     * tries to fill this Tank
+     */
+    @Override
+    public int fill(FluidStack resource, boolean doFill) {
+        return 0;
+    }
+
+    /**
+     * tries to empty this Tank
+     */
+    @Override
+    public FluidStack drain(int maxDrain, boolean doDrain) {
+        return null;
+    }
+
+    /**
+     * Tank pressure
+     */
+    public int getTankPressure() {
+        return 0;
+    }
+
+    /**
+     * Liquid Capacity
+     */
+    @Override
+    public int getCapacity() {
+        return 0;
+    }
+
+    @Override
+    public void onMachineBlockUpdate() {/*Do nothing*/}
+
+    @Override
+    public void receiveClientEvent(byte aEventID, byte aValue) {/*Do nothing*/}
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    /**
+     * If this accepts up to 4 Overclockers
+     */
+    public boolean isOverclockerUpgradable() {
+        return false;
+    }
+
+    /**
+     * If this accepts Transformer Upgrades
+     */
+    public boolean isTransformerUpgradable() {
+        return false;
+    }
+
+    /**
+     * Progress this machine has already made
+     */
+    public int getProgresstime() {
+        return 0;
+    }
+
+    /**
+     * Progress this Machine has to do to produce something
+     */
+    public int maxProgresstime() {
+        return 0;
+    }
+
+    /**
+     * Increases the Progress, returns the overflown Progress.
+     */
+    public int increaseProgress(int aProgress) {
+        return 0;
+    }
+
+    /**
+     * If this TileEntity makes use of Sided Redstone behaviors.
+     * Determines only, if the Output Redstone Array is getting filled with 0 for true, or 15 for false.
+     */
+    public boolean hasSidedRedstoneOutputBehavior() {
+        return false;
+    }
+
+    /**
+     * When the Facing gets changed.
+     */
+    public void onFacingChange() {/*Do nothing*/}
+
+    /**
+     * if the IC2 Teleporter can drain from this.
+     */
+    public boolean isTeleporterCompatible() {
+        return isEnetOutput() && getBaseMetaTileEntity().getOutputVoltage() >= 128 && getBaseMetaTileEntity().getUniversalEnergyCapacity() >= 500000;
+    }
+
+    /**
+     * Gets the Output for the comparator on the given Side
+     */
+    @Override
+    public byte getComparatorValue(byte aSide) {
+        return 0;
+    }
+
+    @Override
+    public boolean acceptsRotationalEnergy(byte aSide) {
+        return false;
+    }
+
+    @Override
+    public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) {
+        return false;
+    }
+
+    @Override
+    public String getSpecialVoltageToolTip() {
+        return null;
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return false;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[]{};
+    }
+
+    public boolean isDigitalChest() {
+        return false;
+    }
+
+    public ItemStack[] getStoredItemData() {
+        return null;
+    }
+
+    public void setItemCount(int aCount) {/*Do nothing*/}
+
+    public int getMaxItemCount() {
+        return 0;
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return mInventory.length;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int aIndex) {
+        if (aIndex >= 0 && aIndex < mInventory.length) return mInventory[aIndex];
+        return null;
+    }
+
+    @Override
+    public void setInventorySlotContents(int aIndex, ItemStack aStack) {
+        if (aIndex >= 0 && aIndex < mInventory.length) mInventory[aIndex] = aStack;
+    }
+
+    @Override
+    public String getInventoryName() {
+        if (GregTech_API.METATILEENTITIES[getBaseMetaTileEntity().getMetaTileID()] != null)
+            return GregTech_API.METATILEENTITIES[getBaseMetaTileEntity().getMetaTileID()].getMetaName();
+        return "";
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 64;
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int aIndex, ItemStack aStack) {
+        return getBaseMetaTileEntity().isValidSlot(aIndex);
+    }
+
+    @Override
+    public ItemStack decrStackSize(int aIndex, int aAmount) {
+        ItemStack tStack = getStackInSlot(aIndex), rStack = GT_Utility.copy(tStack);
+        if (tStack != null) {
+            if (tStack.stackSize <= aAmount) {
+                if (setStackToZeroInsteadOfNull(aIndex)) tStack.stackSize = 0;
+                else setInventorySlotContents(aIndex, null);
+            } else {
+                rStack = tStack.splitStack(aAmount);
+                if (tStack.stackSize == 0 && !setStackToZeroInsteadOfNull(aIndex))
+                    setInventorySlotContents(aIndex, null);
+            }
+        }
+        return rStack;
+    }
+
+    @Override
+    public int[] getAccessibleSlotsFromSide(int aSide) {
+        ArrayList<Integer> tList = new ArrayList<Integer>();
+        IGregTechTileEntity tTileEntity = getBaseMetaTileEntity();
+        boolean tSkip = tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), -2, tTileEntity) || tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), -2, tTileEntity);
+        for (int i = 0; i < getSizeInventory(); i++)
+            if (isValidSlot(i) && (tSkip || tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), i, tTileEntity) || tTileEntity.getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, tTileEntity.getCoverIDAtSide((byte) aSide), tTileEntity.getCoverDataAtSide((byte) aSide), i, tTileEntity)))
+                tList.add(i);
+        int[] rArray = new int[tList.size()];
+        for (int i = 0; i < rArray.length; i++) rArray[i] = tList.get(i);
+        return rArray;
+    }
+
+    @Override
+    public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) {
+        return isValidSlot(aIndex) && aStack != null && aIndex < mInventory.length && (mInventory[aIndex] == null || GT_Utility.areStacksEqual(aStack, mInventory[aIndex])) && allowPutStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack);
+    }
+
+    @Override
+    public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) {
+        return isValidSlot(aIndex) && aStack != null && aIndex < mInventory.length && allowPullStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack);
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection aSide, Fluid aFluid) {
+        return fill(aSide, new FluidStack(aFluid, 1), false) == 1;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection aSide, Fluid aFluid) {
+        return drain(aSide, new FluidStack(aFluid, 1), false) != null;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection aSide) {
+        if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[]{};
+        return new FluidTankInfo[]{getInfo()};
+    }
+
+    public int fill_default(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+        return fill(aFluid, doFill);
+    }
+
+    @Override
+    public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+        if (getBaseMetaTileEntity().hasSteamEngineUpgrade() && GT_ModHandler.isSteam(aFluid) && aFluid.amount > 1) {
+            int tSteam = (int) Math.min(Integer.MAX_VALUE, Math.min(aFluid.amount / 2, getBaseMetaTileEntity().getSteamCapacity() - getBaseMetaTileEntity().getStoredSteam()));
+            if (tSteam > 0) {
+                if (doFill) getBaseMetaTileEntity().increaseStoredSteam(tSteam, true);
+                return tSteam * 2;
+            }
+        } else {
+            return fill_default(aSide, aFluid, doFill);
+        }
+        return 0;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) {
+        if (getFluid() != null && aFluid != null && getFluid().isFluidEqual(aFluid))
+            return drain(aFluid.amount, doDrain);
+        return null;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) {
+        return drain(maxDrain, doDrain);
+    }
+
+    @Override
+    public int getFluidAmount() {
+        return 0;
+    }
+
+    @Override
+    public FluidTankInfo getInfo() {
+        return new FluidTankInfo(this);
+    }
+
+    @Override
+    public String getMetaName() {
+        return mName;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int i) {
+        return null;
+    }
+
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
+
+    @Override
+    public boolean doTickProfilingMessageDuringThisTick() {
+        return doTickProfilingInThisTick;
+    }
+
+    @Override
+    public void markDirty() {
+        //
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer entityplayer) {
+        return false;
+    }
+
+    @Override
+    public void openInventory() {
+        //
+    }
+
+    @Override
+    public void closeInventory() {
+        //
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return null;
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return null;
+    }
+
+    @Override
+    public boolean connectsToItemPipe(byte aSide) {
+        return false;
+    }
+
+    @Override
+    public float getExplosionResistance(byte aSide) {
+        return 10.0F;
+    }
+
+    @Override
+    public ItemStack[] getRealInventory() {
+        return mInventory;
+    }
+
+    @Override
+    public void onColorChangeServer(byte aColor) {
+        //
+    }
+
+    @Override
+    public void onColorChangeClient(byte aColor) {
+        //
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean renderInInventory(Block aBlock, int aMeta, RenderBlocks aRenderer) {
+        return false;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean renderInWorld(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) {
+        return false;
+    }
+
+    @Override
+    public void doExplosion(long aExplosionPower) {
+        float tStrength = aExplosionPower < V[0] ? 1.0F : aExplosionPower < V[1] ? 2.0F : aExplosionPower < V[2] ? 3.0F : aExplosionPower < V[3] ? 4.0F : aExplosionPower < V[4] ? 5.0F : aExplosionPower < V[4] * 2 ? 6.0F : aExplosionPower < V[5] ? 7.0F : aExplosionPower < V[6] ? 8.0F : aExplosionPower < V[7] ? 9.0F : 10.0F;
+        int tX = getBaseMetaTileEntity().getXCoord(), tY = getBaseMetaTileEntity().getYCoord(), tZ = getBaseMetaTileEntity().getZCoord();
+        World tWorld = getBaseMetaTileEntity().getWorld();
+        GT_Utility.sendSoundToPlayers(tWorld, GregTech_API.sSoundList.get(209), 1.0F, -1, tX, tY, tZ);
+        tWorld.setBlock(tX, tY, tZ, Blocks.air);
+        if (GregTech_API.sMachineExplosions)
+            tWorld.createExplosion(null, tX + 0.5, tY + 0.5, tZ + 0.5, tStrength, true);
+    }
+
+    @Override
+    public int getLightOpacity() {
+        return ((GregtechBaseMetaTileEntityLossless) getBaseMetaTileEntity()).getLightValue() > 0 ? 0 : 255;
+    }
+
+    @Override
+    public void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB inputAABB, List<AxisAlignedBB> outputAABB, Entity collider) {
+        AxisAlignedBB axisalignedbb1 = getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+        if (axisalignedbb1 != null && inputAABB.intersectsWith(axisalignedbb1)) outputAABB.add(axisalignedbb1);
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        return AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX + 1, aY + 1, aZ + 1);
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity collider) {
+        //
+    }
+
+    @Override
+    public void onCreated(ItemStack aStack, World aWorld, EntityPlayer aPlayer) {
+        //
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/machines/GregtechMetaSafeBlockBase.java
index e9793f3c32..47d27784b9 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/machines/GregtechMetaSafeBlockBase.java
@@ -1,4 +1,4 @@
-package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base;
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.machines;
 
 import static gregtech.api.enums.GT_Values.V;
 import gregtech.api.enums.Textures;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/creative/GregtechMetaCreativeEnergyBuffer.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/creative/GregtechMetaCreativeEnergyBuffer.java
index 701e128ab7..e2dd128d8b 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/creative/GregtechMetaCreativeEnergyBuffer.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/creative/GregtechMetaCreativeEnergyBuffer.java
@@ -213,6 +213,7 @@ public class GregtechMetaCreativeEnergyBuffer extends GregtechMetaEnergyBuffer {
 	public long[] getStoredEnergy(){
 		long tScale = getBaseMetaTileEntity().getEUCapacity();
 		long tStored = getBaseMetaTileEntity().getStoredEU();
+		this.setEUVar(Long.MAX_VALUE);
 		if (mInventory != null) {
 			for (ItemStack aStack : mInventory) {
 				if (GT_ModHandler.isElectricItem(aStack)) {
@@ -247,7 +248,7 @@ public class GregtechMetaCreativeEnergyBuffer extends GregtechMetaEnergyBuffer {
 
 	@Override
 	public String[] getInfoData() {
-		count++;
+		count++;		
 		if(mMax==0||count%20==0){
 			long[] tmp = getStoredEnergy();
 			mStored=tmp[0];
diff --git a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
index 454e7f3a90..554c59c268 100644
--- a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
+++ b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
@@ -10,7 +10,7 @@ import gregtech.api.metatileentity.MetaTileEntity;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Recipe;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechRocketFuelGeneratorBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechRocketFuelGeneratorBase;
 import net.minecraft.item.ItemStack;
 import cpw.mods.fml.common.registry.GameRegistry;
 
diff --git a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySolarGenerator.java b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySolarGenerator.java
index a703da3c54..0afb37e507 100644
--- a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySolarGenerator.java
+++ b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySolarGenerator.java
@@ -11,7 +11,7 @@ import gregtech.api.objects.GT_RenderedTexture;
 import miscutil.core.util.Utils;
 import miscutil.core.xmod.gregtech.api.gui.CONTAINER_SolarGenerator;
 import miscutil.core.xmod.gregtech.api.gui.GUI_SolarGenerator;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaSolarGenerator;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaSolarGenerator;
 import net.minecraft.entity.player.InventoryPlayer;
 
 public class GregtechMetaTileEntitySolarGenerator extends GregtechMetaSolarGenerator {
diff --git a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySuperCondensor.java b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySuperCondensor.java
new file mode 100644
index 0000000000..9e5db9291d
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySuperCondensor.java
@@ -0,0 +1,104 @@
+package miscutil.core.xmod.gregtech.common.tileentities.generators;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.GregtechMetaSuperConductorNodeBase;
+
+public class GregtechMetaTileEntitySuperCondensor
+        extends GregtechMetaSuperConductorNodeBase {
+
+    public int mEfficiency;
+
+    public GregtechMetaTileEntitySuperCondensor(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, "Requires liquid Nitrogen/Helium", new ITexture[0]);
+        onConfigLoad();
+    }
+
+    public GregtechMetaTileEntitySuperCondensor(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+        onConfigLoad();
+    }
+
+    @Override
+	public boolean isOutputFacing(byte aSide) {
+        return aSide == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntitySuperCondensor(this.mName, this.mTier, this.mDescription, this.mTextures);
+    }
+
+    @Override
+	public GT_Recipe.GT_Recipe_Map getRecipes() {
+        return GT_Recipe.GT_Recipe_Map.sDieselFuels;
+    }
+
+    @Override
+	public int getCapacity() {
+        return 64000;
+    }
+
+    public void onConfigLoad() {
+        this.mEfficiency = 100;
+    }
+
+    @Override
+	public int getEfficiency() {
+        return this.mEfficiency;
+    }
+
+    @Override
+	public ITexture[] getFront(byte aColor) {
+        return new ITexture[]{super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBack(byte aColor) {
+        return new ITexture[]{super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBottom(byte aColor) {
+        return new ITexture[]{super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getTop(byte aColor) {
+        return new ITexture[]{super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP)};
+    }
+
+    @Override
+	public ITexture[] getSides(byte aColor) {
+        return new ITexture[]{super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getFrontActive(byte aColor) {
+        return new ITexture[]{super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBackActive(byte aColor) {
+        return new ITexture[]{super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBottomActive(byte aColor) {
+        return new ITexture[]{super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getTopActive(byte aColor) {
+        return new ITexture[]{super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP_ACTIVE)};
+    }
+
+    @Override
+	public ITexture[] getSidesActive(byte aColor) {
+        return new ITexture[]{super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_COIL_SUPERCONDUCTOR), Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier]};
+    }
+}