Merge branch 'master' of https://github.com/GTNewHorizons/GTplusplus into St00f

# Conflicts:
#	.gitignore
#	dependencies.gradle
#	src/main/java/gtPlusPlus/core/config/ConfigHandler.java
#	src/main/java/gtPlusPlus/core/item/base/BaseItemComponent.java
#	src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaWirelessCharger.java
#	src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_MassFabricator.java
#	src/main/resources/assets/miscutils/lang/en_US.lang

7 files changed, 669 insertions, 169 deletions

diff --git a/src/main/java/gtPlusPlus/core/item/ModItems.java b/src/main/java/gtPlusPlus/core/item/ModItems.java
index 7342c55939..8b72b9c7c9 100644
--- a/src/main/java/gtPlusPlus/core/item/ModItems.java
+++ b/src/main/java/gtPlusPlus/core/item/ModItems.java
@@ -310,6 +310,8 @@ public final class ModItems {
 	public static ItemGenericToken itemGenericToken;
 
 	public static Item itemControlCore;
+	
+	public static Item itemSunnariumBit;
 
 	public static ItemStack itemHotTitaniumIngot;
 
@@ -447,27 +449,8 @@ public final class ModItems {
 
 
 		try{
-
-			/**
-			 * Try generate dusts for missing rare earth materials if they don't exist
-			 */
-
-			if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustGadolinium", 1))){
-				ItemUtils.generateSpecialUseDusts("Gadolinium", "Gadolinium", Materials.Gadolinium.mElement.name(), Utils.rgbtoHexValue(226, 172, 9));
-			}
-			if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustYtterbium", 1))){
-				ItemUtils.generateSpecialUseDusts("Ytterbium", "Ytterbium", Materials.Ytterbium.mElement.name(), Utils.rgbtoHexValue(Materials.Yttrium.mRGBa[0]-60, Materials.Yttrium.mRGBa[1]-60, Materials.Yttrium.mRGBa[2]-60));
-			}
-			if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustSamarium", 1))){
-				ItemUtils.generateSpecialUseDusts("Samarium", "Samarium", Materials.Samarium.mElement.name(), Utils.rgbtoHexValue(161, 168, 114));
-			}
-			if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustLanthanum", 1))){
-				ItemUtils.generateSpecialUseDusts("Lanthanum", "Lanthanum", Materials.Lanthanum.mElement.name(), Utils.rgbtoHexValue(106, 127, 163));
-			}
-			if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustGermanium", 1))){
-		    	ItemUtils.generateSpecialUseDusts("Germanium", "Germanium", "Ge", ELEMENT.getInstance().GERMANIUM.getRgbAsHex());
-			}
-
+			
+			registerCustomMaterialComponents();
 
 			//Elements generate first so they can be used in compounds.
 			//Missing Elements
@@ -855,36 +838,6 @@ public final class ModItems {
 		if (!FluidRegistry.isFluidRegistered("xpjuice")){
 			FluidUtils.generateFluidNoPrefix("xpjuice", "xpjuice", 0, new short[]{50, 150, 50, 100});
 		}
-
-		//Just an unusual plate needed for some black magic.		
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateClay", 1) == null){
-			itemPlateClay = new BaseItemPlate(NONMATERIAL.CLAY);
-		}
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateDoubleClay", 1) == null){
-			itemDoublePlateClay = new BaseItemPlateDouble(NONMATERIAL.CLAY);
-		}
-
-		//Need this for Mutagenic Frames
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("foilUranium235", 1) == null){
-			itemFoilUranium235 = new BaseItemFoil(ELEMENT.getInstance().URANIUM235);
-		}
-
-		//A small gear needed for wizardry.
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("gearGtSmallWroughtIron", 1) == null){
-			itemSmallWroughtIronGear = new BaseItemSmallGear(NONMATERIAL.WROUGHT_IRON);
-		}
-		//Krypton Processing
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("ingotHotTitanium", 1) == null){
-			itemHotTitaniumIngot = ItemUtils.getSimpleStack(new BaseItemIngot(ELEMENT.getInstance().TITANIUM, ComponentTypes.HOTINGOT));
-		}
-		else {
-			itemHotTitaniumIngot = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("ingotHotTitanium", 1);
-		}
-
-		//Need this for Laurenium
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustIndium", 1) == null){
-			itemDustIndium = new BaseItemDust(ELEMENT.getInstance().INDIUM);
-		}
 		
 		//Industrial Diamonds
 		itemExquisiteIndustrialDiamond = new CoreItem("IndustrialDiamondExquisite", "High Quality Industrial Diamond", tabMisc);
@@ -894,97 +847,7 @@ public final class ModItems {
 		ItemUtils.addItemToOreDictionary(tempStack, "gemExquisiteDiamond");
 		ItemUtils.addItemToOreDictionary(tempStack, "craftingExquisiteIndustrialDiamond");
 		
-		//Custom GT++ Crafting Components
-
-		//Springs
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ELEMENT.STANDALONE.WHITE_METAL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ALLOY.NITINOL_60);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ALLOY.AQUATIC_STEEL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ALLOY.EGLIN_STEEL);
-
-		//Small Springs
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.MARAGING250);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.NICHROME);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.STABALLOY);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.STEEL_BLACK);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.BLACK_TITANIUM);
-
-		//Fine Wire
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ELEMENT.STANDALONE.WHITE_METAL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ELEMENT.getInstance().PALLADIUM);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ELEMENT.getInstance().ZIRCONIUM);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.LEAGRISIUM);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.BABBIT_ALLOY);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.KOBOLDITE);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.HG1223);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.QUANTUM);
-		
-		//Dense Plates
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.POTIN);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.AQUATIC_STEEL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.BRONZE);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.OSMIRIDIUM);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.QUANTUM);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.STEEL_BLACK);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.STAINLESS_STEEL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.EGLIN_STEEL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.MARAGING300);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.TALONITE);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.HYPOGEN);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.RHUGNOR);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.ADVANCED_NITINOL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.ASTRAL_TITANIUM);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.WHITE_METAL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.BLACK_METAL);
-		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.GRANITE);		
-		
-		
-		
-		
-		//Special Sillyness
-		if (true) {
-			
-			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateSodium", 1) == null){
-				new BaseItemPlate(ELEMENT.getInstance().SODIUM);
-			}
-			
-			Material meatRaw = NONMATERIAL.MEAT;
-			// A plate of Meat.
-			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateMeatRaw", 1) == null){
-				itemPlateRawMeat = new BaseItemPlate(meatRaw);
-				ItemUtils.registerFuel(ItemUtils.getSimpleStack(itemPlateRawMeat), 100);
-			}
-			// A Block of Meat.
-			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("blockMeatRaw", 1) == null){
-				blockRawMeat  = new BlockBaseModular(meatRaw, BlockTypes.STANDARD);
-				ItemUtils.registerFuel(ItemUtils.getSimpleStack(blockRawMeat), 900);
-			}
-		}
-		
-
-		// A plate of Vanadium.
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateVanadium", 1) == null){
-			itemPlateVanadium = new BaseItemPlate(ELEMENT.getInstance().VANADIUM);
-		}
 
-		//A plate of Lithium.
-		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateLithium", 1) == null){
-			itemPlateLithium = new BaseItemPlate(ELEMENT.getInstance().LITHIUM);
-		}
-
-		//A plate of Europium.
-		if ((ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateEuropium", 1) == null) && CORE.ConfigSwitches.enableCustom_Pipes){
-			itemPlateEuropium = new BaseItemPlate(ELEMENT.getInstance().EUROPIUM);
-		}
-		if ((ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateDoubleEuropium", 1) == null) && CORE.ConfigSwitches.enableCustom_Pipes){
-			itemDoublePlateEuropium = new BaseItemPlateDouble(ELEMENT.getInstance().EUROPIUM);
-		}
-		
-		//Tumbaga Mix (For Simple Crafting)
-		dustTumbagaMix = ItemUtils.generateSpecialUseDusts("MixTumbaga", "Tumbaga Mix", "Au2Cu", Utils.rgbtoHexValue(255, 150, 80))[0];
-		
 		/*
 		 * Decayable Materials
 		 */
@@ -1018,6 +881,8 @@ public final class ModItems {
 		itemDragonJar = new ItemEntityCatcher();
 		
 		itemControlCore = new ItemControlCore();
+		
+		itemSunnariumBit = new ItemSunnariumBit();
 
 		//Chemistry
 		new CoalTar();
@@ -1241,4 +1106,148 @@ public final class ModItems {
 		itemGenericToken.register(3, "Hand Pump Trade Token III", 1, "Craft into a Tier III Hand pump");
 		itemGenericToken.register(4, "Hand Pump Trade Token IV", 1, "Craft into a Tier IV Hand pump");
 	}
+	
+	public static void registerCustomMaterialComponents() {
+		//Custom GT++ Crafting Components
+		
+		/**
+		 * Try generate dusts for missing rare earth materials if they don't exist
+		 */
+
+		if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustGadolinium", 1))){
+			ItemUtils.generateSpecialUseDusts("Gadolinium", "Gadolinium", Materials.Gadolinium.mElement.name(), Utils.rgbtoHexValue(226, 172, 9));
+		}
+		if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustYtterbium", 1))){
+			ItemUtils.generateSpecialUseDusts("Ytterbium", "Ytterbium", Materials.Ytterbium.mElement.name(), Utils.rgbtoHexValue(Materials.Yttrium.mRGBa[0]-60, Materials.Yttrium.mRGBa[1]-60, Materials.Yttrium.mRGBa[2]-60));
+		}
+		if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustSamarium", 1))){
+			ItemUtils.generateSpecialUseDusts("Samarium", "Samarium", Materials.Samarium.mElement.name(), Utils.rgbtoHexValue(161, 168, 114));
+		}
+		if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustLanthanum", 1))){
+			ItemUtils.generateSpecialUseDusts("Lanthanum", "Lanthanum", Materials.Lanthanum.mElement.name(), Utils.rgbtoHexValue(106, 127, 163));
+		}
+		if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustGermanium", 1))){
+	    	ItemUtils.generateSpecialUseDusts("Germanium", "Germanium", "Ge", ELEMENT.getInstance().GERMANIUM.getRgbAsHex());
+		}
+		
+		//Just an unusual plate needed for some black magic.		
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateClay", 1) == null){
+			itemPlateClay = new BaseItemPlate(NONMATERIAL.CLAY);
+		}
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateDoubleClay", 1) == null){
+			itemDoublePlateClay = new BaseItemPlateDouble(NONMATERIAL.CLAY);
+		}
+
+		//Need this for Mutagenic Frames
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("foilUranium235", 1) == null){
+			itemFoilUranium235 = new BaseItemFoil(ELEMENT.getInstance().URANIUM235);
+		}
+
+		//A small gear needed for wizardry.
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("gearGtSmallWroughtIron", 1) == null){
+			itemSmallWroughtIronGear = new BaseItemSmallGear(NONMATERIAL.WROUGHT_IRON);
+		}
+		//Krypton Processing
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("ingotHotTitanium", 1) == null){
+			itemHotTitaniumIngot = ItemUtils.getSimpleStack(new BaseItemIngot(ELEMENT.getInstance().TITANIUM, ComponentTypes.HOTINGOT));
+		}
+		else {
+			itemHotTitaniumIngot = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("ingotHotTitanium", 1);
+		}
+
+		//Need this for Laurenium
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("dustIndium", 1) == null){
+			itemDustIndium = new BaseItemDust(ELEMENT.getInstance().INDIUM);
+		}
+
+		//Springs
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ELEMENT.STANDALONE.WHITE_METAL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ALLOY.NITINOL_60);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ALLOY.AQUATIC_STEEL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SPRING, ALLOY.EGLIN_STEEL);
+
+		//Small Springs
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.MARAGING250);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.NICHROME);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.STABALLOY);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.STEEL_BLACK);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.SMALLSPRING, ALLOY.BLACK_TITANIUM);
+
+		//Fine Wire
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ELEMENT.STANDALONE.WHITE_METAL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ELEMENT.getInstance().PALLADIUM);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ELEMENT.getInstance().ZIRCONIUM);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.LEAGRISIUM);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.BABBIT_ALLOY);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.KOBOLDITE);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.HG1223);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.FINEWIRE, ALLOY.QUANTUM);
+		
+		//Dense Plates
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.POTIN);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.AQUATIC_STEEL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.BRONZE);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.OSMIRIDIUM);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.QUANTUM);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.STEEL_BLACK);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.STAINLESS_STEEL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.EGLIN_STEEL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.MARAGING300);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ALLOY.TALONITE);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.HYPOGEN);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.RHUGNOR);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.ADVANCED_NITINOL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.ASTRAL_TITANIUM);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.WHITE_METAL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.BLACK_METAL);
+		MaterialUtils.generateComponentAndAssignToAMaterial(ComponentTypes.PLATEHEAVY, ELEMENT.STANDALONE.GRANITE);		
+		
+		
+		
+		
+		//Special Sillyness
+		if (true) {
+			
+			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateSodium", 1) == null){
+				new BaseItemPlate(ELEMENT.getInstance().SODIUM);
+			}
+			
+			Material meatRaw = NONMATERIAL.MEAT;
+			// A plate of Meat.
+			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateMeatRaw", 1) == null){
+				itemPlateRawMeat = new BaseItemPlate(meatRaw);
+				ItemUtils.registerFuel(ItemUtils.getSimpleStack(itemPlateRawMeat), 100);
+			}
+			// A Block of Meat.
+			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("blockMeatRaw", 1) == null){
+				blockRawMeat  = new BlockBaseModular(meatRaw, BlockTypes.STANDARD);
+				ItemUtils.registerFuel(ItemUtils.getSimpleStack(blockRawMeat), 900);
+			}
+		}
+		
+
+		// A plate of Vanadium.
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateVanadium", 1) == null){
+			itemPlateVanadium = new BaseItemPlate(ELEMENT.getInstance().VANADIUM);
+		}
+
+		//A plate of Lithium.
+		if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateLithium", 1) == null){
+			itemPlateLithium = new BaseItemPlate(ELEMENT.getInstance().LITHIUM);
+		}
+
+		//A plate of Europium.
+		if ((ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateEuropium", 1) == null) && CORE.ConfigSwitches.enableCustom_Pipes){
+			itemPlateEuropium = new BaseItemPlate(ELEMENT.getInstance().EUROPIUM);
+		}
+		if ((ItemUtils.getItemStackOfAmountFromOreDictNoBroken("plateDoubleEuropium", 1) == null) && CORE.ConfigSwitches.enableCustom_Pipes){
+			itemDoublePlateEuropium = new BaseItemPlateDouble(ELEMENT.getInstance().EUROPIUM);
+		}
+		
+		//Tumbaga Mix (For Simple Crafting)
+		dustTumbagaMix = ItemUtils.generateSpecialUseDusts("MixTumbaga", "Tumbaga Mix", "Au2Cu", Utils.rgbtoHexValue(255, 150, 80))[0];
+		
+	}
 }
diff --git a/src/main/java/gtPlusPlus/core/item/base/BaseItemComponent.java b/src/main/java/gtPlusPlus/core/item/base/BaseItemComponent.java
index 1dc9996cde..9590ec2848 100644
--- a/src/main/java/gtPlusPlus/core/item/base/BaseItemComponent.java
+++ b/src/main/java/gtPlusPlus/core/item/base/BaseItemComponent.java
@@ -5,15 +5,19 @@ import java.util.*;
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+
+import gregtech.api.GregTech_API;
 import gregtech.api.enums.OrePrefixes;
 import gregtech.api.enums.TextureSet;
 import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_OreDictUnificator;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.core.creative.AddToCreativeTab;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.LoadedMods;
 import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.state.MaterialState;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.data.StringUtils;
 import gtPlusPlus.core.util.math.MathUtils;
@@ -118,6 +122,12 @@ public class BaseItemComponent extends Item{
 			aMap.put(aKey, ItemUtils.getSimpleStack(this));
 			Logger.MATERIALS("Registering a material component. Item: ["+componentMaterial.getUnlocalizedName()+"] Map: ["+aKey+"]");
 			Material.mComponentMap.put(componentMaterial.getUnlocalizedName(), aMap);
+			if (componentType == ComponentTypes.PLATE) {
+		        GregTech_API.registerCover(componentMaterial.getPlate(1), new GT_RenderedTexture(componentMaterial.getTextureSet().mTextures[71], componentMaterial.getRGBA(), false), null);			
+			}
+			else if (componentType == ComponentTypes.PLATEDOUBLE) {
+		        GregTech_API.registerCover(componentMaterial.getPlateDouble(1), new GT_RenderedTexture(componentMaterial.getTextureSet().mTextures[72], componentMaterial.getRGBA(), false), null);			
+			}
 			return true;
 		}
 		else {
@@ -341,38 +351,39 @@ public class BaseItemComponent extends Item{
 						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE, new Short[] {0});
 						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE-1, new Short[] {0});
 						short[] er = this.componentMaterial.getRGBA();
-						short value = 1;
+						short value = 0;
 						Short[] ht = new Short[] {er[0], er[1], er[2]};
-						for (int y = 0; y < 40; y++) {
-							if (y < 20) {
+						int aMaxCycles = 200;
+						for (int y = 0; y < aMaxCycles; y++) {
+							if (y < (50)) {
 								value = 1;
 							}
-							else {
+							else if (y < (100)) {
+								value = 0;
+							}
+							else if (y < (150)) {
 								value = -1;
 							}
-							short r = (short) (ht[0] + value);
-							short g = (short) (ht[1] + value);
-							short b = (short) (ht[2] + value);
+							else {
+								value = 0;
+							}
+							short r = (short) Math.max(Math.min(255, (ht[0] + value)), 0);
+							short g = (short) Math.max(Math.min(255, (ht[1] + value)), 0);
+							short b = (short) Math.max(Math.min(255, (ht[2] + value)), 0);
 							Short[] qq = new Short[] {(short) Math.min(255, r), (short) Math.min(255, g), (short) Math.min(255, b)};
 							ht = qq;
 							((Map<Integer, Short[]>) extraData).put(y, qq);					
 						}
+						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE-2, new Short[] {(short) (((Map<Integer, Short[]>) extraData).size()-1)});
 					}
 					if (extraData != null) {
 
 						Short aCurrentFrame = ((Map<Integer, Short[]>) extraData).get((int) Short.MAX_VALUE)[0];
-						Short aSize = 40;
+						Short aSize = (short) (((Map<Integer, Short[]>) extraData).size() - 3);				
 						short nextFrame = (short) ((aCurrentFrame < aSize) ? (aCurrentFrame+1) : 0);
 						Short[] aCurrentFrameRGB = ((Map<Integer, Short[]>) extraData).get(aCurrentFrame < aSize ? (int) aCurrentFrame : 0);
-						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE, new Short[] {nextFrame});
-						return Utils.rgbtoHexValue(aCurrentFrameRGB[0], aCurrentFrameRGB[1], aCurrentFrameRGB[2]);	
-
-
-						/*Short aCurrentFrame = ((Map<Integer, Short[]>) extraData).get((int) Short.MAX_VALUE)[0];
-						Short[] aCurrentFrameRGB = ((Map<Integer, Short[]>) extraData).get((int) aCurrentFrame);
-						short nextFrame = aCurrentFrame < 40 ? aCurrentFrame++ : 0;
-						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE, new Short[] {nextFrame});
-						return Utils.rgbtoHexValue(aCurrentFrameRGB[0], aCurrentFrameRGB[1], aCurrentFrameRGB[2]);*/			
+						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE, new Short[] {nextFrame});				
+						return Utils.rgbtoHexValue(aCurrentFrameRGB[0], aCurrentFrameRGB[1], aCurrentFrameRGB[2]);			
 					}			
 				}
 				
@@ -388,35 +399,200 @@ public class BaseItemComponent extends Item{
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,   0});
 						//Slowly start adding in some red to get to yellow:
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 255,   0});
 						//Then, take out the green to get to red:
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 204,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 153,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255, 102,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,  51,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,   0});
@@ -424,15 +600,90 @@ public class BaseItemComponent extends Item{
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {255,   0, 255});
@@ -440,15 +691,90 @@ public class BaseItemComponent extends Item{
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {204,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {153,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {102,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] { 51,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,   0, 255});
@@ -456,15 +782,90 @@ public class BaseItemComponent extends Item{
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0,  51, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 102, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 153, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 204, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 255});
@@ -472,16 +873,76 @@ public class BaseItemComponent extends Item{
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 204});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 153});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255, 102});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
+						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
 						((Map<Integer, Short[]>) extraData).put(aSlot++, new Short[] {  0, 255,  51});
-						((Map<Integer, Short[]>) extraData).put((int) Byte.MAX_VALUE, new Short[] {(short) (((Map<Integer, Short[]>) extraData).size()-1)});
+						((Map<Integer, Short[]>) extraData).put((int) Short.MAX_VALUE-2, new Short[] {(short) (((Map<Integer, Short[]>) extraData).size()-1)});
 
 
 					}
diff --git a/src/main/java/gtPlusPlus/core/item/base/wire/BaseItemFineWire.java b/src/main/java/gtPlusPlus/core/item/base/wire/BaseItemFineWire.java
new file mode 100644
index 0000000000..846c282af3
--- /dev/null
+++ b/src/main/java/gtPlusPlus/core/item/base/wire/BaseItemFineWire.java
@@ -0,0 +1,12 @@
+package gtPlusPlus.core.item.base.wire;
+
+import gtPlusPlus.core.item.base.BaseItemComponent;
+import gtPlusPlus.core.material.Material;
+
+public class BaseItemFineWire extends BaseItemComponent{
+
+	public BaseItemFineWire(final Material material) {
+		super(material, BaseItemComponent.ComponentTypes.FINEWIRE);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/core/item/crafting/ItemDummyResearch.java b/src/main/java/gtPlusPlus/core/item/crafting/ItemDummyResearch.java
index d8ddb26675..b7bf8a7c8e 100644
--- a/src/main/java/gtPlusPlus/core/item/crafting/ItemDummyResearch.java
+++ b/src/main/java/gtPlusPlus/core/item/crafting/ItemDummyResearch.java
@@ -29,7 +29,8 @@ public class ItemDummyResearch extends ItemGenericToken {
 		RESEARCH_7_ADV_METALLURGY("Advanced Metallurgy", "Advanced Material Sciences!"),
 		RESEARCH_8_TURBINE_AUTOMATION("Turbine Automation", "You really don't want to share this with anyone!"), 
 		RESEARCH_9_CLOAKING("Cloaking Technologies", "Sneaking around like a mouse"),
-		RESEARCH_10_SPARGING("Gas Sparging", "Blowing gas for results");	
+		RESEARCH_10_SPARGING("Gas Sparging", "Blowing gas for results"),
+		RESEARCH_11_MOLECULAR_TRANSFORMER("Molecular Transformation", "Turning things into something better");	
 		
 		
 		
diff --git a/src/main/java/gtPlusPlus/core/item/general/ItemAreaClear.java b/src/main/java/gtPlusPlus/core/item/general/ItemAreaClear.java
index 5be184b3db..16d0c0253b 100644
--- a/src/main/java/gtPlusPlus/core/item/general/ItemAreaClear.java
+++ b/src/main/java/gtPlusPlus/core/item/general/ItemAreaClear.java
@@ -30,7 +30,7 @@ public class ItemAreaClear extends CoreItem {
 	public IIcon[] mIcon = new IIcon[1];
 
 	public ItemAreaClear() {
-		super("itemDebugClearing", AddToCreativeTab.tabMachines, 1, 100, new String[] {EnumChatFormatting.OBFUSCATED+"F A M C Y   N A M E"}, EnumRarity.rare,
+		super("itemDebugClearing", AddToCreativeTab.tabMachines, 1, 100, new String[] {EnumChatFormatting.OBFUSCATED+"F A N C Y   N A M E"}, EnumRarity.rare,
 				EnumChatFormatting.BOLD, false, null);
 	}
 
@@ -160,16 +160,16 @@ public class ItemAreaClear extends CoreItem {
 		int y1 = pos.yPos;
 		int z1 = pos.zPos;
 
-		int x2 = (x1-10);
+		int x2 = (x1-15);
 		int y2 = (y1-1);
-		int z2 = (z1-10);
+		int z2 = (z1-15);
 
 		fillBlockColumn(world, new BlockPos(x2, y2, z2, world));
 		return true;
 	}
 
 	public boolean fillBlockColumn(World world, BlockPos pos){
-		for (int i=0; i<21; i++){
+		for (int i=0; i<30; i++){
 			fillBlockRow(world, new BlockPos(pos.xPos, pos.yPos, pos.zPos+i, world));
 		}
 		return true;
@@ -177,9 +177,10 @@ public class ItemAreaClear extends CoreItem {
 
 	public boolean fillBlockRow(World world, BlockPos pos){
 		for (int j=0; j<2; j++){
-			for (int i=0; i<21; i++){
+			for (int i=0; i<30; i++){
 				if (world.getBlock(pos.xPos+i, pos.yPos+j, pos.zPos) != Blocks.bedrock){
-					world.setBlock(pos.xPos+i, pos.yPos+j, pos.zPos, Blocks.grass);
+					world.setBlock(pos.xPos+i, pos.yPos+j, pos.zPos, Blocks.dirt);
+					world.setBlockMetadataWithNotify(pos.xPos+i, pos.yPos+j, pos.zPos, 2, 2);
 				}
 			}
 		}
diff --git a/src/main/java/gtPlusPlus/core/item/general/ItemBlueprint.java b/src/main/java/gtPlusPlus/core/item/general/ItemBlueprint.java
index eded4e2585..5df17979a9 100644
--- a/src/main/java/gtPlusPlus/core/item/general/ItemBlueprint.java
+++ b/src/main/java/gtPlusPlus/core/item/general/ItemBlueprint.java
@@ -71,7 +71,7 @@ public class ItemBlueprint extends Item implements IItemBlueprint{
 
 	@Override
 	public String getItemStackDisplayName(final ItemStack p_77653_1_) {
-		return "Blueprint [I am useless]";
+		return "Blueprint";
 	}
 
 	@Override
@@ -103,7 +103,7 @@ public class ItemBlueprint extends Item implements IItemBlueprint{
 		ItemStack[] blueprint = new ItemStack[9];
 		if (itemStack.hasTagCompound()){
 			final NBTTagCompound nbt = itemStack.getTagCompound();
-			final NBTTagList list = nbt.getTagList("Items", 10);
+			final NBTTagList list = nbt.getTagList("Inventory", 10);
 			blueprint = new ItemStack[INV_SIZE];
 			for(int i = 0;i<list.tagCount();i++)
 			{
@@ -135,7 +135,7 @@ public class ItemBlueprint extends Item implements IItemBlueprint{
 					list.appendTag(data);
 				}
 			}
-			nbt.setTag("Items", list);
+			nbt.setTag("Inventory", list);
 			itemStack.setTagCompound(nbt);
 			return itemStack;
 		}
diff --git a/src/main/java/gtPlusPlus/core/item/general/ItemSunnariumBit.java b/src/main/java/gtPlusPlus/core/item/general/ItemSunnariumBit.java
new file mode 100644
index 0000000000..0b61a06934
--- /dev/null
+++ b/src/main/java/gtPlusPlus/core/item/general/ItemSunnariumBit.java
@@ -0,0 +1,16 @@
+package gtPlusPlus.core.item.general;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.item.base.CoreItem;
+import gtPlusPlus.core.lib.CORE;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.util.EnumChatFormatting;
+
+public class ItemSunnariumBit extends CoreItem {
+
+	public ItemSunnariumBit() {
+		super("SunnariumBit", "Sunnarium Bit", AddToCreativeTab.tabMisc, 64, 0, new String[] {}, EnumRarity.uncommon, EnumChatFormatting.GOLD, false, null);
+		this.setTextureName(CORE.MODID+":"+"itemSunnariumBit");
+	}
+
+}