Move sources and resources

40 files changed, 6780 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java
new file mode 100644
index 0000000000..c6e98581ff
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java
@@ -0,0 +1,60 @@
+package gtPlusPlus.plugin.agrichem;
+
+public enum AlgaeDefinition {
+
+	/*
+	 * In general, the productivity of freshwater algae is primarily limited by 
+	 * the availability of the nutrient phosphate (PO4-3), while that of 
+	 * marine algae is limited by nitrate (NO3-) or ammonium (NH4+). 
+	 * Some algal species, however, may have unusual nutrient requirements, 
+	 * and their productivity may be limited by certain micronutrients, 
+	 * such as silica, in the case of diatoms.
+	 */
+	
+	Euglenophyta("Euglenophyta", "Euglenoids", true, false, getRGB(147, 168, 50)),
+	Chrysophyta("Chrysophyta", "Golden-Brown Algae", true, true, getRGB(186, 146, 0)),
+	Pyrrophyta("Pyrrophyta", "Fire Algae", true, true, getRGB(250, 118, 2)),
+	Chlorophyta("Chlorophyta", "Green Algae", true, true, getRGB(99, 181, 62)),
+	Rhodophyta("Rhodophyta", "Red Algae", false, true, getRGB(153, 5, 22)),
+	Paeophyta("Paeophyta", "Brown Algae", false, true, getRGB(94, 78, 47)),
+	Xanthophyta("Xanthophyta", "Yellow-Green Algae", true, false, getRGB(118, 138, 16));	
+
+	public final String mScientificName;
+	public final String mSimpleName;
+	public final boolean mSaltWater;
+	public final boolean mFreshWater;
+	public final int mColour;
+	
+	AlgaeDefinition(String aScientificName, String aSimpleName, boolean aFresh, boolean aSalt, int aColour) {
+		mScientificName = aScientificName;
+		mSimpleName = aSimpleName;
+		mFreshWater = aFresh;
+		mSaltWater = aSalt;
+		mColour = aColour;
+	}
+	
+	public static AlgaeDefinition getByIndex(int aIndex) {
+		switch(aIndex) {
+			  default:
+			  case 0:
+				 return Euglenophyta;
+			  case 1:
+				 return Chrysophyta;
+			  case 2:
+				 return Pyrrophyta;
+			  case 3:
+				 return Chlorophyta;
+			  case 4:
+				 return Rhodophyta;
+			  case 5:
+				 return Paeophyta;
+			  case 6:
+				 return Xanthophyta;    
+			}
+	}
+	
+	private final static int getRGB(int r, int g, int b) {
+		return AlgaeUtils.rgbtoHexValue(r, g, b);
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java
new file mode 100644
index 0000000000..73ff23888c
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java
@@ -0,0 +1,11 @@
+package gtPlusPlus.plugin.agrichem;
+
+import gtPlusPlus.core.util.Utils;
+
+public class AlgaeUtils {
+
+	public static int rgbtoHexValue(final int r, final int g, final int b) {
+		return Utils.rgbtoHexValue(r, g, b);
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java b/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java
new file mode 100644
index 0000000000..edfd42b5ca
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java
@@ -0,0 +1,1425 @@
+package gtPlusPlus.plugin.agrichem;
+
+import static gtPlusPlus.core.lib.CORE.GTNH;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.item.ModItems;
+import gtPlusPlus.core.item.base.BaseItemComponent;
+import gtPlusPlus.core.item.chemistry.AgriculturalChem;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.material.ALLOY;
+import gtPlusPlus.core.material.MISC_MATERIALS;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.minecraft.OreDictUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.plugin.agrichem.block.AgrichemFluids;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+import gtPlusPlus.xmod.railcraft.utils.RailcraftUtils;
+import ic2.core.Ic2Items;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class BioRecipes {
+
+	private static Item mFert;
+	private static Item mDustDirt;
+
+	private static Fluid mSalineWater;
+	private static Fluid mDistilledWater;
+	private static Fluid mThermalWater;
+	private static Fluid mAir;
+	private static Fluid mSulfuricWasteWater;
+	private static Fluid mAmmonia;
+	private static Fluid mMethanol;
+	private static Fluid mAceticAcid;
+	private static Fluid mPropionicAcid;
+	private static Fluid mLiquidPlastic;
+	private static Fluid mFermentationBase;
+	private static Fluid mCarbonDioxide;
+	private static Fluid mCarbonMonoxide;
+	private static Fluid mEthylene;
+	public static Fluid mEthanol;
+	private static Fluid mChlorine;
+	private static Fluid mHydrogen;
+	private static Fluid mDilutedSulfuricAcid;
+	private static Fluid mSulfuricAcid;
+	private static Fluid mUrea;
+	private static Fluid mFormaldehyde;
+	private static Fluid mLiquidResin;
+	private static Fluid mMethane;
+	private static Fluid mBenzene;
+	private static Fluid mEthylbenzene;
+	private static Fluid mStyrene;
+	private static Fluid mButanol;
+	private static Fluid mAcetone;
+
+
+	private static final ItemStack getGreenAlgaeRecipeChip() {
+		return getBioChip(4);
+	}
+	private static final ItemStack getBrownAlgaeRecipeChip() {
+		return getBioChip(8);
+	}
+	private static final ItemStack getGoldenBrownAlgaeRecipeChip() {
+		return getBioChip(12);
+	}
+	private static final ItemStack getRedAlgaeRecipeChip() {
+		return getBioChip(16);
+	}	
+
+	private static final ItemStack getBioChip(int aID) {
+		return ItemUtils.simpleMetaStack(AgriculturalChem.mBioCircuit, aID, 0);
+	}
+
+	public static void init() {
+		Logger.INFO("[Bio] Setting Variables");
+		initRecipeVars();
+		Logger.INFO("[Bio] Generating Biochip Recipes");
+		recipeBioChip();
+		Logger.INFO("[Bio] Generating Recipes");
+		recipeAlgaeBiomass();
+		Logger.INFO("[Bio] Finished with recipes");
+	}
+
+	private static final void initRecipeVars() {
+		mFert = AgriculturalChem.dustOrganicFertilizer;
+		mDustDirt = AgriculturalChem.dustDirt;
+
+		// 5.08 Salt Water Solution ;)
+		if (!FluidUtils.doesFluidExist("saltwater")){
+			mSalineWater = FluidUtils.generateFluidNoPrefix("saltwater", "Salt Water", 200, new short[]{10, 30, 220, 100});
+		}
+		else {
+			Materials aSaltWater = MaterialUtils.getMaterial("saltwater");
+			if (aSaltWater != null) {
+				FluidStack aWaterStack = aSaltWater.getFluid(1);
+				if (aWaterStack != null) {
+					mSalineWater = aSaltWater.getFluid(1).getFluid();					
+				}				
+			}
+			if (mSalineWater == null) {
+				mSalineWater = FluidUtils.getWildcardFluidStack("saltwater", 1).getFluid();
+			}
+			if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellSaltWater", 1) == null){				
+				new BaseItemComponent("saltwater", "Salt Water", new short[] {10, 30, 220});
+			}
+		}
+
+		mDistilledWater = FluidUtils.getDistilledWater(1).getFluid();
+		mThermalWater = FluidUtils.getFluidStack("ic2hotwater", 1).getFluid();		
+		mAir = FluidUtils.getFluidStack("air", 1).getFluid();		
+		mSulfuricWasteWater = FluidUtils.getFluidStack("sulfuricapatite", 1).getFluid();
+		mAmmonia = MISC_MATERIALS.AMMONIA.getFluidStack(1).getFluid();
+		mEthylene = FluidUtils.getFluidStack("ethylene", 1).getFluid();
+		mEthanol = FluidUtils.getFluidStack("bioethanol", 1).getFluid();
+		mDilutedSulfuricAcid = FluidUtils.getFluidStack("dilutedsulfuricacid", 1).getFluid();
+		mSulfuricAcid = FluidUtils.getFluidStack("sulfuricacid", 1).getFluid();		 
+		mFormaldehyde = FluidUtils.getFluidStack("fluid.formaldehyde", 1).getFluid();		 
+		mMethane = FluidUtils.getFluidStack("methane", 1).getFluid();
+		mBenzene = FluidUtils.getFluidStack("benzene", 1).getFluid();
+		mEthylbenzene = FluidUtils.getFluidStack("fluid.ethylbenzene", 1).getFluid();
+		mStyrene = FluidUtils.getFluidStack("styrene", 1).getFluid();		
+		mMethanol = FluidUtils.getFluidStack("methanol", 1).getFluid();
+		mLiquidPlastic = FluidUtils.getWildcardFluidStack("plastic", 1).getFluid();
+		mCarbonDioxide = MISC_MATERIALS.CARBON_DIOXIDE.getFluidStack(1).getFluid();
+		mCarbonMonoxide = MISC_MATERIALS.CARBON_MONOXIDE.getFluidStack(1).getFluid();
+		mChlorine = FluidUtils.getFluidStack("chlorine", 1).getFluid();
+		mHydrogen = FluidUtils.getFluidStack("hydrogen", 1).getFluid();		
+		mAceticAcid = AgrichemFluids.mAceticAcid;
+		mPropionicAcid = AgrichemFluids.mPropionicAcid;
+		mUrea = AgrichemFluids.mUrea;
+		mLiquidResin = AgrichemFluids.mLiquidResin;
+		mFermentationBase = AgrichemFluids.mFermentationBase;		
+		mButanol = AgrichemFluids.mButanol;
+		mAcetone = AgrichemFluids.mAcetone;
+	}
+
+	private static void recipeAlgaeBiomass() {
+
+		// TODO
+		// Add in recipes to get initial Biomass
+
+		recipeGreenAlgae();
+		recipeBrownAlgae();
+		recipeGoldenBrownAlgae();
+		recipeRedAlgae();
+		recipeWoodPellets();
+		recipeWoodBricks();
+		recipeCellulosePulp();
+		recipeCatalystCarrier();
+		recipeAluminiumSilverCatalyst();
+		recipeAceticAcid();
+		recipePropionicAcid();
+		recipeFermentationBase();
+		recipeEthanol();
+		recipeCelluloseFibre();
+		recipeGoldenBrownCelluloseFiber();
+		recipeRedCelluloseFiber();		
+		recipeSodiumHydroxide();
+		recipeSodiumCarbonate();
+		recipePelletMold();
+		recipeAluminiumPellet();
+		recipeAlumina();
+		recipeAluminium();
+		recipeCalciumCarbonate();
+		recipeLithiumChloride();
+		recipeAlginicAcid();
+		recipeSulfuricAcid();
+		recipeUrea();		
+		recipeRawBioResin();
+		recipeLiquidResin();
+		recipeCompost();
+		recipeMethane();
+		recipeBenzene();
+		recipeStyrene();		
+		registerFuels();
+	}
+
+	private static void registerFuels() {
+
+		// Burnables
+		ItemUtils.registerFuel(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), 800);
+		ItemUtils.registerFuel(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 1), 4800);
+
+		// Gas Fuels
+		//GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalGas", 1), null, 96, 1);
+
+		//Combustion Fuels
+		GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellButanol", 1), null, 1125, 0);
+
+	}
+	private static void recipeGreenAlgae() {
+		// Compost
+		GT_ModHandler.addPulverisationRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 10),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1));
+
+		// Turn into Cellulose
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getGreenAlgaeRecipeChip(),
+				ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 30)
+		},
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 5),
+				30 * 30,
+				16);
+
+
+	}
+
+	private static void recipeBrownAlgae() {
+		// Compost
+		GT_ModHandler.addPulverisationRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 10),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1));
+
+		// Alginic acid
+		CORE.RA.addExtractorRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 10),
+				ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 1),
+				20 * 15,
+				30);
+
+		// Lithium Chloride
+		GT_Values.RA.addBlastRecipe(
+				getBrownAlgaeRecipeChip(),
+				ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 20),
+				GT_Values.NF,
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 1),
+				GT_Values.NI,
+				120, 
+				120,
+				1200);
+
+		// Sodium Carbonate
+		CORE.RA.addChemicalRecipe(
+				getBrownAlgaeRecipeChip(),
+				ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 20),
+				FluidUtils.getDistilledWater(2000), 
+				GT_Values.NF, 
+				ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 1),
+				20 * 30,
+				30);		
+
+	}
+
+	private static void recipeGoldenBrownAlgae() {
+		// Compost
+		GT_ModHandler.addPulverisationRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 10),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1));
+
+		// Turn into Cellulose
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getGoldenBrownAlgaeRecipeChip(),
+				ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 30)
+		},
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 5),
+				30 * 30,
+				120);
+
+	}
+
+	private static void recipeRedAlgae() {
+		// Compost
+		GT_ModHandler.addPulverisationRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 10),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1));
+
+		// Turn into Cellulose
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getRedAlgaeRecipeChip(),
+				ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 30)
+		},
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 5),
+				30 * 30,
+				240);
+
+	}
+
+	private static void recipeCelluloseFibre() {
+
+		CORE.RA.addChemicalRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 20),
+				ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 2),
+				GT_Values.NF, 
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 10),
+				45 * 20,
+				16);
+
+		// Craft into Wood Pellets
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(2),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12)
+		},
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2),
+				20 * 4,
+				8);
+
+		// Methanol Extraction
+		GT_Values.RA.addFluidExtractionRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12),
+				GT_Values.NI,
+				FluidUtils.getFluidStack(mMethanol, 50),
+				10000,
+				20 * 30,
+				30);
+
+		// Compost
+		GT_ModHandler.addPulverisationRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 5),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1));
+
+		// Plastic		
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(16),
+						ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 64),
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mAceticAcid, 500),
+						FluidUtils.getFluidStack(BioRecipes.mPropionicAcid, 500),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mLiquidPlastic, (144)),						
+				},
+				120 * 20,
+				240,
+				2);
+
+
+	}
+
+	private static void recipeWoodPellets() {
+		// Shapeless Recipe
+		RecipeUtils.addShapelessGregtechRecipe(new ItemStack[] {
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1)
+		}, ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 2));
+
+		// Extruder Recipe
+		GT_Values.RA.addExtruderRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12),
+				ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 0),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 3),
+				20 * 10, 
+				16);
+
+		// Assembly Recipe
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(2),
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 8)
+		}, 
+				GT_Values.NF, 
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 2),
+				20 * 5, 
+				8);
+
+		// CO2
+		CORE.RA.addFluidExtractionRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1),
+				FluidUtils.getFluidStack(mCarbonDioxide, 70),
+				10*20,
+				30);
+
+
+		// Add Charcoal Recipe
+		if (LoadedMods.Railcraft) {
+			RailcraftUtils.addCokeOvenRecipe(
+					ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2),
+					true,
+					true,
+					ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3),
+					GT_Values.NF, 
+					1200);			
+		}
+		CORE.RA.addCokeOvenRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2),
+				getBioChip(3),
+				null,
+				GT_Values.NF, 
+				ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3),
+				120, 
+				16);			
+
+
+	}
+
+	private static void recipeWoodBricks() {
+
+		// Assembly Recipe
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(3),
+				ItemUtils.getOrePrefixStack(OrePrefixes.dust, Materials.Wood, 50)
+		}, 
+				GT_Values.NF, 
+				ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 1),
+				100 * 20, 
+				16);
+	}
+
+	private static void recipeCellulosePulp() {
+
+		// Assembly Recipe
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(2),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 4)
+		}, 
+				GT_Values.NF, 
+				ItemUtils.getSimpleStack(Items.paper, 1),
+				60 * 20, 
+				16);
+	}
+
+	private static void recipeCatalystCarrier() {
+		// Assembly Recipe
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(20),
+				ItemUtils.getItemStackOfAmountFromOreDict("plateSteel", GTNH ? 8 : 4),
+				ItemUtils.getItemStackOfAmountFromOreDict("wireFineCopper", GTNH ? 4 : 2),
+				ItemUtils.getItemStackOfAmountFromOreDict("screwTin", GTNH ? 6 : 3)
+		}, 
+				GT_Values.NF, 
+				CI.getEmptyCatalyst(1),
+				300 * 20, 
+				16);
+	}	
+
+	private static void recipeAluminiumSilverCatalyst() {
+		// Assembly Recipe
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(4),
+				CI.getEmptyCatalyst(10),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustAluminium", 4),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustSilver", 4)
+		}, 
+				GT_Values.NF, 
+				CI.getGreenCatalyst(10),
+				20 * 20, 
+				30);
+	}
+
+	private static void recipeAceticAcid() {
+
+		/*		GT_Values.RA.addMixerRecipe(
+						CI.getGreenCatalyst(10),
+						var2,
+						var3, var4,
+						var5, // Fluid in
+						var6, // Fluid out
+						var7, // Item Out
+						var8, // Time
+						var9); // Eu
+		 */	
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						CI.getGreenCatalyst(0)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mMethanol, 700),
+						FluidUtils.getFluidStack(BioRecipes.mCarbonMonoxide, 300),
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 2000),
+				},
+				new ItemStack[] {
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mAceticAcid, 250),						
+				},
+				120 * 20,
+				60,
+				1);
+		
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] {
+						CI.getNumberedBioCircuit(14),
+						CI.emptyCells(1)
+						}, 
+				FluidUtils.getFluidStack(mFermentationBase, 4000), 
+				null, 
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellAceticAcid", 1)						
+				},
+				new int[] {10000, 10000}, 
+				60 * 20,
+				16);
+
+
+	}
+
+
+
+	public final static HashSet<GT_ItemStack> mFruits = new HashSet<GT_ItemStack>();
+	public final static HashSet<GT_ItemStack> mVege = new HashSet<GT_ItemStack>();
+	public final static HashSet<GT_ItemStack> mNuts = new HashSet<GT_ItemStack>();
+	public final static HashSet<GT_ItemStack> mSeeds = new HashSet<GT_ItemStack>();
+
+	public final static AutoMap<ItemStack> mList_Master_FruitVege = new AutoMap<ItemStack>();
+	public final static AutoMap<ItemStack> mList_Master_Seeds = new AutoMap<ItemStack>();
+
+	private static void processFermentationOreDict() {
+		processOreDictEntry("listAllfruit", mFruits);		
+		processOreDictEntry("listAllFruit", mFruits);
+		processOreDictEntry("listAllveggie", mVege);
+		processOreDictEntry("listAllVeggie", mVege);
+		processOreDictEntry("listAllnut", mNuts);
+		processOreDictEntry("listAllNut", mNuts);
+		processOreDictEntry("listAllseed", mSeeds);
+		processOreDictEntry("listAllSeed", mSeeds);
+
+		if (!mFruits.isEmpty()) {
+			for (GT_ItemStack g : mFruits) {
+				mList_Master_FruitVege.put(g.toStack());
+			}
+		}
+		if (!mVege.isEmpty()) {
+			for (GT_ItemStack g : mVege) {
+				mList_Master_FruitVege.put(g.toStack());
+			}
+		}
+		if (!mNuts.isEmpty()) {
+			for (GT_ItemStack g : mNuts) {
+				mList_Master_FruitVege.put(g.toStack());
+			}
+		}
+		if (!mSeeds.isEmpty()) {
+			for (GT_ItemStack g : mSeeds) {
+				mList_Master_Seeds.put(g.toStack());
+			}
+		}
+	}
+
+	// Make Fermentation
+	private static void processOreDictEntry(String aOreName, HashSet<GT_ItemStack> mfruits2) {
+		ArrayList<ItemStack> aTemp = OreDictionary.getOres(aOreName);
+		if (!aTemp.isEmpty()) {
+			for (ItemStack stack : aTemp) {
+				mfruits2.add(new GT_ItemStack(stack));
+			}
+		}
+	}
+
+
+	private static void recipeFermentationBase() {
+		processFermentationOreDict();
+		AutoMap<ItemStack> aFruitVege = mList_Master_FruitVege;
+		AutoMap<ItemStack> aSeeds = mList_Master_Seeds;
+		ArrayList<ItemStack> aMap = OreDictionary.getOres("cropSugarbeet");		
+		for (ItemStack a : aFruitVege) {
+			if (aMap.contains(a)) {
+				continue;
+			}
+			if (ItemUtils.checkForInvalidItems(a)) {
+				CORE.RA.addChemicalPlantRecipe(
+						new ItemStack[] {
+								getBioChip(2),
+								ItemUtils.getSimpleStack(a, 10)
+						},
+						new FluidStack[] {
+								FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+						},
+						new ItemStack[] {
+
+						},
+						new FluidStack[] {
+								FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 200),						
+						},
+						60 * 20,
+						2,
+						0);
+			}
+			
+		}
+		for (ItemStack a : aSeeds) {
+			if (ItemUtils.checkForInvalidItems(a)) {
+				CORE.RA.addChemicalPlantRecipe(
+						new ItemStack[] {
+								getBioChip(3),
+								ItemUtils.getSimpleStack(a, 20)
+						},
+						new FluidStack[] {
+								FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+						},
+						new ItemStack[] {
+
+						},
+						new FluidStack[] {
+								FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 50),						
+						},
+						60 * 20,
+						2,
+						0);
+			}			
+		}
+
+		// Sugar Cane
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(4),
+						ItemUtils.getSimpleStack(Items.reeds, 16)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 75),						
+				},
+				90 * 20,
+				30,
+				0);
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(5),
+						ItemUtils.getSimpleStack(Items.reeds, 32),
+						ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 4)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 150),						
+				},
+				120 * 20,
+				30,
+				0);
+
+		// Sugar Beet
+		if (OreDictUtils.containsValidEntries("cropSugarbeet")) {
+
+			CORE.RA.addChemicalPlantRecipe(
+					new ItemStack[] {
+							getBioChip(4),
+							ItemUtils.getItemStackOfAmountFromOreDict("cropSugarbeet", 8),
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+					},
+					new ItemStack[] {
+
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 75),						
+					},
+					60 * 20,
+					30,
+					0);
+
+			CORE.RA.addChemicalPlantRecipe(
+					new ItemStack[] {
+							getBioChip(5),
+							ItemUtils.getItemStackOfAmountFromOreDict("cropSugarbeet", 16),
+							ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 4)
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000),
+					},
+					new ItemStack[] {
+
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 150),						
+					},
+					90 * 20,
+					30,
+					0);
+		}
+
+		// Produce Acetone, Butanol and Ethanol
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(5),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellFermentationBase", 48),
+						ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 16),
+						ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 16),
+				},
+				new FluidStack[] {
+
+				},
+				new ItemStack[] {
+						ItemUtils.getItemStackOfAmountFromOreDict("cellButanol", 6),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellAcetone", 3),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellEthanol", 1),
+						CI.emptyCells(38)
+				},
+				new FluidStack[] {
+
+				},
+				450 * 20,
+				32,
+				1);
+
+
+	}
+
+	private static void recipePropionicAcid() {
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						CI.getGreenCatalyst(0)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mEthylene, 500),
+						FluidUtils.getFluidStack(BioRecipes.mCarbonMonoxide, 500),
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 2000),
+				},
+				new ItemStack[] {
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mPropionicAcid, 250),						
+				},
+				20 * 20,
+				60,
+				1);
+	}
+
+	private static void recipeEthanol() {
+
+		CORE.RA.addDistilleryRecipe(
+				BioRecipes.getBioChip(2),
+				FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000),
+				FluidUtils.getFluidStack(BioRecipes.mEthanol, 100),
+				null,
+				20 * 20,
+				60,
+				false);
+
+	}
+
+	private static void recipeGoldenBrownCelluloseFiber() {
+		CORE.RA.addFluidExtractionRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 20),
+				FluidUtils.getFluidStack(BioRecipes.mAmmonia, 50),
+				20 * 30,
+				120);
+	}
+
+	private static void recipeRedCelluloseFiber() {
+		CORE.RA.addExtractorRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 20),
+				ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 5),
+				20 * 30,
+				240);		
+	}
+
+	private static void recipeSodiumHydroxide() {
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(4)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mSalineWater, 1000),
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(AgriculturalChem.mSodiumHydroxide, 1)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mChlorine, 400),
+						FluidUtils.getFluidStack(BioRecipes.mHydrogen, 600),						
+				},
+				300 * 20,
+				120,
+				1);
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(5),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustSodium", 5)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 5000),
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(AgriculturalChem.mSodiumHydroxide, 5)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mHydrogen, 5000),						
+				},
+				60 * 20,
+				60,
+				1);
+	}
+
+	private static void recipeSodiumCarbonate() {
+
+		if (OreDictUtils.containsValidEntries("fuelCoke")) {			
+			CORE.RA.addChemicalPlantRecipe(
+					new ItemStack[] {
+							getBioChip(18),
+							ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 3),
+							ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 3),
+							ItemUtils.getSimpleStack(AgriculturalChem.mAluminiumPellet, 6)
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+					},
+					new ItemStack[] {
+							ItemUtils.getSimpleStack(AgriculturalChem.mSodiumAluminate, 18)
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mHydrogen, 200),
+							FluidUtils.getFluidStack(BioRecipes.mCarbonDioxide, 1600),
+					},
+					120 * 20,
+					120,
+					1);
+
+		}	
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(18),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustCoal", 6),
+						ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 4),
+						ItemUtils.getSimpleStack(AgriculturalChem.mAluminiumPellet, 6)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(AgriculturalChem.mSodiumAluminate, 16)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mHydrogen, 100),
+						FluidUtils.getFluidStack(BioRecipes.mCarbonDioxide, 1750),
+				},
+				180 * 20,
+				120,
+				1);
+
+	}
+
+	private static void recipePelletMold() {
+		GregtechItemList.Pellet_Mold.set(ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 1));		
+		GT_Values.RA.addLatheRecipe(
+				ALLOY.TUMBAGA.getBlock(1),
+				GregtechItemList.Pellet_Mold.get(1),
+				null,
+				20 * 30 * 15,
+				90);	
+	}
+
+	private static void recipeAluminiumPellet() {
+
+		// Ore Names, no prefix
+		AutoMap<String> aOreNames = new AutoMap<String>();	
+
+		aOreNames.put("Lazurite");
+		aOreNames.put("Bauxite");
+		aOreNames.put("Grossular");
+		aOreNames.put("Pyrope");
+		aOreNames.put("Sodalite");
+		aOreNames.put("Spodumene");
+		aOreNames.put("Ruby");
+		aOreNames.put("Sapphire");
+		aOreNames.put("GreenSapphire");
+
+		// Voltage
+		HashMap<String, Integer> aOreData1 = new HashMap<String, Integer>();
+		// Input Count
+		HashMap<String, Integer> aOreData2 = new HashMap<String, Integer>();
+		// Output Count
+		HashMap<String, Integer> aOreData3 = new HashMap<String, Integer>();
+
+		aOreData1.put("Lazurite", 120);
+		aOreData1.put("Bauxite", 90);
+		aOreData1.put("Grossular", 90);
+		aOreData1.put("Pyrope", 90);
+		aOreData1.put("Sodalite", 90);
+		aOreData1.put("Spodumene", 90);
+		aOreData1.put("Ruby", 60);
+		aOreData1.put("Sapphire", 30);
+		aOreData1.put("GreenSapphire", 30);		
+		aOreData2.put("Lazurite", 14);
+		aOreData2.put("Bauxite", 39);
+		aOreData2.put("Grossular", 20);
+		aOreData2.put("Pyrope", 20);
+		aOreData2.put("Sodalite", 11);
+		aOreData2.put("Spodumene", 10);
+		aOreData2.put("Ruby", 6);
+		aOreData2.put("Sapphire", 5);
+		aOreData2.put("GreenSapphire", 5);
+		aOreData3.put("Lazurite", 3);
+		aOreData3.put("Bauxite", 16);
+		aOreData3.put("Grossular", 2);
+		aOreData3.put("Pyrope", 2);
+		aOreData3.put("Sodalite", 3);
+		aOreData3.put("Spodumene", 1);
+		aOreData3.put("Ruby", 2);
+		aOreData3.put("Sapphire", 2);
+		aOreData3.put("GreenSapphire", 2);
+
+		// Assemble all valid crushed ore types for making pellet mix
+		HashMap<String, ItemStack> aOreCache = new HashMap<String, ItemStack>();
+		for (String aOreName : aOreNames) {
+			String aTemp = aOreName;
+			aOreName = "crushedPurified" + aOreName;
+			if (ItemUtils.doesOreDictHaveEntryFor(aOreName)) {
+				aOreCache.put(aTemp, ItemUtils.getItemStackOfAmountFromOreDict(aOreName, 1));
+			}
+		}
+
+		for (String aOreName : aOreNames) {
+			CORE.RA.addChemicalPlantRecipe(
+					new ItemStack[] {
+							CI.getNumberedBioCircuit(14),
+							ItemUtils.getSimpleStack(aOreCache.get(aOreName), aOreData2.get(aOreName))
+					}, 
+					new FluidStack[] {
+							FluidUtils.getSteam(2000 * aOreData2.get(aOreName))
+					}, 
+					new ItemStack[] {
+							ItemUtils.getSimpleStack(AgriculturalChem.mCleanAluminiumMix, (int) (Math.ceil(aOreData3.get(aOreName) * 1.4)))
+					}, 
+					new FluidStack[] {
+							FluidUtils.getFluidStack(AgriculturalChem.RedMud, 100 * (int) (Math.ceil(aOreData3.get(aOreName) * 1.4)))
+					}, 
+					20 * 60, 
+					aOreData1.get(aOreName), 
+					aOreName.equals("Bauxite") ? 2 : 1);
+		}
+
+		GT_Values.RA.addExtruderRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mCleanAluminiumMix, 3),
+				ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 0),
+				ItemUtils.getSimpleStack(AgriculturalChem.mAluminiumPellet, 4),
+				20 * 30, 
+				64);
+
+
+	}
+
+	private static void recipeAlumina() {
+		GT_Values.RA.addBlastRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mSodiumAluminate, 24),
+				ItemUtils.getSimpleStack(AgriculturalChem.mSodiumHydroxide, 3),
+				FluidUtils.getFluidStack(mCarbonDioxide, 6000), 
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mAlumina, 24),
+				ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 2),
+				20 * 120,
+				120,
+				1200);
+	}
+
+	private static void recipeAluminium() {
+		GT_Values.RA.addBlastRecipe(
+				ItemUtils.getSimpleStack(AgriculturalChem.mAlumina, 24),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustCarbon", 4),
+				GT_Values.NF,
+				GT_Values.NF,
+				ItemUtils.getItemStackOfAmountFromOreDict("dustAluminium", 24),
+				null,
+				20 * 120,
+				120,
+				1600);		
+	}
+
+	private static void recipeCalciumCarbonate() {
+
+	}
+
+	private static void recipeLithiumChloride() {
+
+		if (OreDictUtils.containsValidEntries("dustRockSalt")) {
+			GT_Values.RA.addElectrolyzerRecipe(
+					ItemUtils.getItemStackOfAmountFromOreDict("dustRockSalt", 8), 
+					ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 10),
+					FluidUtils.getFluidStack(BioRecipes.mAir, 4000),
+					FluidUtils.getFluidStack(BioRecipes.mChlorine, 500),					
+					ItemUtils.getItemStackOfAmountFromOreDict("dustLithium", 2), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustSmallLithium", 3), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustSmallLithium", 3), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustTinyLithium", 5), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustPotassium", 2), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustSmallPotassium", 5),					
+					new int[] {7500, 8000, 8500, 9000, 7500, 8500}, 					
+					60 * 30, 
+					60);
+		}
+		if (OreDictUtils.containsValidEntries("dustPotash")) {
+			GT_Values.RA.addElectrolyzerRecipe(
+					ItemUtils.getItemStackOfAmountFromOreDict("dustPotash", 10), 
+					ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 16),
+					FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000),
+					FluidUtils.getFluidStack(BioRecipes.mChlorine, 250),					
+					ItemUtils.getItemStackOfAmountFromOreDict("dustLithium", 3), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustSmallLithium", 5), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustSmallLithium", 5), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustTinyLithium", 7), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustAsh", 2), 
+					ItemUtils.getItemStackOfAmountFromOreDict("dustAsh", 2),					
+					new int[] {7500, 8000, 8500, 9000, 9000, 9000}, 					
+					45 * 30, 
+					90);
+		}
+
+	}
+
+	private static void recipeAlginicAcid() {
+
+		/*// Turn into Cellulose Pulp
+		CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] {
+				getBioChip(7),
+				ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 20),
+				ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 5)
+		},
+				GT_Values.NF,
+				ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 20),
+				90 * 20,
+				16);*/
+	}
+
+	private static void recipeSulfuricAcid() {
+
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(7),
+						ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 10),
+						ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 30)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 2000),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mSulfuricAcid, 50),						
+				},
+				60 * 20,
+				60,
+				1);
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(7),
+						ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 5),
+						ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 30)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 2000),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mSulfuricAcid, 250),						
+				},
+				60 * 20,
+				120,
+				2);
+
+	}
+
+	private static void recipeUrea() {
+
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(9),
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mAmmonia, 600),
+						FluidUtils.getFluidStack(BioRecipes.mCarbonDioxide, 400),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mUrea, 400),	
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 600),						
+				},
+				120 * 20,
+				30,
+				1);
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(9),
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mUrea, 200),
+						FluidUtils.getFluidStack(BioRecipes.mFormaldehyde, 200),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mLiquidResin, 200)						
+				},
+				120 * 20,
+				30,
+				1);
+	}
+
+	private static void recipeRawBioResin() {
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(3),
+						ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 10),
+						ItemUtils.getSimpleStack(Blocks.dirt, 20)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000),
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(AgriculturalChem.mRawBioResin, 1),						
+				},
+				new FluidStack[] {
+
+				},
+				60 * 20,
+				30,
+				1);
+	}
+
+	private static void recipeLiquidResin() {
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(3),
+						ItemUtils.getSimpleStack(AgriculturalChem.mRawBioResin, 1)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mEthanol, 200),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mLiquidResin, 50),						
+				},
+				60 * 20,
+				30,
+				1);
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(3),
+						ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 8)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mLiquidResin, 144),
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(Ic2Items.resin, 1)
+				},
+				new FluidStack[] {
+
+				},
+				120 * 20,
+				30,
+				1);
+
+
+	}
+
+	private static void recipeCompost() {
+		ItemStack aFert;
+		if (LoadedMods.Forestry) {
+			aFert = ItemUtils.getSimpleStack(AgriculturalChem.aFertForestry, 2);			
+			CORE.RA.addChemicalPlantRecipe(
+					new ItemStack[] {
+							getBioChip(11),
+							ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 16),
+							ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 8)
+					},
+					new FluidStack[] {
+							FluidUtils.getFluidStack(BioRecipes.mUrea, 500),
+					},
+					new ItemStack[] {
+							aFert
+					},
+					new FluidStack[] {
+
+					},
+					120 * 20,
+					60,
+					1);
+		}
+
+		aFert = ItemUtils.getSimpleStack(AgriculturalChem.aFertIC2, 2);
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(12),
+						ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 16),
+						ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 8)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mUrea, 500),
+				},
+				new ItemStack[] {
+						aFert
+				},
+				new FluidStack[] {
+
+				},
+				120 * 20,
+				60,
+				1);
+
+	}
+
+	private static void recipeMethane() {
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(12),
+						ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, 20)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 500),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mMethane, 20),						
+				},
+				20 * 20,
+				8,
+				1);
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(13),
+						ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 64),
+						ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 48),
+						ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 32)
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mMethane, 2000),
+				},
+				new ItemStack[] {
+
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mEthylene, 1250),						
+				},
+				60 * 20,
+				60,
+				1);
+	}
+
+	private static void recipeBenzene() {
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(19),
+						CI.getGreenCatalyst(0),
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mMethane, 1000),
+				},
+				new ItemStack[] {
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mBenzene, 500),					
+				},
+				8 * 20,
+				120,
+				2);
+	}
+
+	private static void recipeStyrene() {
+
+		CORE.RA.addChemicalPlantRecipe(
+				new ItemStack[] {
+						getBioChip(20),
+						CI.getGreenCatalyst(0),
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mEthylbenzene, 100),
+				},
+				new ItemStack[] {
+				},
+				new FluidStack[] {
+						FluidUtils.getFluidStack(BioRecipes.mStyrene, 25),					
+				},
+				16 * 20,
+				480,
+				2);
+	}
+
+	private static void recipeBioChip() {
+		GT_ModHandler.addShapelessCraftingRecipe(
+				GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 0L), 0, new Object[]{OrePrefixes.circuit.get(Materials.Primitive)});
+
+		long bits = 0;
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 1L, new Object[0]), bits,
+				new Object[]{"d  ", " P ", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 2L, new Object[0]), bits,
+				new Object[]{" d ", " P ", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 3L, new Object[0]), bits,
+				new Object[]{"  d", " P ", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 4L, new Object[0]), bits,
+				new Object[]{"   ", " Pd", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 5L, new Object[0]), bits,
+				new Object[]{"   ", " P ", "  d", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 6L, new Object[0]), bits,
+				new Object[]{"   ", " P ", " d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 7L, new Object[0]), bits,
+				new Object[]{"   ", " P ", "d  ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 8L, new Object[0]), bits,
+				new Object[]{"   ", "dP ", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 9L, new Object[0]), bits,
+				new Object[]{"P d", "   ", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 10L, new Object[0]), bits,
+				new Object[]{"P  ", "  d", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 11L, new Object[0]), bits,
+				new Object[]{"P  ", "   ", "  d", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 12L, new Object[0]), bits,
+				new Object[]{"P  ", "   ", " d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 13L, new Object[0]), bits,
+				new Object[]{"  P", "   ", "  d", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 14L, new Object[0]), bits,
+				new Object[]{"  P", "   ", " d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 15L, new Object[0]), bits,
+				new Object[]{"  P", "   ", "d  ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 16L, new Object[0]), bits,
+				new Object[]{"  P", "d  ", "   ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 17L, new Object[0]), bits,
+				new Object[]{"   ", "   ", "d P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 18L, new Object[0]), bits,
+				new Object[]{"   ", "d  ", "  P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 19L, new Object[0]), bits,
+				new Object[]{"d  ", "   ", "  P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 20L, new Object[0]), bits,
+				new Object[]{" d ", "   ", "  P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 21L, new Object[0]), bits,
+				new Object[]{"d  ", "   ", "P  ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 22L, new Object[0]), bits,
+				new Object[]{" d ", "   ", "P  ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 23L, new Object[0]), bits,
+				new Object[]{"  d", "   ", "P  ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+		addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 24L, new Object[0]), bits,
+				new Object[]{"   ", "  d", "P  ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])});
+	}
+
+	public static boolean addCraftingRecipe(ItemStack aResult, long aBitMask, Object[] aRecipe) {
+		Method mAddRecipe = ReflectionUtils.getMethod(GT_ModHandler.class, "addCraftingRecipe", new Class[] {
+				ItemStack.class, Enchantment[].class, int[].class,
+				boolean.class, boolean.class, boolean.class, boolean.class,
+				boolean.class, boolean.class, boolean.class, boolean.class,
+				boolean.class, boolean.class, boolean.class, boolean.class,
+				boolean.class, Object[].class});
+		boolean didInvoke = false;
+		if (mAddRecipe != null) {
+			try {
+				didInvoke = (boolean) mAddRecipe.invoke(null, aResult,
+						new Enchantment[] {},
+						new int[] {},
+						false,
+						false,
+						false,
+						false,
+						false,
+						false,
+						false,
+						false,
+						false,
+						false,
+						false, 
+						false, 
+						true, 
+						aRecipe);
+			}
+			catch (IllegalAccessException | IllegalArgumentException
+					| InvocationTargetException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+		return didInvoke;
+
+
+	}
+
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/src/main/java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java
new file mode 100644
index 0000000000..4cf31e9335
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java
@@ -0,0 +1,70 @@
+package gtPlusPlus.plugin.agrichem;
+
+import java.util.List;
+
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.plugin.agrichem.block.AgrichemFluids;
+import gtPlusPlus.plugin.agrichem.fluids.FluidLoader;
+import gtPlusPlus.plugin.agrichem.item.algae.ItemAgrichemBase;
+import gtPlusPlus.plugin.agrichem.item.algae.ItemAlgaeBase;
+import gtPlusPlus.plugin.agrichem.item.algae.ItemBioChip;
+import gtPlusPlus.plugin.manager.Core_Manager;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class Core_Agrichem implements IPlugin {
+
+	final static Core_Agrichem mInstance;
+	
+
+	static {
+		mInstance = new Core_Agrichem();
+		Core_Manager.registerPlugin(mInstance);
+		mInstance.log("Preparing "+mInstance.getPluginName()+" for use.");
+	}
+
+	@Override
+	public boolean preInit() {
+		mInstance.log("Generating Fluids");		
+		FluidLoader.generate();
+		AgrichemFluids.init();
+		mInstance.log("Generating Items");
+		return true;
+	}
+
+	@Override
+	public boolean init() {
+		mInstance.log("Setting Items");	
+		return true;
+	}
+
+	@Override
+	public boolean postInit() {
+		mInstance.log("Generating Recipes");
+		return true;
+	}
+
+	@Override
+	public boolean serverStart() {
+		return true;
+	}
+
+	@Override
+	public boolean serverStop() {
+		return true;
+	}
+
+	@Override
+	public String getPluginName() {
+		return "GT++ Agrichemistry Module";
+	}
+
+	@Override
+	public String getPluginAbbreviation() {
+		return "FARM";
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/IAlgalItem.java b/src/main/java/gtPlusPlus/plugin/agrichem/IAlgalItem.java
new file mode 100644
index 0000000000..fada07d062
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/IAlgalItem.java
@@ -0,0 +1,12 @@
+package gtPlusPlus.plugin.agrichem;
+
+import gtPlusPlus.plugin.agrichem.logic.AlgaeGeneticData;
+import net.minecraft.item.ItemStack;
+
+public interface IAlgalItem {
+
+	public abstract AlgaeDefinition getAlgaeType(ItemStack aStack);
+	
+	public abstract AlgaeGeneticData getSpeciesData(ItemStack aStack);	
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java b/src/main/java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java
new file mode 100644
index 0000000000..039dd702da
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java
@@ -0,0 +1,88 @@
+package gtPlusPlus.plugin.agrichem.block;
+
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+
+public class AgrichemFluids {
+
+	/*
+	 * Saline Water - saltwater
+	 * Sulfuric Waste Water - sulfuricapatite
+	 * Methanol - methanol
+	 * Hot Water - ic2hotwater
+	 * Acetic Acid
+	 * Propionic Acid
+	 * Fermentation Base
+	 * Ethylene - ethylene
+	 * Ethanol - bioethanol
+	 * Diluted SA - filutedsulfuricacid
+	 * Sulfuric Acid - sulfuricacid
+	 * Urea
+	 * Formaldehyde - fluid.formaldehyde
+	 * Liquid Resin
+	 * Methane - methane
+	 * Benzene - benzene
+	 * Ethylbenzene - fluid.ethylbenzene
+	 * Styrene - styrene
+	 */
+
+	public static Fluid mAceticAcid;
+	public static Fluid mPropionicAcid;
+	public static Fluid mFermentationBase;
+	public static Fluid mUrea;
+	public static Fluid mLiquidResin;
+	public static Fluid mAcetone;
+	public static Fluid mButanol;
+	
+	
+	
+	public static void init() {
+		if (!FluidRegistry.isFluidRegistered("aceticacid")) {
+			mAceticAcid = FluidUtils.generateFluidNoPrefix("aceticacid", "Acetic Acid", 200, new short[] { 97, 168, 96, 100 }, true);			
+		}
+		else {
+			mAceticAcid = FluidRegistry.getFluid("aceticacid");
+		}
+		if (!FluidRegistry.isFluidRegistered("propionicacid")) {
+			mPropionicAcid = FluidUtils.generateFluidNoPrefix("propionicacid", "Propionic Acid", 200,	new short[] { 198, 209, 148, 100 }, true);			
+		}
+		else {
+			mPropionicAcid = FluidRegistry.getFluid("propionicacid");
+		}
+		if (!FluidRegistry.isFluidRegistered("fermentation.base")) {
+			mFermentationBase = FluidUtils.generateFluidNoPrefix("fermentation.base", "Fermentation Base", 200,	new short[] { 107, 100, 63, 100 }, true);			
+		}
+		else {
+			mFermentationBase = FluidRegistry.getFluid("fermentation.base");
+		}
+		if (!FluidRegistry.isFluidRegistered("ureamix")) {
+			mUrea = FluidUtils.generateFluidNoPrefix("ureamix", "Urea Mix", 200, new short[] { 71, 55, 12, 100 }, true);			
+		}
+		else {
+			mUrea = FluidRegistry.getFluid("ureamix");
+		}
+		if (!FluidRegistry.isFluidRegistered("liquidresin")) {
+			mLiquidResin = FluidUtils.generateFluidNoPrefix("liquidresin", "Liquid Resin", 200,	new short[] { 59, 58, 56, 100 }, true);			
+		}
+		else {
+			mLiquidResin = FluidRegistry.getFluid("liquidresin");
+		}
+		
+		if (!FluidRegistry.isFluidRegistered("acetone")) {
+			mAcetone = FluidUtils.generateFluidNoPrefix("acetone", "Acetone", 200,	new short[] { 59, 58, 56, 100 }, true);			
+		}
+		else {
+			mAcetone = FluidRegistry.getFluid("acetone");
+		}
+		if (!FluidRegistry.isFluidRegistered("butanol")) {
+			mButanol = FluidUtils.generateFluidNoPrefix("butanol", "Butanol", 200,	new short[] { 159, 58, 56, 100 }, true);			
+		}
+		else {
+			mButanol = FluidRegistry.getFluid("butanol");
+		}
+	}
+	
+	
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/fluids/FluidLoader.java b/src/main/java/gtPlusPlus/plugin/agrichem/fluids/FluidLoader.java
new file mode 100644
index 0000000000..a60a8c09de
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/fluids/FluidLoader.java
@@ -0,0 +1,21 @@
+package gtPlusPlus.plugin.agrichem.fluids;
+
+import gtPlusPlus.core.fluids.FluidFactory;
+
+public class FluidLoader {
+	
+	private static final int ID_DIRTY_WATER = 50;
+	private static final int ID_RAW_SEWERAGE = 51;
+	private static final int ID_GUANO = 52;
+	private static final int ID_POOPJUICE = 53;
+	
+	public static void generate() {
+
+		FluidFactory.generate(ID_DIRTY_WATER, "dirtywater", new short[] {25, 25, 180});
+		FluidFactory.generate(ID_RAW_SEWERAGE, "sewerage", new short[] {100, 45, 25});
+		FluidFactory.generate(ID_GUANO, "guano", new short[] {175, 175, 180});
+		FluidFactory.generate(ID_POOPJUICE, "poo", new short[] {75, 45, 10});
+		
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java b/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java
new file mode 100644
index 0000000000..abeebc054d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java
@@ -0,0 +1,312 @@
+package gtPlusPlus.plugin.agrichem.item.algae;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gtPlusPlus.core.item.chemistry.general.ItemGenericChemBase;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.OreDictUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class ItemAgrichemBase extends Item {
+
+	final protected IIcon base[];
+	
+	/*
+	 * 0 - Algae Biomass
+	 * 1 - Green Algae Biomass
+	 * 2 - Brown Algae Biomass
+	 * 3 - Golden-Brown Algae Biomass
+	 * 4 - Red Algae Biomass
+	 * 5 - Cellulose Fiber
+	 * 6 - Golden-Brown Cellulose Fiber
+	 * 7 - Red Cellulose Fiber
+	 * 8 - Compost
+	 * 9 - Wood Pellet
+	 * 10 - Wood Brick
+	 * 11 - Cellulose Pulp
+	 * 12 - Raw Bio Resin
+	 * 13 - Catalyst Carrier
+	 * 14 - Green Metal Catalyst
+	 * 15 - Alginic Acid
+	 * 16 - Alumina
+	 * 17 - Aluminium Pellet
+	 * 18 - Sodium Aluminate
+	 * 19 - Sodium Hydroxide // Exists in Newer GT
+	 * 20 - Sodium Carbonate
+	 * 21 - Lithium Chloride
+	 * 22 - Pellet Mold
+	 * 23 - Clean Aluminium Mix
+	 * 24 - Pinecone
+	 * 25 - Crushed Pine
+	 */
+	
+	public ItemAgrichemBase() {
+		this.setHasSubtypes(true);
+		this.setNoRepair();
+		this.setMaxStackSize(64);
+		this.setMaxDamage(0);		
+		base = new IIcon[26];		
+		this.setUnlocalizedName("BasicAgrichemItem");
+		GameRegistry.registerItem(this, this.getUnlocalizedName());
+	}
+	
+	@Override
+	public boolean isDamageable() {
+		return false;
+	}
+
+	@Override
+	public boolean shouldRotateAroundWhenRendering() {
+		return super.shouldRotateAroundWhenRendering();
+	}
+
+	@Override
+	public void onUpdate(ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) {
+		super.onUpdate(p_77663_1_, p_77663_2_, p_77663_3_, p_77663_4_, p_77663_5_);
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack aStack) {
+		return super.getItemStackDisplayName(aStack);
+	}
+
+	@Override
+	public EnumRarity getRarity(ItemStack p_77613_1_) {
+		return EnumRarity.common;
+	}
+
+	@Override
+	public boolean requiresMultipleRenderPasses() {
+		return false;
+	}
+
+	private static boolean mHasCheckedForSodiumHydroxide = false;
+	private static boolean mShowSodiumHydroxide = true;
+	
+	private static boolean checkSodiumHydroxide() {
+		if (mHasCheckedForSodiumHydroxide) {
+			return mShowSodiumHydroxide;
+		}
+		else {
+			if (OreDictUtils.containsValidEntries("dustSodiumHydroxide_GT5U")
+					|| OreDictUtils.containsValidEntries("dustSodiumHydroxide")) {
+				List<ItemStack> aTest = OreDictionary.getOres(
+						"dustSodiumHydroxide", false
+				);
+				if (aTest.isEmpty()) {
+					aTest = OreDictionary.getOres(
+							"dustSodiumHydroxide_GT5U", false
+					);
+					if (!aTest.isEmpty()) {
+						mShowSodiumHydroxide = false;
+					}
+				}
+				else {
+					mShowSodiumHydroxide = false;
+				}
+			}
+		}		
+		mHasCheckedForSodiumHydroxide = true;
+		return mShowSodiumHydroxide;
+	}
+
+	@Override
+	public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) {
+		for (int i=0;i<base.length;i++) {
+			if (i == 19) {
+				// Only show if it doesn't exist.
+				if (checkSodiumHydroxide()) {
+					aList.add(ItemUtils.simpleMetaStack(aItem, i, 1));					
+				}
+			}
+			else {
+				aList.add(ItemUtils.simpleMetaStack(aItem, i, 1));				
+			}
+		}
+	}
+
+	@Override
+	public boolean getIsRepairable(ItemStack p_82789_1_, ItemStack p_82789_2_) {
+		return false;
+	}
+
+	@Override
+	public boolean isRepairable() {
+		return false;
+	}
+
+	@Override
+	public boolean isBookEnchantable(ItemStack stack, ItemStack book) {
+		return false;
+	}
+
+	@Override
+	public int getDisplayDamage(ItemStack stack) {
+		return stack.getItemDamage();
+	}
+
+	@Override
+	public int getItemEnchantability() {
+		return 0;
+	}
+
+	@Override
+	public int getItemEnchantability(ItemStack stack) {
+		return 0;
+	}
+
+	@Override
+	public void registerIcons(final IIconRegister u) {
+		for (int i=0;i<this.base.length;i++) {
+			String aPath = CORE.MODID + ":" + "bioscience/MetaItem1/"+i;
+			this.base[i] = u.registerIcon(aPath);										
+		}
+	}
+	
+	
+	private boolean isTextureValid(String aPath) {
+		if (aPath == null) {
+			return false;
+		}
+		else if (aPath.indexOf(92) == -1) {
+			Constructor aTextureAtlasSprite = ReflectionUtils.getConstructor(
+					TextureAtlasSprite.class, String.class
+			);
+			if (aTextureAtlasSprite != null) {
+				try {
+					TextureAtlasSprite aTestAtlas = (TextureAtlasSprite) aTextureAtlasSprite.newInstance(
+							aPath
+					);
+					if (aTestAtlas != null) {
+						return true;
+					}
+				}
+				catch (InstantiationException | IllegalAccessException
+						| IllegalArgumentException
+						| InvocationTargetException e) {
+				}
+			}
+		}
+		return false;
+	}
+	
+	@Override
+	public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) {
+		return this.base[damage];		
+	}
+
+	@Override
+	public IIcon getIconFromDamage(int damage) {
+		return this.base[damage];	
+	}
+
+	@Override
+	public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) {
+		return this.base[stack.getItemDamage()];
+	}
+
+	@Override
+	public IIcon getIcon(ItemStack stack, int pass) {
+		return this.base[stack.getItemDamage()];	
+	}
+
+	@Override
+    public String getUnlocalizedName(ItemStack stack) {
+		return super.getUnlocalizedName() + "." + stack.getItemDamage();
+    }
+	
+
+
+	@Override
+	public double getDurabilityForDisplay(ItemStack aStack) {
+		if (ItemUtils.isCatalyst(aStack)) {			
+			if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()){
+				createCatalystNBT(aStack);
+	        }
+			double currentDamage = getCatalystDamage(aStack);
+			return currentDamage / getCatalystMaxDamage(aStack);
+		}
+		else {
+			return 1D;
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public void addInformation(ItemStack aStack, EntityPlayer player, List list, boolean bool) {
+		boolean aHasSpecialTooltips = false;
+		int aMaxDamage = 0;
+		int aDamageSegment = 0;
+		int aDam = 0;
+		EnumChatFormatting durability = EnumChatFormatting.GRAY;
+		if (ItemUtils.isCatalyst(aStack)) {
+			list.add(EnumChatFormatting.GRAY+"Active Reaction Agent");
+			aMaxDamage = getCatalystMaxDamage(aStack);
+			aDamageSegment = aMaxDamage / 5;
+			aDam = aMaxDamage-getCatalystDamage(aStack);
+			aHasSpecialTooltips = true;
+		}
+		if (aHasSpecialTooltips) {			
+			if (aDam > aDamageSegment * 3){
+				durability = EnumChatFormatting.GREEN;
+			}
+			else if (aDam > aDamageSegment * 2){
+				durability = EnumChatFormatting.YELLOW;
+			}
+			else if (aDam > aDamageSegment){
+				durability = EnumChatFormatting.GOLD;
+			}
+			else if (aDam >= 0){
+				durability = EnumChatFormatting.RED;
+			}
+			list.add(durability+""+(aDam)+EnumChatFormatting.GRAY+" / "+aMaxDamage);
+		}
+		super.addInformation(aStack, player, list, bool);
+	}
+	
+	@Override
+	public boolean showDurabilityBar(ItemStack aStack) {
+		if (ItemUtils.isCatalyst(aStack)) {
+			int aDam = getCatalystDamage(aStack);
+			return aDam > 0;
+		}
+		return false;
+	}
+	
+	public static boolean createCatalystNBT(ItemStack rStack){
+		return ItemGenericChemBase.createCatalystNBT(rStack);
+	}
+
+	public static int getCatalystDamage(ItemStack aStack) {
+		return ItemGenericChemBase.getCatalystDamage(aStack);
+	}
+	
+	public static int getCatalystMaxDamage(ItemStack aStack) {
+		return ItemGenericChemBase.getCatalystMaxDamage(aStack);
+	}
+
+	public static void setCatalystDamage(ItemStack aStack,int aAmount) {
+		ItemGenericChemBase.setCatalystDamage(aStack, aAmount);
+	}
+	
+	public static int getMaxCatalystDurability(ItemStack aStack) {
+		return ItemGenericChemBase.getMaxCatalystDurability(aStack);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java b/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java
new file mode 100644
index 0000000000..6b31a42809
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java
@@ -0,0 +1,235 @@
+package gtPlusPlus.plugin.agrichem.item.algae;
+
+import java.util.List;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.plugin.agrichem.AlgaeDefinition;
+import gtPlusPlus.plugin.agrichem.IAlgalItem;
+import gtPlusPlus.plugin.agrichem.logic.AlgaeGeneticData;
+import gtPlusPlus.plugin.agrichem.logic.AlgaeGrowthRequirement;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+public class ItemAlgaeBase extends Item implements IAlgalItem {
+
+	protected IIcon base;	
+	protected IIcon overlay;	
+	
+	public ItemAlgaeBase() {
+		this.setHasSubtypes(true);
+		this.setMaxDamage(127);
+		this.setNoRepair();
+		this.setMaxStackSize(32);
+		this.setUnlocalizedName("BasicAlgaeItem");
+		GameRegistry.registerItem(this, this.getUnlocalizedName());
+	}
+	
+	@Override
+	public boolean isDamageable() {
+		return false;
+	}
+
+	@Override
+	public boolean shouldRotateAroundWhenRendering() {
+		return super.shouldRotateAroundWhenRendering();
+	}
+
+	@Override
+	public void onUpdate(ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) {
+		if (!p_77663_1_.hasTagCompound() || p_77663_1_.getTagCompound().hasNoTags()) {
+			p_77663_1_ = initNBT(p_77663_1_);
+		}
+		super.onUpdate(p_77663_1_, p_77663_2_, p_77663_3_, p_77663_4_, p_77663_5_);
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack aStack) {
+		return EnumChatFormatting.UNDERLINE+super.getItemStackDisplayName(aStack);
+	}
+
+	@Override
+	public void addInformation(ItemStack aStack, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) {
+		int aDam = aStack.getItemDamage();
+		try {
+		aList.add(AlgaeDefinition.getByIndex(aDam).mSimpleName);
+		if (!aStack.hasTagCompound() || aStack.getTagCompound().hasNoTags()) {
+			aStack = initNBT(aStack);
+		}
+		else {
+			NBTTagCompound aNBT = aStack.getTagCompound();
+			boolean mRequiresLight = aNBT.getBoolean("mRequiresLight");
+			boolean mSaltWater = aNBT.getBoolean("mSaltWater");
+			boolean mFreshWater = aNBT.getBoolean("mFreshWater");
+			byte mTempTolerance = aNBT.getByte("mTempTolerance");
+			float mFertility = aNBT.getFloat("mFertility");
+			float mProductionSpeed = aNBT.getFloat("mProductionSpeed");
+			byte mLifespan = aNBT.getByte("mLifespan");
+			int mGeneration = aNBT.getInteger("mGeneration");			
+
+			aList.add("Requires Light: "+mRequiresLight);
+			aList.add("Salt Water: "+mSaltWater);
+			aList.add("Fresh Water: "+mFreshWater);
+			aList.add("Temp Tolerance: "+mTempTolerance);
+			aList.add("Growth: "+mFertility);
+			aList.add("Production: "+mProductionSpeed);
+			aList.add("Lifespan in days: "+mLifespan);
+			aList.add("Generation: "+mGeneration);			
+		}		
+		}
+		catch (Throwable t) {
+			t.printStackTrace();
+		}
+		super.addInformation(aStack, p_77624_2_, aList, p_77624_4_);
+	}
+
+	@Override
+	public EnumRarity getRarity(ItemStack p_77613_1_) {
+		return EnumRarity.uncommon;
+	}
+
+	@Override
+	public boolean requiresMultipleRenderPasses() {
+		return true;
+	}
+
+	@Override
+	public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) {
+		for (int i=0;i<AlgaeDefinition.values().length;i++) {
+			aList.add(ItemUtils.simpleMetaStack(aItem, i, 1));
+		}
+	}
+
+	@Override
+	public boolean getIsRepairable(ItemStack p_82789_1_, ItemStack p_82789_2_) {
+		return false;
+	}
+
+	@Override
+	public boolean isRepairable() {
+		return false;
+	}
+
+	@Override
+	public boolean isBookEnchantable(ItemStack stack, ItemStack book) {
+		return false;
+	}
+
+	@Override
+	public int getDisplayDamage(ItemStack stack) {
+		return stack.getItemDamage();
+	}
+
+	@Override
+	public boolean showDurabilityBar(ItemStack stack) {
+		return false;
+	}
+
+	@Override
+	public int getItemEnchantability() {
+		return 0;
+	}
+
+	@Override
+	public int getItemEnchantability(ItemStack stack) {
+		return 0;
+	}
+
+	@Override
+	public int getColorFromItemStack(ItemStack aStack, int aMeta) {
+		return AlgaeDefinition.getByIndex(aStack.getItemDamage()).mColour;
+	}
+	
+	@Override
+	public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) {
+		if(pass == 0) {
+			return this.base;
+		}
+		return this.overlay;	
+	}
+
+	@Override
+	public void registerIcons(final IIconRegister i) {
+		this.base = i.registerIcon(CORE.MODID + ":" + "bioscience/BasicAlgae");
+		this.overlay = i.registerIcon(CORE.MODID + ":" + "bioscience/BasicAlgae" + "_Overlay");		
+	}
+	
+	public static ItemStack initNBT(ItemStack aFreshAlgae) {
+		NBTTagCompound aNewTag = new NBTTagCompound();
+		ItemAlgaeBase aItem;
+		if (aFreshAlgae.getItem() instanceof ItemAlgaeBase) {
+			aItem = (ItemAlgaeBase) aFreshAlgae.getItem();
+			if (!aFreshAlgae.hasTagCompound()) {
+				AlgaeGeneticData y = aItem.getSpeciesData(aFreshAlgae);
+				aNewTag = y.writeToNBT();				
+				aFreshAlgae.setTagCompound(aNewTag);
+			}
+			else {
+				aNewTag = aFreshAlgae.getTagCompound();
+			}	
+		}			
+		return aFreshAlgae;
+	}
+
+	@Override
+	public AlgaeDefinition getAlgaeType(ItemStack aStack) {
+		return AlgaeDefinition.getByIndex(aStack != null ? aStack.getItemDamage() : 3);
+	}
+
+	@Override
+	public AlgaeGeneticData getSpeciesData(ItemStack aStack) {
+		NBTTagCompound aTag;
+		if (!aStack.hasTagCompound() || aStack.getTagCompound().hasNoTags()) {
+			aTag = new NBTTagCompound();
+			AlgaeGeneticData aGenes;
+			if (aStack.getItemDamage() < 3 || aStack.getItemDamage() > 5) {
+				aGenes = new AlgaeGeneticData();
+				aTag = aGenes.writeToNBT();
+			}
+			else {
+				byte aTemp, aLifespan;
+				float aFert, aSpeed;
+				
+				int aDam = aStack.getItemDamage();
+				aTemp = (byte) (aDam == 3 ? 0 : aDam == 4 ? 2 : 1);
+				aLifespan = (byte) (aDam == 3 ? 1 : aDam == 4 ? 3f : 2f);
+				aFert = (float) (aDam == 3 ? 2f : aDam == 4 ? 1f : 1.75f);
+				aSpeed = (float) (aDam == 3 ? 1f : aDam == 4 ? 1.5f : 2f);
+				
+				aGenes = new AlgaeGeneticData(
+						true, true,
+						AlgaeDefinition.getByIndex(aDam).mSaltWater, AlgaeDefinition.getByIndex(aDam).mFreshWater,
+						aTemp,
+						aFert,
+						aSpeed,
+						aLifespan,
+						0,
+						new AutoMap<AlgaeGrowthRequirement>());
+				aTag = aGenes.writeToNBT();
+			}
+		}
+		else {
+			aTag = aStack.getTagCompound();
+		}
+		
+		
+		
+		
+		return new AlgaeGeneticData(aTag);
+	}
+	
+	
+	
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java b/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java
new file mode 100644
index 0000000000..f876839f5f
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java
@@ -0,0 +1,238 @@
+package gtPlusPlus.plugin.agrichem.item.algae;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUIDialogSelectItem;
+import gregtech.api.interfaces.INetworkUpdatableItem;
+import gregtech.api.net.GT_Packet_UpdateItem;
+import gregtech.api.objects.XSTR;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.*;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.FakePlayer;
+import org.apache.commons.lang3.tuple.Pair;
+
+public class ItemBioChip extends Item implements INetworkUpdatableItem {
+	private static final List<ItemStack> ALL_VARIANTS = new ArrayList<>();
+
+	protected IIcon base;
+	
+	public ItemBioChip() {
+		this.setHasSubtypes(true);
+		this.setNoRepair();
+		this.setMaxStackSize(64);
+		this.setMaxDamage(0);
+		this.setUnlocalizedName("BioRecipeSelector");
+		GameRegistry.registerItem(this, this.getUnlocalizedName());
+		ALL_VARIANTS.add(new ItemStack(this, 0, 0));
+		for (int i = 1; i <= 24; i++) {
+			ItemStack aStack = new ItemStack(this, 0, i);
+			ALL_VARIANTS.add(aStack);
+		}
+	}
+	
+	@Override
+	public boolean isDamageable() {
+		return false;
+	}
+
+	@Override
+	public boolean shouldRotateAroundWhenRendering() {
+		return super.shouldRotateAroundWhenRendering();
+	}
+
+	@Override
+	public void onUpdate(ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) {
+		super.onUpdate(p_77663_1_, p_77663_2_, p_77663_3_, p_77663_4_, p_77663_5_);
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack aStack) {
+		return super.getItemStackDisplayName(aStack);
+	}
+
+	@Override
+	public void addInformation(ItemStack aStack, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) {
+		try {
+			aList.add("Configuration == "+aStack.getItemDamage());
+			aList.add(GT_LanguageManager.addStringLocalization(new StringBuilder().append(getUnlocalizedName()).append(".tooltip.0").toString(), "Right click to reconfigure"));
+			aList.add(GT_LanguageManager.addStringLocalization(new StringBuilder().append(getUnlocalizedName()).append(".tooltip.1").toString(), "Needs a screwdriver or circuit programming tool"));
+		}
+		catch (Throwable t) {
+			t.printStackTrace();
+		}
+		super.addInformation(aStack, p_77624_2_, aList, p_77624_4_);
+	}
+
+	@Override
+	public EnumRarity getRarity(ItemStack p_77613_1_) {
+		return EnumRarity.common;
+	}
+
+	@Override
+	public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) {
+			aList.add(ItemUtils.simpleMetaStack(aItem, 0, 1));		
+	}
+
+	@Override
+	public boolean getIsRepairable(ItemStack p_82789_1_, ItemStack p_82789_2_) {
+		return false;
+	}
+
+	@Override
+	public boolean isRepairable() {
+		return false;
+	}
+
+	@Override
+	public boolean isBookEnchantable(ItemStack stack, ItemStack book) {
+		return false;
+	}
+
+	@Override
+	public int getDisplayDamage(ItemStack stack) {
+		return stack.getItemDamage();
+	}
+
+	@Override
+	public boolean showDurabilityBar(ItemStack stack) {
+		return false;
+	}
+
+	@Override
+	public int getItemEnchantability() {
+		return 0;
+	}
+
+	@Override
+	public int getItemEnchantability(ItemStack stack) {
+		return 0;
+	}
+
+	@Override
+	public void registerIcons(final IIconRegister u) {
+		this.base = u.registerIcon(CORE.MODID + ":" + "bioscience/BioCircuit");				
+	}
+	
+	@Override
+	public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) {
+		return this.base;		
+	}
+
+	@Override
+	public IIcon getIconFromDamage(int damage) {
+		return this.base;	
+	}
+
+	@Override
+	public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) {
+		return this.base;
+	}
+
+	@Override
+	public IIcon getIcon(ItemStack stack, int pass) {
+		return this.base;	
+	}
+
+	@Override
+    public String getUnlocalizedName(ItemStack stack) {
+		return super.getUnlocalizedName();
+    }
+
+	@Override
+	public boolean receive(ItemStack stack, EntityPlayerMP player, NBTTagCompound tag) {
+		int meta = tag.hasKey("meta", Constants.NBT.TAG_BYTE) ? tag.getByte("meta") : -1;
+		if (meta < 0 || meta > 24)
+			return true;
+
+		if (!player.capabilities.isCreativeMode) {
+			Pair<Integer, BiFunction<ItemStack, EntityPlayerMP, ItemStack>> toolIndex = findConfiguratorInInv(player);
+			if (toolIndex == null) return true;
+
+			ItemStack[] mainInventory = player.inventory.mainInventory;
+			mainInventory[toolIndex.getKey()] = toolIndex.getValue().apply(mainInventory[toolIndex.getKey()], player);
+		}
+		stack.setItemDamage(meta);
+
+		return true;
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float xOffset, float yOffset, float zOffset) {
+		// nothing on server side or fake player
+		if (player instanceof FakePlayer || !world.isRemote) return false;
+		// check if any screwdriver
+		ItemStack configuratorStack;
+		if (player.capabilities.isCreativeMode) {
+			configuratorStack = null;
+		} else {
+			Pair<Integer, ?> configurator = findConfiguratorInInv(player);
+			if (configurator == null) {
+				int count;
+				try {
+					count = Integer.parseInt(StatCollector.translateToLocal("GT5U.item.programmed_circuit.no_screwdriver.count"));
+				} catch (NumberFormatException e) {
+					player.addChatComponentMessage(new ChatComponentText("Error in translation GT5U.item.programmed_circuit.no_screwdriver.count: " + e.getMessage()));
+					count = 1;
+				}
+				player.addChatComponentMessage(new ChatComponentTranslation("GT5U.item.programmed_circuit.no_screwdriver." + XSTR.XSTR_INSTANCE.nextInt(count)));
+				return false;
+			}
+			configuratorStack = player.inventory.mainInventory[configurator.getKey()];
+		}
+		openSelectorGui(configuratorStack, stack.getItemDamage());
+		return true;
+	}
+
+	private void openSelectorGui(ItemStack configurator, int meta) {
+		FMLCommonHandler.instance().showGuiScreen(new GT_GUIDialogSelectItem(
+				StatCollector.translateToLocal("GT5U.item.programmed_circuit.select.header"),
+				configurator,
+				null,
+				ItemBioChip::onConfigured,
+				ALL_VARIANTS,
+				meta,
+				true
+		));
+	}
+
+	private static void onConfigured(ItemStack stack) {
+		NBTTagCompound tag = new NBTTagCompound();
+		tag.setByte("meta", (byte) stack.getItemDamage());
+		GT_Values.NW.sendToServer(new GT_Packet_UpdateItem(tag));
+	}
+
+	private static Pair<Integer, BiFunction<ItemStack, EntityPlayerMP, ItemStack>> findConfiguratorInInv(EntityPlayer player) {
+		ItemStack[] mainInventory = player.inventory.mainInventory;
+		for (int j = 0, mainInventoryLength = mainInventory.length; j < mainInventoryLength; j++) {
+			ItemStack toolStack = mainInventory[j];
+
+			if (!GT_Utility.isStackValid(toolStack))
+				continue;
+
+			for (Map.Entry<Predicate<ItemStack>, BiFunction<ItemStack, EntityPlayerMP, ItemStack>> p : GregTech_API.sCircuitProgrammerList.entrySet())
+				if (p.getKey().test(toolStack))
+					return Pair.of(j, p.getValue());
+		}
+		return null;
+	}
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java b/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java
new file mode 100644
index 0000000000..dfe0f50b47
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java
@@ -0,0 +1,130 @@
+package gtPlusPlus.plugin.agrichem.logic;
+
+import gtPlusPlus.api.objects.data.AutoMap;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class AlgaeGeneticData {
+	
+	private final int mLifespan;	
+	
+	private final int mGeneration;
+	
+	private final boolean mIsDominant;
+	
+	private final boolean mRequiresLight;
+	
+	private final boolean mSaltWater;
+	
+	private final boolean mFreshWater;
+	
+	private final byte mTempTolerance;
+	
+	private final float mFertility;
+	
+	private final float mProductionSpeed;
+	
+	private final AutoMap<AlgaeGrowthRequirement> mSpecialRequirements;
+	
+
+	public AlgaeGeneticData() {
+		this(true, true, true, true, (byte) 0, 1f, 1f, (byte) 30, 0, new AutoMap<AlgaeGrowthRequirement>());
+	}
+	
+	public AlgaeGeneticData(boolean isDominant, boolean requiresLight, boolean isSalt, boolean isFresh, 
+			byte aTempTolerance, float aFertility, float aSpeed, byte aLifespan, int aGeneration, AutoMap<AlgaeGrowthRequirement> aRequirements) {
+		mIsDominant = isDominant;
+		mRequiresLight = requiresLight;
+		mSaltWater = isSalt;
+		mFreshWater = isFresh;
+		mTempTolerance = aTempTolerance;
+		mFertility = aFertility;
+		mProductionSpeed = aSpeed;
+		mLifespan = aLifespan;
+		mGeneration = aGeneration;
+		mSpecialRequirements = aRequirements;
+	}
+
+	
+	public AlgaeGeneticData(NBTTagCompound aNBT) {
+		if (aNBT == null || aNBT.hasNoTags()) {
+			mIsDominant = true;
+			mRequiresLight = true;
+			mSaltWater = true;
+			mFreshWater = true;
+			mTempTolerance = 0;
+			mFertility = 1;
+			mProductionSpeed = 1;
+			mLifespan = 30;
+			mGeneration = 0;
+		}
+		else {
+			mIsDominant = aNBT.getBoolean("mIsDominant");
+			mRequiresLight = aNBT.getBoolean("mRequiresLight");
+			mSaltWater = aNBT.getBoolean("mSaltWater");
+			mFreshWater = aNBT.getBoolean("mFreshWater");
+			mTempTolerance = aNBT.getByte("mTempTolerance");
+			mFertility = aNBT.getFloat("mFertility");
+			mProductionSpeed = aNBT.getFloat("mProductionSpeed");
+			mLifespan = aNBT.getByte("mLifespan");
+			mGeneration = aNBT.getInteger("mGeneration");
+		}
+		mSpecialRequirements = new AutoMap<AlgaeGrowthRequirement>();
+	}
+
+	/**
+	 * In MC Days
+	 */
+	public final int getLifespan() {
+		return this.mLifespan;
+	}
+
+	public final boolean isDominant() {
+		return this.mIsDominant;
+	}
+
+	public final boolean RequiresLight() {
+		return this.mRequiresLight;
+	}
+
+	public final boolean isSaltWater() {
+		return this.mSaltWater;
+	}
+
+	public final boolean isFreshWater() {
+		return this.mFreshWater;
+	}
+
+	public final byte getTempTolerance() {
+		return this.mTempTolerance;
+	}
+
+	public final float getFertility() {
+		return this.mFertility;
+	}
+
+	public final float getProductionSpeed() {
+		return this.mProductionSpeed;
+	}
+
+	public final int getGeneration() {
+		return this.mGeneration;
+	}
+
+	public final AutoMap<AlgaeGrowthRequirement> getSpecialRequirements() {
+		return this.mSpecialRequirements;
+	}
+	
+	public NBTTagCompound writeToNBT() {
+		NBTTagCompound aGenes = new NBTTagCompound();
+		aGenes.setBoolean("mIsDominant", this.mIsDominant);
+		aGenes.setBoolean("mRequiresLight", this.mRequiresLight);
+		aGenes.setBoolean("mSaltWater", this.mSaltWater);
+		aGenes.setBoolean("mFreshWater", this.mFreshWater);
+		aGenes.setInteger("mLifespan", this.mLifespan);
+		aGenes.setInteger("mGeneration", this.mGeneration);
+		aGenes.setByte("mTempTolerance", this.mTempTolerance);
+		aGenes.setFloat("mFertility", this.mFertility);
+		aGenes.setFloat("mProductionSpeed", this.mProductionSpeed);		
+		return aGenes;
+	}
+}
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java b/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java
new file mode 100644
index 0000000000..6bddc9d085
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java
@@ -0,0 +1,5 @@
+package gtPlusPlus.plugin.agrichem.logic;
+
+public class AlgaeGrowthRequirement {
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fishing/Core_Fishing.java b/src/main/java/gtPlusPlus/plugin/fishing/Core_Fishing.java
new file mode 100644
index 0000000000..48706bc986
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fishing/Core_Fishing.java
@@ -0,0 +1,54 @@
+package gtPlusPlus.plugin.fishing;
+
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.plugin.manager.Core_Manager;
+
+public class Core_Fishing implements IPlugin {
+
+	final static Core_Fishing mInstance;
+
+	static {
+		mInstance = new Core_Fishing();
+		mInstance.log("Preparing "+mInstance.getPluginName()+" for use.");
+	}
+	
+	Core_Fishing() {
+		Core_Manager.registerPlugin(this);
+	}
+	
+	@Override
+	public boolean preInit() {
+		return false;
+	}
+
+	@Override
+	public boolean init() {
+		return false;
+	}
+
+	@Override
+	public boolean postInit() {
+		return false;
+	}
+
+	@Override
+	public boolean serverStart() {
+		return false;
+	}
+
+	@Override
+	public boolean serverStop() {
+		return false;
+	}
+
+	@Override
+	public String getPluginName() {
+		return "GT++ Fishing Module";
+	}
+
+	@Override
+	public String getPluginAbbreviation() {
+		return "Fish";
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fishing/block/BlockFishEggs.java b/src/main/java/gtPlusPlus/plugin/fishing/block/BlockFishEggs.java
new file mode 100644
index 0000000000..c11d4fa333
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fishing/block/BlockFishEggs.java
@@ -0,0 +1,12 @@
+package gtPlusPlus.plugin.fishing.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+
+public class BlockFishEggs extends Block{
+
+	protected BlockFishEggs() {
+		super(Material.water);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fishing/item/BaseFish.java b/src/main/java/gtPlusPlus/plugin/fishing/item/BaseFish.java
new file mode 100644
index 0000000000..d96d8d8cfd
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fishing/item/BaseFish.java
@@ -0,0 +1,119 @@
+package gtPlusPlus.plugin.fishing.item;
+
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.potion.PotionHelper;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+import gtPlusPlus.plugin.fishing.misc.BaseFishTypes;
+
+public class BaseFish extends ItemFood
+{
+    private final boolean isCooked;
+
+    public BaseFish(boolean cooked)
+    {
+        super(0, 0.0F, false);
+        this.isCooked = cooked;
+    }
+
+    public int func_150905_g(ItemStack p_150905_1_)
+    {
+        BaseFishTypes fishtype = BaseFishTypes.getFishTypeFromStackDamage(p_150905_1_);
+        return this.isCooked && fishtype.isCooked() ? fishtype.func_150970_e() : fishtype.func_150975_c();
+    }
+
+    public float func_150906_h(ItemStack p_150906_1_)
+    {
+        BaseFishTypes fishtype = BaseFishTypes.getFishTypeFromStackDamage(p_150906_1_);
+        return this.isCooked && fishtype.isCooked() ? fishtype.func_150977_f() : fishtype.func_150967_d();
+    }
+
+    /**
+     * Returns a string representing what this item does to a potion.
+     */
+    public String getPotionEffect(ItemStack p_150896_1_)
+    {
+        return BaseFishTypes.getFishTypeFromStackDamage(p_150896_1_) == BaseFishTypes.PUFFERFISH ? PotionHelper.field_151423_m : null;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister p_94581_1_)
+    {
+        BaseFishTypes[] afishtype = BaseFishTypes.values();
+        int i = afishtype.length;
+
+        for (int j = 0; j < i; ++j)
+        {
+            BaseFishTypes fishtype = afishtype[j];
+            fishtype.func_150968_a(p_94581_1_);
+        }
+    }
+
+    protected void onFoodEaten(ItemStack fish, World world, EntityPlayer player)
+    {
+        BaseFishTypes fishtype = BaseFishTypes.getFishTypeFromStackDamage(fish);
+
+        if (fishtype == BaseFishTypes.PUFFERFISH)
+        {
+            player.addPotionEffect(new PotionEffect(Potion.poison.id, 1200, 3));
+            player.addPotionEffect(new PotionEffect(Potion.hunger.id, 300, 2));
+            player.addPotionEffect(new PotionEffect(Potion.confusion.id, 300, 1));
+        }
+
+        super.onFoodEaten(fish, world, player);
+    }
+
+    /**
+     * Gets an icon index based on an item's damage value
+     */
+    @SideOnly(Side.CLIENT)
+    public IIcon getIconFromDamage(int dmg)
+    {
+        BaseFishTypes fishtype = BaseFishTypes.getFishTypeFromDamageValue(dmg);
+        return this.isCooked && fishtype.isCooked() ? fishtype.func_150979_h() : fishtype.func_150971_g();
+    }
+
+    /**
+     * returns a list of items with the same ID, but different meta (eg: dye returns 16 items)
+     */
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item p_150895_1_, CreativeTabs p_150895_2_, List p_150895_3_)
+    {
+        BaseFishTypes[] afishtype = BaseFishTypes.values();
+        int i = afishtype.length;
+
+        for (int j = 0; j < i; ++j)
+        {
+            BaseFishTypes fishtype = afishtype[j];
+
+            if (!this.isCooked || fishtype.isCooked())
+            {
+                p_150895_3_.add(new ItemStack(this, 1, fishtype.getFishID()));
+            }
+        }
+    }
+
+    /**
+     * Returns the unlocalized name of this item. This version accepts an ItemStack so different stacks can have
+     * different names based on their damage or NBT.
+     */
+    public String getUnlocalizedName(ItemStack p_77667_1_)
+    {
+        BaseFishTypes fishtype = BaseFishTypes.getFishTypeFromStackDamage(p_77667_1_);
+        return this.getUnlocalizedName() + "." + fishtype.getFishName() + "." + (this.isCooked && fishtype.isCooked() ? "cooked" : "raw");
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/plugin/fishing/misc/BaseFishTypes.java b/src/main/java/gtPlusPlus/plugin/fishing/misc/BaseFishTypes.java
new file mode 100644
index 0000000000..ea8d04b5d3
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fishing/misc/BaseFishTypes.java
@@ -0,0 +1,140 @@
+package gtPlusPlus.plugin.fishing.misc;
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import gtPlusPlus.plugin.fishing.item.BaseFish;
+
+public enum BaseFishTypes{
+	
+        COD(0, "cod", 2, 0.1F, 5, 0.6F),
+        SALMON(1, "salmon", 2, 0.1F, 6, 0.8F),
+        CLOWNFISH(2, "clownfish", 1, 0.1F),
+        PUFFERFISH(3, "pufferfish", 1, 0.1F);
+	
+	
+	
+	
+        private static final Map<Integer, BaseFishTypes> mFishMap = Maps.newHashMap();
+        private final int mID;
+        private final String mFishName;
+        @SideOnly(Side.CLIENT)
+        private IIcon iicon;
+        @SideOnly(Side.CLIENT)
+        private IIcon iicon2;
+        private final int field_150991_j;
+        private final float field_150992_k;
+        private final int field_150989_l;
+        private final float field_150990_m;
+        private boolean isCooked = false;
+
+        private BaseFishTypes(int p_i45336_3_, String p_i45336_4_, int p_i45336_5_, float p_i45336_6_, int p_i45336_7_, float p_i45336_8_)
+        {
+            this.mID = p_i45336_3_;
+            this.mFishName = p_i45336_4_;
+            this.field_150991_j = p_i45336_5_;
+            this.field_150992_k = p_i45336_6_;
+            this.field_150989_l = p_i45336_7_;
+            this.field_150990_m = p_i45336_8_;
+            this.isCooked = true;
+        }
+
+        private BaseFishTypes(int p_i45337_3_, String p_i45337_4_, int p_i45337_5_, float p_i45337_6_)
+        {
+            this.mID = p_i45337_3_;
+            this.mFishName = p_i45337_4_;
+            this.field_150991_j = p_i45337_5_;
+            this.field_150992_k = p_i45337_6_;
+            this.field_150989_l = 0;
+            this.field_150990_m = 0.0F;
+            this.isCooked = false;
+        }
+
+        public int getFishID()
+        {
+            return this.mID;
+        }
+
+        public String getFishName()
+        {
+            return this.mFishName;
+        }
+
+        public int func_150975_c()
+        {
+            return this.field_150991_j;
+        }
+
+        public float func_150967_d()
+        {
+            return this.field_150992_k;
+        }
+
+        public int func_150970_e()
+        {
+            return this.field_150989_l;
+        }
+
+        public float func_150977_f()
+        {
+            return this.field_150990_m;
+        }
+
+        @SideOnly(Side.CLIENT)
+        public void func_150968_a(IIconRegister p_150968_1_)
+        {
+            this.iicon = p_150968_1_.registerIcon("fish_" + this.mFishName + "_raw");
+
+            if (this.isCooked)
+            {
+                this.iicon2 = p_150968_1_.registerIcon("fish_" + this.mFishName + "_cooked");
+            }
+        }
+
+        @SideOnly(Side.CLIENT)
+        public IIcon func_150971_g()
+        {
+            return this.iicon;
+        }
+
+        @SideOnly(Side.CLIENT)
+        public IIcon func_150979_h()
+        {
+            return this.iicon2;
+        }
+
+        public boolean isCooked()
+        {
+            return this.isCooked;
+        }
+
+        public static BaseFishTypes getFishTypeFromDamageValue(int dmg)
+        {
+            BaseFishTypes fishtype = (BaseFishTypes)mFishMap.get(Integer.valueOf(dmg));
+            return fishtype == null ? COD : fishtype;
+        }
+
+        public static BaseFishTypes getFishTypeFromStackDamage(ItemStack fish)
+        {
+            return fish.getItem() instanceof BaseFish ? getFishTypeFromDamageValue(fish.getItemDamage()) : COD;
+        }
+
+        static
+        {
+            BaseFishTypes[] var0 = values();
+            int var1 = var0.length;
+
+            for (int var2 = 0; var2 < var1; ++var2)
+            {
+                BaseFishTypes var3 = var0[var2];
+                mFishMap.put(Integer.valueOf(var3.getFishID()), var3);
+            }
+        }
+    }
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/plugin/fixes/interfaces/IBugFix.java b/src/main/java/gtPlusPlus/plugin/fixes/interfaces/IBugFix.java
new file mode 100644
index 0000000000..d67ff24d7b
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fixes/interfaces/IBugFix.java
@@ -0,0 +1,7 @@
+package gtPlusPlus.plugin.fixes.interfaces;
+
+public interface IBugFix {
+
+	public boolean isFixValid();
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fixes/vanilla/Core_VanillaFixes.java b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/Core_VanillaFixes.java
new file mode 100644
index 0000000000..2bfd05e5be
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/Core_VanillaFixes.java
@@ -0,0 +1,95 @@
+package gtPlusPlus.plugin.fixes.vanilla;
+
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.plugin.manager.Core_Manager;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+
+public class Core_VanillaFixes implements IPlugin {
+
+	final static Core_VanillaFixes mInstance;
+	final static VanillaBedHeightFix mBedFixInstance;
+	final static VanillaBackgroundMusicFix mMusicFixInstance;
+
+	static {
+		mInstance = new Core_VanillaFixes();
+		mBedFixInstance = new VanillaBedHeightFix(mInstance);
+		mMusicFixInstance = new VanillaBackgroundMusicFix(mInstance);
+		mInstance.log("Preparing "+mInstance.getPluginName()+" for use.");
+	}
+	
+	Core_VanillaFixes() {
+		Core_Manager.registerPlugin(this);
+	}
+	
+	@Override
+	public boolean preInit() {		
+		return fixVanillaOD();
+	}
+
+	@Override
+	public boolean init() {
+		return true;
+	}
+
+	@Override
+	public boolean postInit() {
+		return true;
+	}
+
+	@Override
+	public boolean serverStart() {
+		mMusicFixInstance.manage();
+		return true;
+	}
+
+	@Override
+	public boolean serverStop() {
+		return true;
+	}
+
+	@Override
+	public String getPluginName() {
+		return "GT++ Vanilla Fixes Module";
+	}
+
+	@Override
+	public String getPluginAbbreviation() {
+		return "VFIX";
+	}
+	
+	private boolean fixVanillaOD() {		
+		registerToOreDict(ItemUtils.getSimpleStack(Items.blaze_rod), "rodBlaze");
+		registerToOreDict(ItemUtils.getSimpleStack(Items.nether_wart), "cropNetherWart");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.reeds), "sugarcane");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.paper), "paper");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.ender_pearl), "enderpearl");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.bone), "bone");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.gunpowder), "gunpowder");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.string), "string");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.nether_star), "netherStar");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.leather), "leather");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.feather), "feather");	
+		registerToOreDict(ItemUtils.getSimpleStack(Items.egg), "egg");	
+		registerToOreDict(ItemUtils.getSimpleStack(Blocks.end_stone), "endstone");	
+		registerToOreDict(ItemUtils.getSimpleStack(Blocks.vine), "vine");	
+		registerToOreDict(ItemUtils.getSimpleStack(Blocks.cactus), "blockCactus");	
+		registerToOreDict(ItemUtils.getSimpleStack(Blocks.grass), "grass");	
+		registerToOreDict(ItemUtils.getSimpleStack(Blocks.obsidian), "obsidian");	
+		registerToOreDict(ItemUtils.getSimpleStack(Blocks.crafting_table), "workbench");		
+		return true;
+	}
+	
+	private void registerToOreDict(ItemStack aStack, String aString) {
+		if (aStack.getItem() == Items.blaze_rod) {
+			mInstance.log("Registering "+aStack.getDisplayName()+" to OreDictionary under the tag '"+aString+"'.");			
+		}
+		else {
+			mInstance.log("Registering "+aStack.getDisplayName()+" to OreDictionary under the tag '"+aString+"'. (Added to Forge in 1.8.9)");			
+		}		
+		ItemUtils.addItemToOreDictionary(aStack, aString);		
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBackgroundMusicFix.java b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBackgroundMusicFix.java
new file mode 100644
index 0000000000..bfd73407f7
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBackgroundMusicFix.java
@@ -0,0 +1,63 @@
+package gtPlusPlus.plugin.fixes.vanilla;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.plugin.fixes.interfaces.IBugFix;
+import gtPlusPlus.plugin.fixes.vanilla.music.MusicTocker;
+import gtPlusPlus.preloader.CORE_Preloader;
+
+public class VanillaBackgroundMusicFix implements IBugFix {
+
+	private final IPlugin mParent;
+	private final boolean enabled;
+	private MusicTocker mFixInstance;
+
+	public VanillaBackgroundMusicFix(IPlugin minstance) {
+		mParent = minstance;
+		if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isClient()) {
+			mParent.log("[BGM] Registering BGM delay Fix.");
+			enabled = true;
+			mFixInstance = new MusicTocker(mParent);
+		} else if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isServer()) {
+			mParent.log("[BGM] Tried registering BGM delay Fix on Server, disabling.");
+			enabled = false;
+		} else {
+			mParent.log("[BGM] Not registering BGM delay Fix.");
+			enabled = false;
+		}
+	}
+
+	public boolean isFixValid() {
+		return enabled;
+	}
+
+	public void manage() {
+		if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isClient()) {
+			TimerTask task = new ManageTask(this.mFixInstance);
+			Timer timer = new Timer("BGM-WatchDog");
+			long delay = 1000 * 60;
+			timer.scheduleAtFixedRate(task, delay, 5000);
+		}
+	}
+
+	private static class ManageTask extends TimerTask {
+		private final MusicTocker A;
+
+		public ManageTask(MusicTocker a) {
+			A = a;
+		}
+
+		@Override
+		public void run() {
+			if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isClient()) {
+				if (!A.mVanillaManager) {
+					A.run();
+				}
+			}
+		}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBedHeightFix.java b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBedHeightFix.java
new file mode 100644
index 0000000000..f33cc71fc6
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBedHeightFix.java
@@ -0,0 +1,82 @@
+package gtPlusPlus.plugin.fixes.vanilla;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.plugin.fixes.interfaces.IBugFix;
+import gtPlusPlus.preloader.DevHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
+
+public class VanillaBedHeightFix implements IBugFix {
+
+	private final Method mSleepInBedAt;
+	private final IPlugin mParent;
+
+	public VanillaBedHeightFix(IPlugin minstance) {
+		mParent = minstance;
+		if (DevHelper.isValidHelperObject()) {	
+			Method m;
+			if (DevHelper.isObfuscatedEnvironment()) {
+				m = ReflectionUtils.getMethod(EntityPlayer.class, "func_71018_a", int.class, int.class,	int.class);
+			}
+			else {
+				m = ReflectionUtils.getMethod(net.minecraft.entity.player.EntityPlayer.class, "sleepInBedAt", int.class, int.class,	int.class);
+			}			
+			if (m != null) {
+				mSleepInBedAt = m;
+				mParent.log("Registering Bed Height Fix.");
+				Utils.registerEvent(this);
+			} else {
+				mSleepInBedAt = null;
+			}
+		} else {
+			mSleepInBedAt = null;
+		}
+	}
+
+	public boolean isFixValid() {
+		return mSleepInBedAt != null;
+	}
+
+	/**
+	 * Fix created by deNULL -
+	 * https://github.com/deNULL/BugPatch/blob/master/src/main/java/ru/denull/BugPatch/mod/ClientEvents.java#L45
+	 * 
+	 * @param evt
+	 *            - The event where a player sleeps
+	 */
+
+	@SubscribeEvent(priority = EventPriority.HIGHEST)
+	public void playerSleepInBed(PlayerSleepInBedEvent evt) {
+		Logger.WARNING("Sleep Event Detected. Player is sleeping at Y: " + evt.y);
+		if (evt.y <= 0 && isFixValid()) {
+			int correctY = 256 + evt.y;
+			if (correctY <= 0) {
+				Logger.WARNING(
+						"You're trying to sleep at y=" + evt.y + ", which is impossibly low. However, fixed y value is "
+								+ correctY + ", which is still below 0. Falling back to default behavior.");
+			} else {
+				Logger.WARNING("You're trying to sleep at y=" + evt.y
+						+ ". This is probably caused by overflow, stopping original event; retrying with y=" + correctY
+						+ ".");
+				evt.result = EntityPlayer.EnumStatus.OTHER_PROBLEM;
+				try {
+					mSleepInBedAt.invoke(evt.entityPlayer, evt.x, correctY, evt.z);
+				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+					Logger.WARNING("Encountered an error trying to sleep.");
+				}
+			}
+		} else if (!isFixValid()) {
+			Logger.WARNING(
+					"Method sleepInBedAt was not found in EntityPlayer (wrong MC and/or Forge version?), unable to fix");
+		}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/fixes/vanilla/music/MusicTocker.java b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/music/MusicTocker.java
new file mode 100644
index 0000000000..452c902e05
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/fixes/vanilla/music/MusicTocker.java
@@ -0,0 +1,130 @@
+package gtPlusPlus.plugin.fixes.vanilla.music;
+
+import java.lang.reflect.Field;
+import java.util.Random;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.random.XSTR;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.preloader.CORE_Preloader;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.ISound;
+import net.minecraft.client.audio.MusicTicker;
+import net.minecraft.client.audio.PositionedSoundRecord;
+import net.minecraft.util.MathHelper;
+
+@SideOnly(Side.CLIENT)
+public class MusicTocker extends MusicTicker implements Runnable {
+
+	private final Random mRandom = new XSTR();
+	private final Minecraft mMinecraft;
+	private final IPlugin mPlugin;
+	private ISound mSound;
+	private int mTimeUntilNextTrack = 100;
+	
+	public boolean mVanillaManager = false;
+
+	public MusicTocker(IPlugin aPlugin) {
+		super(Minecraft.getMinecraft());
+		mPlugin = aPlugin;
+		mMinecraft = Minecraft.getMinecraft();	
+		mPlugin.log("[BGM] Created BGM Watchdog with a delay of "+getDelay()+" ticks.");	
+		inject();
+	}
+
+	private static int getDelay() {
+		return CORE_Preloader.enableWatchdogBGM;
+	}	
+
+	private boolean inject() {
+		mPlugin.log("[BGM] Inject new Watchdog into Minecraft instance.");	
+		ReflectionUtils.setField(Minecraft.getMinecraft(), "mcMusicTicker", this);
+		mPlugin.log("[BGM] Verifying...");
+		Field f = ReflectionUtils.getField(Minecraft.class, "mcMusicTicker");
+		try {
+			Object m = f.get(mMinecraft);
+			if (m != null) {
+				if (m instanceof MusicTocker || m.getClass().isAssignableFrom(getClass())) {
+					mPlugin.log("[BGM] Success.");	
+					return true;
+				}
+				else if (m instanceof MusicTicker || m.getClass().isAssignableFrom(MusicTicker.class)) {
+					mPlugin.log("[BGM] Found Vanilla MusicTicker, but may be instance of MusicTocker.");		
+					return true;
+				}			
+			}
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+		}
+		
+		mPlugin.log("[BGM] Failed.");	
+		return false;
+	}
+	
+	private final void updateInternalNumber() {
+		if (ReflectionUtils.doesFieldExist(getClass(), "field_147676_d")) {
+			ReflectionUtils.setField(this, "field_147676_d", mTimeUntilNextTrack);
+		}
+	}
+	
+	private final void updateInternalSound(ISound aSound) {
+		if (ReflectionUtils.doesFieldExist(getClass(), "field_147678_c")) {
+			ReflectionUtils.setField(this, "field_147678_c", aSound);
+		}		
+	}
+
+	/**
+	 * Updates the JList with a new model.
+	 */
+	@Override
+	public void update() {	
+		run();
+		mVanillaManager = true;
+	}
+
+	@Override
+	public void run() {
+		MusicType musictype = this.mMinecraft.func_147109_W();
+		
+			if (this.mSound != null) {
+				if (!musictype.getMusicTickerLocation().equals(this.mSound.getPositionedSoundLocation())) {
+					this.mMinecraft.getSoundHandler().stopSound(this.mSound);
+					this.mTimeUntilNextTrack = MathHelper.getRandomIntegerInRange(this.mRandom, 0, getDelay() / 2);
+					updateInternalNumber();
+					Logger.INFO("[BGM] Adjusted BGM delay 1");
+				}
+				if (!this.mMinecraft.getSoundHandler().isSoundPlaying(this.mSound)) {
+					this.mSound = null;
+					updateInternalSound(null);
+					this.mTimeUntilNextTrack = Math.min(MathHelper.getRandomIntegerInRange(this.mRandom, getDelay(), getDelay() * 2), this.mTimeUntilNextTrack);
+					updateInternalNumber();
+					Logger.INFO("[BGM] Adjusted BGM delay 2");
+				}
+			}
+			else if (this.mSound == null && this.mTimeUntilNextTrack-- <= 0) {			
+				this.mSound = PositionedSoundRecord.func_147673_a(musictype.getMusicTickerLocation());
+				updateInternalSound(mSound);
+				this.mMinecraft.getSoundHandler().playSound(this.mSound);
+				this.mTimeUntilNextTrack = getDelay();
+				updateInternalNumber();
+				Logger.INFO("[BGM] Adjusted BGM 3");
+			}
+				
+		/*
+		 * try { // Get Value stored in underlying object. Integer aRealDelay =
+		 * (Integer) ReflectionUtils.getField(getClass(), "field_147676_d").get(this);
+		 * 
+		 * if (aRealDelay == null) { return; } else { if (aRealDelay > getDelay() ||
+		 * aRealDelay <= 0) { this.mTimeUntilNextTrack = getDelay();
+		 * updateInternalNumber(); } else { this.mTimeUntilNextTrack -= 5 * 20;
+		 * updateInternalNumber(); } aRealDelay = (Integer)
+		 * ReflectionUtils.getField(getClass(), "field_147676_d").get(this);
+		 * Logger.INFO("[BGM] Adjusted BGM - "+aRealDelay); }
+		 * 
+		 * } catch (IllegalArgumentException | IllegalAccessException e) { }
+		 */					
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/plugin/manager/Core_Manager.java b/src/main/java/gtPlusPlus/plugin/manager/Core_Manager.java
new file mode 100644
index 0000000000..45e85d68ac
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/manager/Core_Manager.java
@@ -0,0 +1,110 @@
+package gtPlusPlus.plugin.manager;
+
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+
+public class Core_Manager {
+
+	public static AutoMap<IPlugin> mPlugins = new AutoMap<IPlugin>();
+	
+	/**
+	 * @param plugin - Dynamically registers the plugin for loading.
+	 */
+	public static void registerPlugin(IPlugin plugin) {
+		Logger.INFO("[Plugin] " + "Registered "+plugin.getPluginName()+".");
+		mPlugins.put(plugin);
+	}	
+	
+	/**
+	 * Dynamically loads all class objects within the "gtPlusPlus.plugin" package.
+	 */
+	public static void veryEarlyInit() {
+		if (ReflectionUtils.dynamicallyLoadClassesInPackage("gtPlusPlus.plugin")) {
+			Logger.INFO("[Plugin] Plugin System loaded.");
+		}
+	}
+	
+	public static boolean preInit() {
+		try {			
+			for (IPlugin h : mPlugins) {
+				if (h.preInit()) {
+					Logger.INFO("[Plugin] Completed Pre-Init Phase for "+h.getPluginName()+".");
+				}
+				else {
+					Logger.INFO("[Plugin] Failed during Pre-Init Phase for "+h.getPluginName()+".");					
+				}
+			}			
+			return true;
+		}
+		catch (Throwable t) {}
+		return false;		
+	}
+	
+	public static boolean init() {
+		try {			
+			for (IPlugin h : mPlugins) {
+				if (h.init()) {
+					Logger.INFO("[Plugin] Completed Init Phase for "+h.getPluginName()+".");
+				}
+				else {
+					Logger.INFO("[Plugin] Failed during Init Phase for "+h.getPluginName()+".");					
+				}
+			}			
+			return true;
+		}
+		catch (Throwable t) {}
+		return false;		
+	}
+	
+	public static boolean postInit() {
+		try {			
+			for (IPlugin h : mPlugins) {
+				if (h.postInit()) {
+					Logger.INFO("[Plugin] Completed Post-Init Phase for "+h.getPluginName()+".");
+				}
+				else {
+					Logger.INFO("[Plugin] Failed during Post-Init Phase for "+h.getPluginName()+".");					
+				}
+			}			
+			return true;
+		}
+		catch (Throwable t) {}
+		return false;		
+	}
+	
+	public static boolean serverStart() {
+		try {			
+			for (IPlugin h : mPlugins) {
+				if (h.serverStart()) {
+					Logger.INFO("[Plugin] Completed Server Start Phase for "+h.getPluginName()+".");
+				}
+				else {
+					Logger.INFO("[Plugin] Failed during Server Start Phase for "+h.getPluginName()+".");					
+				}
+			}			
+			return true;
+		}
+		catch (Throwable t) {}
+		return false;		
+	}
+	
+	public static boolean serverStop() {
+		try {			
+			for (IPlugin h : mPlugins) {
+				if (h.serverStop()) {
+					Logger.INFO("[Plugin] Completed Server Stop Phase for "+h.getPluginName()+".");
+				}
+				else {
+					Logger.INFO("[Plugin] Failed during Server Stop Phase for "+h.getPluginName()+".");					
+				}
+			}			
+			return true;
+		}
+		catch (Throwable t) {}
+		return false;		
+	}
+	
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/sulfurchem/Core_SulfuricChemistry.java b/src/main/java/gtPlusPlus/plugin/sulfurchem/Core_SulfuricChemistry.java
new file mode 100644
index 0000000000..ed6762c69d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/sulfurchem/Core_SulfuricChemistry.java
@@ -0,0 +1,314 @@
+package gtPlusPlus.plugin.sulfurchem;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.util.GT_Recipe;
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.plugin.manager.Core_Manager;
+import gtPlusPlus.preloader.CORE_Preloader;
+import gtPlusPlus.xmod.gregtech.common.StaticFields59;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class Core_SulfuricChemistry implements IPlugin {
+
+	final static Core_SulfuricChemistry mInstance;
+	private static boolean shouldLoad = false;
+
+	private static AutoMap<GT_Recipe> mRemovedRecipes1 = new AutoMap<GT_Recipe>();
+	private static AutoMap<GT_Recipe> mRemovedRecipes2 = new AutoMap<GT_Recipe>();
+
+	static {
+		mInstance = new Core_SulfuricChemistry();
+		Core_Manager.registerPlugin(mInstance);
+		mInstance.log("Preparing "+mInstance.getPluginName()+" for use.");
+	}
+
+	@Override
+	public boolean preInit() {
+		if (/*CORE.ConfigSwitches.enableSulfuricAcidFix || *//*CORE.DEVENV*/false) {
+			shouldLoad = true;
+		}
+		if (shouldLoad)
+			return true;
+		return false;
+	}
+
+	@Override
+	public boolean init() {
+		if (shouldLoad)
+			return true;
+		return false;
+	}
+
+	@Override
+	public boolean postInit() {		
+		if (shouldLoad) {
+			try {
+			int disabled = disableSulfurTrioxide();
+			log("Disabled "+disabled+" Sulfur Trioxide Chemistry recipes.");
+			int disabled2 = disableSulfuricAcid();
+			log("Disabled "+disabled2+" Sulfuric Acid Chemistry recipes.");
+			int addedNew = addRevisedGT6Recipes();
+			log("Added "+addedNew+" new Sulfuric Chemistry recipes.");
+			
+			if (CORE.DEVENV || CORE_Preloader.DEBUG_MODE) {
+				for (int i=0;i<2;i++) {
+					for (GT_Recipe m : mRemovedRecipes1) {
+						String[] mInfo = RecipeUtils.getRecipeInfo(m);
+						log("Removed Recipe");
+						for (int r=0;r<mInfo.length;r++) {
+							log(mInfo[r]);
+						}
+					}	
+					for (GT_Recipe m : mRemovedRecipes2) {
+						String[] mInfo = RecipeUtils.getRecipeInfo(m);
+						log("Removed Recipe");
+						for (int r=0;r<mInfo.length;r++) {
+							log(mInfo[r]);
+						}
+					}
+				}
+			}			
+			return disabled > 0 && addedNew > 0;
+			}
+			catch (Throwable t) {
+				t.printStackTrace();
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean serverStart() {
+		return false;
+	}
+
+	@Override
+	public boolean serverStop() {
+		return false;
+	}
+
+	@Override
+	public String getPluginName() {
+		return "GT++ Revised Sulfuric Chemistry Module";
+	}
+
+	public int addRevisedGT6Recipes() {
+
+		String catalyst = "dustPlatinum";
+		int mCountAdded = 0;
+
+		/**
+		 * Sulfur Trioxide Recipes
+		 */		
+		//Air
+		if (CORE.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict(catalyst, 0),
+				ItemUtils.getItemStackOfAmountFromOreDict("cellAir", 1),
+				FluidUtils.getFluidStack("sulfurdioxide", 3000),
+				FluidUtils.getFluidStack("sulfurtrioxide", 4000),
+				CI.emptyCells(1),
+				null,
+				16, 
+				16)) {
+			mCountAdded++;
+		}
+		if (CORE.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict(catalyst, 0),
+				ItemUtils.getItemStackOfAmountFromOreDict("cellSulfurDioxide", 3),
+				FluidUtils.getFluidStack("air", 1000),
+				FluidUtils.getFluidStack("sulfurtrioxide", 4000),
+				CI.emptyCells(3),
+				null,
+				16, 
+				16)) {
+			mCountAdded++;
+		}		
+		//Oxygen
+		if (CORE.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict(catalyst, 0),
+				ItemUtils.getItemStackOfAmountFromOreDict("cellOxygen", 1),
+				FluidUtils.getFluidStack("sulfurdioxide", 3000),
+				FluidUtils.getFluidStack("sulfurtrioxide", 4000),
+				CI.emptyCells(1),
+				null,
+				16, 
+				16)) {
+			mCountAdded++;
+		}
+		if (CORE.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict(catalyst, 0),
+				ItemUtils.getItemStackOfAmountFromOreDict("cellSulfurDioxide", 3),
+				FluidUtils.getFluidStack("oxygen", 1000),
+				FluidUtils.getFluidStack("sulfurtrioxide", 4000),
+				CI.emptyCells(3),
+				null,
+				16, 
+				16)) {
+			mCountAdded++;
+		}
+
+		/**
+		 * Sulfuric Acid Recipes
+		 */
+
+		if (CORE.RA.addChemicalRecipe(
+				CI.getNumberedCircuit(22),
+				ItemUtils.getItemStackOfAmountFromOreDict("cellSulfurTrioxide", 1),
+				FluidUtils.getFluidStack("water", 750),
+				Materials.SulfuricAcid.getFluid(1750),
+				CI.emptyCells(1),
+				null,
+				20, 
+				20)) {
+			mCountAdded++;
+		}		
+		if (CORE.RA.addChemicalRecipe(
+				CI.getNumberedCircuit(22),
+				ItemUtils.getItemStackOfAmountFromOreDict("cellWater", 3),
+				FluidUtils.getFluidStack("sulfurtrioxide", 4000),
+				Materials.SulfuricAcid.getFluid(7000),
+				CI.emptyCells(3),
+				null,
+				20, 
+				20)) {
+			mCountAdded++;
+		}
+
+		return mCountAdded;
+	}
+
+
+	public int disableSulfurTrioxide() {
+		int mDisabled = 0;		
+		FluidStack mStack = FluidUtils.getFluidStack("sulfurtrioxide", 1);
+		//Single Block Recipes
+		recipe : for (GT_Recipe r : GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList) {
+			for (ItemStack i : r.mOutputs) {
+				i.stackSize = 1;
+				if (ItemStack.areItemStacksEqual(i, ItemUtils.getItemStackOfAmountFromOreDict("cellSulfurTrioxide", 1))) {
+					mRemovedRecipes1.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+			for (FluidStack f : r.mFluidOutputs) {
+				f.amount = 1;
+				if (FluidStack.areFluidStackTagsEqual(f, mStack)) {
+					mRemovedRecipes1.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+		}
+
+		//Multi Block Recipes
+		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+		recipe : for (GT_Recipe r : StaticFields59.getLargeChemicalReactorRecipeMap().mRecipeList) {
+			for (ItemStack i : r.mOutputs) {
+				i.stackSize = 1;
+				if (ItemStack.areItemStacksEqual(i, ItemUtils.getItemStackOfAmountFromOreDict("cellSulfurTrioxide", 1))) {
+					mRemovedRecipes1.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+			for (FluidStack f : r.mFluidOutputs) {
+				f.amount = 1;
+				if (FluidStack.areFluidStackTagsEqual(f, mStack)) {
+					mRemovedRecipes1.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+		}
+		}
+
+		return mDisabled;
+	}
+
+	public int disableSulfuricAcid() {
+		int mDisabled = 0;	
+		FluidStack mStack = FluidUtils.getFluidStack("sulfuricacid", 1);	
+		//Single Block Recipes
+		
+		recipe : for (GT_Recipe r : GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList) {
+			for (ItemStack i : r.mOutputs) {
+				i.stackSize = 1;
+				if (ItemStack.areItemStacksEqual(i, ItemUtils.getItemStackOfAmountFromOreDict("cellSulfuricAcid", 1))) {
+					mRemovedRecipes2.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+			for (FluidStack f : r.mFluidOutputs) {
+				f.amount = 1;
+				if (FluidStack.areFluidStackTagsEqual(f, mStack)) {
+					mRemovedRecipes2.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+		}
+
+		//Multi Block Recipes
+		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+		recipe : for (GT_Recipe r : StaticFields59.getLargeChemicalReactorRecipeMap().mRecipeList) {
+			for (ItemStack i : r.mOutputs) {
+				i.stackSize = 1;
+				if (ItemStack.areItemStacksEqual(i, ItemUtils.getItemStackOfAmountFromOreDict("cellSulfuricAcid", 1))) {
+					mRemovedRecipes2.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+			for (FluidStack f : r.mFluidOutputs) {
+				f.amount = 1;
+				if (FluidStack.areFluidStackTagsEqual(f, mStack)) {
+					mRemovedRecipes2.put(r);
+					r.mEnabled = false;
+					r.mHidden = true;
+					mDisabled++;
+					continue recipe;
+				}
+				continue;
+			}
+		}
+		}
+
+		return mDisabled;
+	}
+
+	@Override
+	public String getPluginAbbreviation() {
+		return "RSCM";
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/Core_VillagerAdditions.java b/src/main/java/gtPlusPlus/plugin/villagers/Core_VillagerAdditions.java
new file mode 100644
index 0000000000..09e4c4865f
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/Core_VillagerAdditions.java
@@ -0,0 +1,130 @@
+package gtPlusPlus.plugin.villagers;
+
+import static gtPlusPlus.plugin.villagers.VillagerUtils.mVillagerMap;
+
+import java.util.HashMap;
+
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.VillagerRegistry;
+import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.core.entity.EntityPrimedMiningExplosive;
+import gtPlusPlus.core.entity.monster.EntityGiantChickenBase;
+import gtPlusPlus.core.entity.monster.EntitySickBlaze;
+import gtPlusPlus.core.entity.monster.EntityStaballoyConstruct;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.plugin.manager.Core_Manager;
+import gtPlusPlus.plugin.villagers.block.BlockGenericSpawner;
+import gtPlusPlus.plugin.villagers.entity.EntityBaseVillager;
+import gtPlusPlus.plugin.villagers.entity.EntityNativeAustralian;
+import gtPlusPlus.plugin.villagers.trade.TradeHandlerAboriginal;
+import gtPlusPlus.plugin.villagers.trade.TradeHandlerBanker;
+import gtPlusPlus.plugin.villagers.trade.TradeHandlerTechnician;
+import gtPlusPlus.plugin.villagers.trade.TradeHandlerTrader;
+import net.minecraft.util.ResourceLocation;
+
+public class Core_VillagerAdditions implements IPlugin {
+
+	public final static Core_VillagerAdditions mInstance;
+	private static boolean shouldLoad = false;
+
+	public static final HashMap<Integer, ResourceLocation> mVillagerSkins = new HashMap<Integer, ResourceLocation>();
+	public static final AutoMap<Pair<Integer, IVillageTradeHandler>> mVillagerTrades = new AutoMap<Pair<Integer, IVillageTradeHandler>>();
+
+	static {
+		mInstance = new Core_VillagerAdditions();
+		Core_Manager.registerPlugin(mInstance);
+		mInstance.log("Preparing "+mInstance.getPluginName()+" for use.");
+	}
+
+	@Override
+	public boolean preInit() {
+		if (/*CORE.ConfigSwitches.enableSulfuricAcidFix || */CORE.DEVENV) {
+			shouldLoad = true;
+		}
+		if (shouldLoad) {			
+			//Register Custom Villager Entity
+			EntityRegistry.registerGlobalEntityID(EntityBaseVillager.class, "WiseVillager", EntityRegistry.findGlobalUniqueEntityId(), Utils.rgbtoHexValue(180, 120, 120), Utils.rgbtoHexValue(0, 0, 0));
+			EntityRegistry.registerGlobalEntityID(EntityNativeAustralian.class, "Aboriginal", EntityRegistry.findGlobalUniqueEntityId(), Utils.rgbtoHexValue(50, 50, 50), Utils.rgbtoHexValue(25, 25, 25));
+	        VillagerUtils.registerNewVillager(0, "Banker", "Banker", "Banker", "banker", new TradeHandlerBanker());
+			VillagerUtils.registerNewVillager(1, "Technician", "Technician", "Technician", "technician", new TradeHandlerTechnician());
+			VillagerUtils.registerNewVillager(2, "Trader", "Trader", "Trader", "trader", new TradeHandlerTrader());
+			VillagerUtils.registerNewVillager(3, "Aboriginal", "Aboriginal", "Aboriginal", "aboriginal", new TradeHandlerAboriginal());
+			
+			if (mVillagerMap.size() > 0) {
+				for (VillagerObject g : mVillagerMap.values()) {
+					if (g != null && g.mID >= 0) {
+						VillagerRegistry.instance().registerVillagerId(7735+g.mID);	
+						log("Registered a Custom Villager with ID of "+g.mID+".");
+						//Utils.createNewMobSpawner(10+g.mID, EntityBaseVillager.class);
+						if (mVillagerSkins.get(g.mID) != null) {
+							VillagerRegistry.instance().registerVillagerSkin(7735+g.mID, mVillagerSkins.get(g.mID));
+							log("Registered a Custom Skin for Villager with ID of "+g.mID+".");
+						}
+					}
+				}
+			}			
+			
+			//Register all Villager ID's and their Custom Trades.
+			if (mVillagerTrades.size() > 0) {
+				for (Pair<Integer, IVillageTradeHandler> g : mVillagerTrades) {
+					if (g != null && g.getKey() != null) {
+						if (g.getValue() != null) {
+							VillagerRegistry.instance().registerVillageTradeHandler(g.getKey(), g.getValue());
+							log("Registered a Custom Trade for Villager with ID of "+g.getKey()+".");
+						}
+					}
+				}
+			}	
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public boolean init() {
+		if (shouldLoad) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public boolean postInit() {		
+		if (shouldLoad) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public boolean serverStart() {
+		if (shouldLoad) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public boolean serverStop() {
+		if (shouldLoad) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public String getPluginName() {
+		return "GT++ Enhanced Villagers";
+	}
+
+	@Override
+	public String getPluginAbbreviation() {
+		return "Bank";
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/NameLists.java b/src/main/java/gtPlusPlus/plugin/villagers/NameLists.java
new file mode 100644
index 0000000000..e9cd254503
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/NameLists.java
@@ -0,0 +1,994 @@
+package gtPlusPlus.plugin.villagers;
+
+import org.apache.commons.lang3.StringUtils;
+
+import gtPlusPlus.core.util.math.MathUtils;
+
+public class NameLists {
+
+	public static final String[] mFirstNames;
+	public static final String[] mLastNames;
+	public static final String[] mScottishFirstNames; 
+	
+	static {
+		mFirstNames = generateFirstNames();
+		mLastNames = generateLastNames();
+		mScottishFirstNames = generateScottishFirstNames(); 
+	}
+
+
+	private static final String[] generateScottishFirstNames() {
+		return new String[] { "Aadam", "Aadit", "Aahron", "Aaran", "Aaren",
+				"Aarez", "Aarman", "Aaron", "Aaron-James", "Aarron", "Aaryan", "Aaryn", "Aayan", "Aazaan", "Abaan", "Abbas",
+				"Abdallah", "Abdalroof", "Abdihakim", "Abdirahman", "Abdisalam", "Abdul", "Abdul-Aziz", "Abdulbasir",
+				"Abdulkadir", "Abdulkarem", "Abdulkhader", "Abdullah", "Abdul-Majeed", "Abdulmalik", "Abdul-Rehman",
+				"Abdur", "Abdurraheem", "Abdur-Rahman", "Abdur-Rehmaan", "Abel", "Abhinav", "Abhisumant", "Abid", "Abir",
+				"Abraham", "Abu", "Abubakar", "Ace", "Adain", "Adam", "Adam-James", "Addison", "Addisson", "Adegbola",
+				"Adegbolahan", "Aden", "Adenn", "Adie", "Adil", "Aditya", "Adnan", "Adrian", "Adrien", "Aedan", "Aedin",
+				"Aedyn", "Aeron", "Afonso", "Ahmad", "Ahmed", "Ahmed-Aziz", "Ahoua", "Ahtasham", "Aiadan", "Aidan", "Aiden",
+				"Aiden-Jack", "Aiden-Vee", "Aidian", "Aidy", "Ailin", "Aiman", "Ainsley", "Ainslie", "Airen", "Airidas",
+				"Airlie", "AJ", "Ajay", "A-Jay", "Ajayraj", "Akan", "Akram", "Al", "Ala'", "Alan", "Alanas", "Alasdair",
+				"Alastair", "Alber", "Albert", "Albie", "Aldred", "Alec", "Aled", "Aleem", "Aleksandar", "Aleksander",
+				"Aleksandr", "Aleksandrs", "Alekzander", "Alessandro", "Alessio", "Alex", "Alexander", "Alexei", "Alexx",
+				"Alexzander", "Alf", "Alfee", "Alfie", "Alfred", "Alfy", "Alhaji", "Al-Hassan", "Ali", "Aliekber", "Alieu",
+				"Alihaider", "Alisdair", "Alishan", "Alistair", "Alistar", "Alister", "Aliyaan", "Allan", "Allan-Laiton",
+				"Allen", "Allesandro", "Allister", "Ally", "Alphonse", "Altyiab", "Alum", "Alvern", "Alvin", "Alyas",
+				"Amaan", "Aman", "Amani", "Ambanimoh", "Ameer", "Amgad", "Ami", "Amin", "Amir", "Ammaar", "Ammar", "Ammer",
+				"Amolpreet", "Amos", "Amrinder", "Amrit", "Amro", "Anay", "Andrea", "Andreas", "Andrei", "Andrejs",
+				"Andrew", "Andy", "Anees", "Anesu", "Angel", "Angelo", "Angus", "Anir", "Anis", "Anish", "Anmolpreet",
+				"Annan", "Anndra", "Anselm", "Anthony", "Anthony-John", "Antoine", "Anton", "Antoni", "Antonio", "Antony",
+				"Antonyo", "Anubhav", "Aodhan", "Aon", "Aonghus", "Apisai", "Arafat", "Aran", "Arandeep", "Arann", "Aray",
+				"Arayan", "Archibald", "Archie", "Arda", "Ardal", "Ardeshir", "Areeb", "Areez", "Aref", "Arfin", "Argyle",
+				"Argyll", "Ari", "Aria", "Arian", "Arihant", "Aristomenis", "Aristotelis", "Arjuna", "Arlo", "Armaan",
+				"Arman", "Armen", "Arnab", "Arnav", "Arnold", "Aron", "Aronas", "Arran", "Arrham", "Arron", "Arryn",
+				"Arsalan", "Artem", "Arthur", "Artur", "Arturo", "Arun", "Arunas", "Arved", "Arya", "Aryan", "Aryankhan",
+				"Aryian", "Aryn", "Asa", "Asfhan", "Ash", "Ashlee-jay", "Ashley", "Ashton", "Ashton-Lloyd", "Ashtyn",
+				"Ashwin", "Asif", "Asim", "Aslam", "Asrar", "Ata", "Atal", "Atapattu", "Ateeq", "Athol", "Athon",
+				"Athos-Carlos", "Atli", "Atom", "Attila", "Aulay", "Aun", "Austen", "Austin", "Avani", "Averon", "Avi",
+				"Avinash", "Avraham", "Awais", "Awwal", "Axel", "Ayaan", "Ayan", "Aydan", "Ayden", "Aydin", "Aydon",
+				"Ayman", "Ayomide", "Ayren", "Ayrton", "Aytug", "Ayub", "Ayyub", "Azaan", "Azedine", "Azeem", "Azim",
+				"Aziz", "Azlan", "Azzam", "Azzedine", "Babatunmise", "Babur", "Bader", "Badr", "Badsha", "Bailee", "Bailey",
+				"Bailie", "Bailley", "Baillie", "Baley", "Balian", "Banan", "Barath", "Barkley", "Barney", "Baron",
+				"Barrie", "Barry", "Bartlomiej", "Bartosz", "Basher", "Basile", "Baxter", "Baye", "Bayley", "Beau", "Beinn",
+				"Bekim", "Believe", "Ben", "Bendeguz", "Benedict", "Benjamin", "Benjamyn", "Benji", "Benn", "Bennett",
+				"Benny", "Benoit", "Bentley", "Berkay", "Bernard", "Bertie", "Bevin", "Bezalel", "Bhaaldeen", "Bharath",
+				"Bilal", "Bill", "Billy", "Binod", "Bjorn", "Blaike", "Blaine", "Blair", "Blaire", "Blake", "Blazej",
+				"Blazey", "Blessing", "Blue", "Blyth", "Bo", "Boab", "Bob", "Bobby", "Bobby-Lee", "Bodhan", "Boedyn",
+				"Bogdan", "Bohbi", "Bony", "Bowen", "Bowie", "Boyd", "Bracken", "Brad", "Bradan", "Braden", "Bradley",
+				"Bradlie", "Bradly", "Brady", "Bradyn", "Braeden", "Braiden", "Brajan", "Brandan", "Branden", "Brandon",
+				"Brandonlee", "Brandon-Lee", "Brandyn", "Brannan", "Brayden", "Braydon", "Braydyn", "Breandan", "Brehme",
+				"Brendan", "Brendon", "Brendyn", "Breogan", "Bret", "Brett", "Briaddon", "Brian", "Brodi", "Brodie",
+				"Brody", "Brogan", "Broghan", "Brooke", "Brooklin", "Brooklyn", "Bruce", "Bruin", "Bruno", "Brunon",
+				"Bryan", "Bryce", "Bryden", "Brydon", "Brydon-Craig", "Bryn", "Brynmor", "Bryson", "Buddy", "Bully",
+				"Burak", "Burhan", "Butali", "Butchi", "Byron", "Cabhan", "Cadan", "Cade", "Caden", "Cadon", "Cadyn",
+				"Caedan", "Caedyn", "Cael", "Caelan", "Caelen", "Caethan", "Cahl", "Cahlum", "Cai", "Caidan", "Caiden",
+				"Caiden-Paul", "Caidyn", "Caie", "Cailaen", "Cailean", "Caileb-John", "Cailin", "Cain", "Caine", "Cairn",
+				"Cal", "Calan", "Calder", "Cale", "Calean", "Caleb", "Calen", "Caley", "Calib", "Calin", "Callahan",
+				"Callan", "Callan-Adam", "Calley", "Callie", "Callin", "Callum", "Callun", "Callyn", "Calum", "Calum-James",
+				"Calvin", "Cambell", "Camerin", "Cameron", "Campbel", "Campbell", "Camron", "Caolain", "Caolan", "Carl",
+				"Carlo", "Carlos", "Carrich", "Carrick", "Carson", "Carter", "Carwyn", "Casey", "Casper", "Cassy", "Cathal",
+				"Cator", "Cavan", "Cayden", "Cayden-Robert", "Cayden-Tiamo", "Ceejay", "Ceilan", "Ceiran", "Ceirin",
+				"Ceiron", "Cejay", "Celik", "Cephas", "Cesar", "Cesare", "Chad", "Chaitanya", "Chang-Ha", "Charles",
+				"Charley", "Charlie", "Charly", "Chase", "Che", "Chester", "Chevy", "Chi", "Chibudom", "Chidera", "Chimsom",
+				"Chin", "Chintu", "Chiqal", "Chiron", "Chris", "Chris-Daniel", "Chrismedi", "Christian", "Christie",
+				"Christoph", "Christopher", "Christopher-Lee", "Christy", "Chu", "Chukwuemeka", "Cian", "Ciann", "Ciar",
+				"Ciaran", "Ciarian", "Cieran", "Cillian", "Cillin", "Cinar", "CJ", "C-Jay", "Clark", "Clarke", "Clayton",
+				"Clement", "Clifford", "Clyde", "Cobain", "Coban", "Coben", "Cobi", "Cobie", "Coby", "Codey", "Codi",
+				"Codie", "Cody", "Cody-Lee", "Coel", "Cohan", "Cohen", "Colby", "Cole", "Colin", "Coll", "Colm", "Colt",
+				"Colton", "Colum", "Colvin", "Comghan", "Conal", "Conall", "Conan", "Conar", "Conghaile", "Conlan",
+				"Conley", "Conli", "Conlin", "Conlly", "Conlon", "Conlyn", "Connal", "Connall", "Connan", "Connar",
+				"Connel", "Connell", "Conner", "Connolly", "Connor", "Connor-David", "Conor", "Conrad", "Cooper",
+				"Copeland", "Coray", "Corben", "Corbin", "Corey", "Corey-James", "Corey-Jay", "Cori", "Corie", "Corin",
+				"Cormac", "Cormack", "Cormak", "Corran", "Corrie", "Cory", "Cosmo", "Coupar", "Craig", "Craig-James",
+				"Crawford", "Creag", "Crispin", "Cristian", "Crombie", "Cruiz", "Cruz", "Cuillin", "Cullen", "Cullin",
+				"Curtis", "Cyrus", "Daanyaal", "Daegan", "Daegyu", "Dafydd", "Dagon", "Dailey", "Daimhin", "Daithi",
+				"Dakota", "Daksh", "Dale", "Dalong", "Dalton", "Damian", "Damien", "Damon", "Dan", "Danar", "Dane",
+				"Danial", "Daniel", "Daniele", "Daniel-James", "Daniels", "Daniil", "Danish", "Daniyal", "Danniel", "Danny",
+				"Dante", "Danyal", "Danyil", "Danys", "Daood", "Dara", "Darach", "Daragh", "Darcy", "D'arcy", "Dareh",
+				"Daren", "Darien", "Darius", "Darl", "Darn", "Darrach", "Darragh", "Darrel", "Darrell", "Darren", "Darrie",
+				"Darrius", "Darroch", "Darryl", "Darryn", "Darwyn", "Daryl", "Daryn", "Daud", "Daumantas", "Davi", "David",
+				"David-Jay", "David-Lee", "Davie", "Davis", "Davy", "Dawid", "Dawson", "Dawud", "Dayem", "Daymian",
+				"Deacon", "Deagan", "Dean", "Deano", "Decklan", "Declain", "Declan", "Declyan", "Declyn", "Dedeniseoluwa",
+				"Deecan", "Deegan", "Deelan", "Deklain-Jaimes", "Del", "Demetrius", "Denis", "Deniss", "Dennan", "Dennin",
+				"Dennis", "Denny", "Dennys", "Denon", "Denton", "Denver", "Denzel", "Deon", "Derek", "Derick", "Derin",
+				"Dermot", "Derren", "Derrie", "Derrin", "Derron", "Derry", "Derryn", "Deryn", "Deshawn", "Desmond", "Dev",
+				"Devan", "Devin", "Devlin", "Devlyn", "Devon", "Devrin", "Devyn", "Dex", "Dexter", "Dhani", "Dharam",
+				"Dhavid", "Dhyia", "Diarmaid", "Diarmid", "Diarmuid", "Didier", "Diego", "Diesel", "Diesil", "Digby",
+				"Dilan", "Dilano", "Dillan", "Dillon", "Dilraj", "Dimitri", "Dinaras", "Dion", "Dissanayake", "Dmitri",
+				"Doire", "Dolan", "Domanic", "Domenico", "Domhnall", "Dominic", "Dominick", "Dominik", "Donald", "Donnacha",
+				"Donnie", "Dorian", "Dougal", "Douglas", "Dougray", "Drakeo", "Dre", "Dregan", "Drew", "Dugald", "Duncan",
+				"Duriel", "Dustin", "Dylan", "Dylan-Jack", "Dylan-James", "Dylan-John", "Dylan-Patrick", "Dylin", "Dyllan",
+				"Dyllan-James", "Dyllon", "Eadie", "Eagann", "Eamon", "Eamonn", "Eason", "Eassan", "Easton", "Ebow", "Ed",
+				"Eddie", "Eden", "Ediomi", "Edison", "Eduardo", "Eduards", "Edward", "Edwin", "Edwyn", "Eesa", "Efan",
+				"Efe", "Ege", "Ehsan", "Ehsen", "Eiddon", "Eidhan", "Eihli", "Eimantas", "Eisa", "Eli", "Elias", "Elijah",
+				"Eliot", "Elisau", "Eljay", "Eljon", "Elliot", "Elliott", "Ellis", "Ellisandro", "Elshan", "Elvin", "Elyan",
+				"Emanuel", "Emerson", "Emil", "Emile", "Emir", "Emlyn", "Emmanuel", "Emmet", "Eng", "Eniola", "Enis",
+				"Ennis", "Enrico", "Enrique", "Enzo", "Eoghain", "Eoghan", "Eoin", "Eonan", "Erdehan", "Eren", "Erencem",
+				"Eric", "Ericlee", "Erik", "Eriz", "Ernie-Jacks", "Eroni", "Eryk", "Eshan", "Essa", "Esteban", "Ethan",
+				"Etienne", "Etinosa", "Euan", "Eugene", "Evan", "Evann", "Ewan", "Ewen", "Ewing", "Exodi", "Ezekiel",
+				"Ezra", "Fabian", "Fahad", "Faheem", "Faisal", "Faizaan", "Famara", "Fares", "Farhaan", "Farhan", "Farren",
+				"Farzad", "Fauzaan", "Favour", "Fawaz", "Fawkes", "Faysal", "Fearghus", "Feden", "Felix", "Fergal",
+				"Fergie", "Fergus", "Ferre", "Fezaan", "Fiachra", "Fikret", "Filip", "Filippo", "Finan", "Findlay",
+				"Findlay-James", "Findlie", "Finlay", "Finley", "Finn", "Finnan", "Finnean", "Finnen", "Finnlay", "Finnley",
+				"Fintan", "Fionn", "Firaaz", "Fletcher", "Flint", "Florin", "Flyn", "Flynn", "Fodeba", "Folarinwa",
+				"Forbes", "Forgan", "Forrest", "Fox", "Francesco", "Francis", "Francisco", "Franciszek", "Franco", "Frank",
+				"Frankie", "Franklin", "Franko", "Fraser", "Frazer", "Fred", "Freddie", "Frederick", "Fruin", "Fyfe", "Fyn",
+				"Fynlay", "Fynn", "Gabriel", "Gallagher", "Gareth", "Garren", "Garrett", "Garry", "Gary", "Gavin",
+				"Gavin-Lee", "Gene", "Geoff", "Geoffrey", "Geomer", "Geordan", "Geordie", "George", "Georgia", "Georgy",
+				"Gerard", "Ghyll", "Giacomo", "Gian", "Giancarlo", "Gianluca", "Gianmarco", "Gideon", "Gil", "Gio",
+				"Girijan", "Girius", "Gjan", "Glascott", "Glen", "Glenn", "Gordon", "Grady", "Graeme", "Graham", "Grahame",
+				"Grant", "Grayson", "Greg", "Gregor", "Gregory", "Greig", "Griffin", "Griffyn", "Grzegorz", "Guang",
+				"Guerin", "Guillaume", "Gurardass", "Gurdeep", "Gursees", "Gurthar", "Gurveer", "Gurwinder", "Gus",
+				"Gustav", "Guthrie", "Guy", "Gytis", "Habeeb", "Hadji", "Hadyn", "Hagun", "Haiden", "Haider", "Hamad",
+				"Hamid", "Hamish", "Hamza", "Hamzah", "Han", "Hansen", "Hao", "Hareem", "Hari", "Harikrishna", "Haris",
+				"Harish", "Harjeevan", "Harjyot", "Harlee", "Harleigh", "Harley", "Harman", "Harnek", "Harold", "Haroon",
+				"Harper", "Harri", "Harrington", "Harris", "Harrison", "Harry", "Harvey", "Harvie", "Harvinder", "Hasan",
+				"Haseeb", "Hashem", "Hashim", "Hassan", "Hassanali", "Hately", "Havila", "Hayden", "Haydn", "Haydon",
+				"Haydyn", "Hcen", "Hector", "Heddle", "Heidar", "Heini", "Hendri", "Henri", "Henry", "Herbert", "Heyden",
+				"Hiro", "Hirvaansh", "Hishaam", "Hogan", "Honey", "Hong", "Hope", "Hopkin", "Hosea", "Howard", "Howie",
+				"Hristomir", "Hubert", "Hugh", "Hugo", "Humza", "Hunter", "Husnain", "Hussain", "Hussan", "Hussnain",
+				"Hussnan", "Hyden", "I", "Iagan", "Iain", "Ian", "Ibraheem", "Ibrahim", "Idahosa", "Idrees", "Idris",
+				"Iestyn", "Ieuan", "Igor", "Ihtisham", "Ijay", "Ikechukwu", "Ikemsinachukwu", "Ilyaas", "Ilyas", "Iman",
+				"Immanuel", "Inan", "Indy", "Ines", "Innes", "Ioannis", "Ireayomide", "Ireoluwa", "Irvin", "Irvine", "Isa",
+				"Isaa", "Isaac", "Isaiah", "Isak", "Isher", "Ishwar", "Isimeli", "Isira", "Ismaeel", "Ismail", "Israel",
+				"Issiaka", "Ivan", "Ivar", "Izaak", "J", "Jaay", "Jac", "Jace", "Jack", "Jacki", "Jackie", "Jack-James",
+				"Jackson", "Jacky", "Jacob", "Jacques", "Jad", "Jaden", "Jadon", "Jadyn", "Jae", "Jagat", "Jago", "Jaheim",
+				"Jahid", "Jahy", "Jai", "Jaida", "Jaiden", "Jaidyn", "Jaii", "Jaime", "Jai-Rajaram", "Jaise", "Jak", "Jake",
+				"Jakey", "Jakob", "Jaksyn", "Jakub", "Jamaal", "Jamal", "Jameel", "Jameil", "James", "James-Paul", "Jamey",
+				"Jamie", "Jan", "Jaosha", "Jardine", "Jared", "Jarell", "Jarl", "Jarno", "Jarred", "Jarvi", "Jasey-Jay",
+				"Jasim", "Jaskaran", "Jason", "Jasper", "Jaxon", "Jaxson", "Jay", "Jaydan", "Jayden", "Jayden-James",
+				"Jayden-Lee", "Jayden-Paul", "Jayden-Thomas", "Jaydn", "Jaydon", "Jaydyn", "Jayhan", "Jay-Jay", "Jayke",
+				"Jaymie", "Jayse", "Jayson", "Jaz", "Jazeb", "Jazib", "Jazz", "Jean", "Jean-Lewis", "Jean-Pierre",
+				"Jebadiah", "Jed", "Jedd", "Jedidiah", "Jeemie", "Jeevan", "Jeffrey", "Jensen", "Jenson", "Jensyn",
+				"Jeremy", "Jerome", "Jeronimo", "Jerrick", "Jerry", "Jesse", "Jesuseun", "Jeswin", "Jevan", "Jeyun", "Jez",
+				"Jia", "Jian", "Jiao", "Jimmy", "Jincheng", "JJ", "Joaquin", "Joash", "Jock", "Jody", "Joe", "Joeddy",
+				"Joel", "Joey", "Joey-Jack", "Johann", "Johannes", "Johansson", "John", "Johnathan", "Johndean", "Johnjay",
+				"John-Michael", "Johnnie", "Johnny", "Johnpaul", "John-Paul", "John-Scott", "Johnson", "Jole", "Jomuel",
+				"Jon", "Jonah", "Jonatan", "Jonathan", "Jonathon", "Jonny", "Jonothan", "Jon-Paul", "Jonson", "Joojo",
+				"Jordan", "Jordi", "Jordon", "Jordy", "Jordyn", "Jorge", "Joris", "Jorryn", "Josan", "Josef", "Joseph",
+				"Josese", "Josh", "Joshiah", "Joshua", "Josiah", "Joss", "Jostelle", "Joynul", "Juan", "Jubin", "Judah",
+				"Jude", "Jules", "Julian", "Julien", "Jun", "Junior", "Jura", "Justan", "Justin", "Justinas", "Kaan",
+				"Kabeer", "Kabir", "Kacey", "Kacper", "Kade", "Kaden", "Kadin", "Kadyn", "Kaeden", "Kael", "Kaelan",
+				"Kaelin", "Kaelum", "Kai", "Kaid", "Kaidan", "Kaiden", "Kaidinn", "Kaidyn", "Kaileb", "Kailin", "Kain",
+				"Kaine", "Kainin", "Kainui", "Kairn", "Kaison", "Kaiwen", "Kajally", "Kajetan", "Kalani", "Kale", "Kaleb",
+				"Kaleem", "Kal-el", "Kalen", "Kalin", "Kallan", "Kallin", "Kalum", "Kalvin", "Kalvyn", "Kameron", "Kames",
+				"Kamil", "Kamran", "Kamron", "Kane", "Karam", "Karamvir", "Karandeep", "Kareem", "Karim", "Karimas", "Karl",
+				"Karol", "Karson", "Karsyn", "Karthikeya", "Kasey", "Kash", "Kashif", "Kasim", "Kasper", "Kasra", "Kavin",
+				"Kayam", "Kaydan", "Kayden", "Kaydin", "Kaydn", "Kaydyn", "Kaydyne", "Kayleb", "Kaylem", "Kaylum", "Kayne",
+				"Kaywan", "Kealan", "Kealon", "Kean", "Keane", "Kearney", "Keatin", "Keaton", "Keavan", "Keayn", "Kedrick",
+				"Keegan", "Keelan", "Keelin", "Keeman", "Keenan", "Keenan-Lee", "Keeton", "Kehinde", "Keigan", "Keilan",
+				"Keir", "Keiran", "Keiren", "Keiron", "Keiryn", "Keison", "Keith", "Keivlin", "Kelam", "Kelan", "Kellan",
+				"Kellen", "Kelso", "Kelum", "Kelvan", "Kelvin", "Ken", "Kenan", "Kendall", "Kendyn", "Kenlin", "Kenneth",
+				"Kensey", "Kenton", "Kenyon", "Kenzeigh", "Kenzi", "Kenzie", "Kenzo", "Kenzy", "Keo", "Ker", "Kern", "Kerr",
+				"Kevan", "Kevin", "Kevyn", "Kez", "Khai", "Khalan", "Khaleel", "Khaya", "Khevien", "Khizar", "Khizer",
+				"Kia", "Kian", "Kian-James", "Kiaran", "Kiarash", "Kie", "Kiefer", "Kiegan", "Kienan", "Kier", "Kieran",
+				"Kieran-Scott", "Kieren", "Kierin", "Kiern", "Kieron", "Kieryn", "Kile", "Killian", "Kimi", "Kingston",
+				"Kinneil", "Kinnon", "Kinsey", "Kiran", "Kirk", "Kirwin", "Kit", "Kiya", "Kiyonari", "Kjae", "Klein",
+				"Klevis", "Kobe", "Kobi", "Koby", "Koddi", "Koden", "Kodi", "Kodie", "Kody", "Kofi", "Kogan", "Kohen",
+				"Kole", "Konan", "Konar", "Konnor", "Konrad", "Koray", "Korben", "Korbyn", "Korey", "Kori", "Korrin",
+				"Kory", "Koushik", "Kris", "Krish", "Krishan", "Kriss", "Kristian", "Kristin", "Kristofer", "Kristoffer",
+				"Kristopher", "Kruz", "Krzysiek", "Krzysztof", "Ksawery", "Ksawier", "Kuba", "Kurt", "Kurtis", "Kurtis-Jae",
+				"Kyaan", "Kyan", "Kyde", "Kyden", "Kye", "Kyel", "Kyhran", "Kyie", "Kylan", "Kylar", "Kyle", "Kyle-Derek",
+				"Kylian", "Kym", "Kynan", "Kyral", "Kyran", "Kyren", "Kyrillos", "Kyro", "Kyron", "Kyrran", "Lachlainn",
+				"Lachlan", "Lachlann", "Lael", "Lagan", "Laird", "Laison", "Lakshya", "Lance", "Lancelot", "Landon", "Lang",
+				"Lasse", "Latif", "Lauchlan", "Lauchlin", "Laughlan", "Lauren", "Laurence", "Laurie", "Lawlyn", "Lawrence",
+				"Lawrie", "Lawson", "Layne", "Layton", "Lee", "Leigh", "Leigham", "Leighton", "Leilan", "Leiten", "Leithen",
+				"Leland", "Lenin", "Lennan", "Lennen", "Lennex", "Lennon", "Lennox", "Lenny", "Leno", "Lenon", "Lenyn",
+				"Leo", "Leon", "Leonard", "Leonardas", "Leonardo", "Lepeng", "Leroy", "Leven", "Levi", "Levon", "Levy",
+				"Lewie", "Lewin", "Lewis", "Lex", "Leydon", "Leyland", "Leylann", "Leyton", "Liall", "Liam", "Liam-Stephen",
+				"Limo", "Lincoln", "Lincoln-John", "Lincon", "Linden", "Linton", "Lionel", "Lisandro", "Litrell",
+				"Liyonela-Elam", "LLeyton", "Lliam", "Lloyd", "Lloyde", "Loche", "Lochlan", "Lochlann", "Lochlan-Oliver",
+				"Lock", "Lockey", "Logan", "Logann", "Logan-Rhys", "Loghan", "Lokesh", "Loki", "Lomond", "Lorcan", "Lorenz",
+				"Lorenzo", "Lorne", "Loudon", "Loui", "Louie", "Louis", "Loukas", "Lovell", "Luc", "Luca", "Lucais",
+				"Lucas", "Lucca", "Lucian", "Luciano", "Lucien", "Lucus", "Luic", "Luis", "Luk", "Luka", "Lukas", "Lukasz",
+				"Luke", "Lukmaan", "Luqman", "Lyall", "Lyle", "Lyndsay", "Lysander", "Maanav", "Maaz", "Mac", "Macallum",
+				"Macaulay", "Macauley", "Macaully", "Machlan", "Maciej", "Mack", "Mackenzie", "Mackenzy", "Mackie",
+				"Macsen", "Macy", "Madaki", "Maddison", "Maddox", "Madison", "Madison-Jake", "Madox", "Mael", "Magnus",
+				"Mahan", "Mahdi", "Mahmoud", "Maias", "Maison", "Maisum", "Maitlind", "Majid", "Makensie", "Makenzie",
+				"Makin", "Maksim", "Maksymilian", "Malachai", "Malachi", "Malachy", "Malakai", "Malakhy", "Malcolm",
+				"Malik", "Malikye", "Malo", "Ma'moon", "Manas", "Maneet", "Manmohan", "Manolo", "Manson", "Mantej",
+				"Manuel", "Manus", "Marc", "Marc-Anthony", "Marcel", "Marcello", "Marcin", "Marco", "Marcos", "Marcous",
+				"Marcquis", "Marcus", "Mario", "Marios", "Marius", "Mark", "Marko", "Markus", "Marley", "Marlin", "Marlon",
+				"Maros", "Marshall", "Martin", "Marty", "Martyn", "Marvellous", "Marvin", "Marwan", "Maryk", "Marzuq",
+				"Mashhood", "Mason", "Mason-Jay", "Masood", "Masson", "Matas", "Matej", "Mateusz", "Mathew", "Mathias",
+				"Mathu", "Mathuyan", "Mati", "Matt", "Matteo", "Matthew", "Matthew-William", "Matthias", "Max", "Maxim",
+				"Maximilian", "Maximillian", "Maximus", "Maxwell", "Maxx", "Mayeul", "Mayson", "Mazin", "Mcbride",
+				"McCaulley", "McKade", "McKauley", "McKay", "McKenzie", "McLay", "Meftah", "Mehmet", "Mehraz", "Meko",
+				"Melville", "Meshach", "Meyzhward", "Micah", "Michael", "Michael-Alexander", "Michael-James", "Michal",
+				"Michat", "Micheal", "Michee", "Mickey", "Miguel", "Mika", "Mikael", "Mi'kael", "Mikee", "Mikey", "Mikhail",
+				"Mikolaj", "Miles", "Millar", "Miller", "Milo", "Milos", "Milosz", "Mir", "Mirza", "Mitch", "Mitchel",
+				"Mitchell", "Moad", "Moayd", "Mobeen", "Modoulamin", "Modu", "Mohamad", "Mohamed", "Mohammad",
+				"Mohammad-Bilal", "Mohammed", "Mohanad", "Mohd", "Momin", "Momooreoluwa", "Montague", "Montgomery", "Monty",
+				"Moore", "Moosa", "Moray", "Morgan", "Morgyn", "Morris", "Morton", "Moshy", "Motade", "Moyes", "Msughter",
+				"Mueez", "Muhamadjavad", "Muhammad", "Muhammed", "Muhsin", "Muir", "Munachi", "Muneeb", "Mungo", "Munir",
+				"Munmair", "Munro", "Murdo", "Murray", "Murrough", "Murry", "Musa", "Musse", "Mustafa", "Mustapha",
+				"Muzammil", "Muzzammil", "Mykie", "Myles", "Mylo", "Nabeel", "Nadeem", "Nader", "Nagib", "Naif", "Nairn",
+				"Narvic", "Nash", "Nasser", "Nassir", "Natan", "Nate", "Nathan", "Nathanael", "Nathanial", "Nathaniel",
+				"Nathan-Rae", "Nawfal", "Nayan", "Neco", "Neil", "Nelson", "Neo", "Neshawn", "Nevan", "Nevin",
+				"Ngonidzashe", "Nial", "Niall", "Nicholas", "Nick", "Nickhill", "Nicki", "Nickson", "Nicky", "Nico",
+				"Nicodemus", "Nicol", "Nicolae", "Nicolas", "Nidhish", "Nihaal", "Nihal", "Nikash", "Nikhil", "Niki",
+				"Nikita", "Nikodem", "Nikolai", "Nikos", "Nilav", "Niraj", "Niro", "Niven", "Noah", "Noel", "Nolan", "Noor",
+				"Norman", "Norrie", "Nuada", "Nyah", "Oakley", "Oban", "Obieluem", "Obosa", "Odhran", "Odin", "Odynn",
+				"Ogheneochuko", "Ogheneruno", "Ohran", "Oilibhear", "Oisin", "Ojima-Ojo", "Okeoghene", "Olaf", "Ola-Oluwa",
+				"Olaoluwapolorimi", "Ole", "Olie", "Oliver", "Olivier", "Oliwier", "Ollie", "Olurotimi", "Oluwadamilare",
+				"Oluwadamiloju", "Oluwafemi", "Oluwafikunayomi", "Oluwalayomi", "Oluwatobiloba", "Oluwatoni", "Omar",
+				"Omri", "Oran", "Orin", "Orlando", "Orley", "Orran", "Orrick", "Orrin", "Orson", "Oryn", "Oscar",
+				"Osesenagha", "Oskar", "Ossian", "Oswald", "Otto", "Owain", "Owais", "Owen", "Owyn", "Oz", "Ozzy", "Pablo",
+				"Pacey", "Padraig", "Paolo", "Pardeepraj", "Parkash", "Parker", "Pascoe", "Pasquale", "Patrick",
+				"Patrick-John", "Patrikas", "Patryk", "Paul", "Pavit", "Pawel", "Pawlo", "Pearce", "Pearse", "Pearsen",
+				"Pedram", "Pedro", "Peirce", "Peiyan", "Pele", "Peni", "Peregrine", "Peter", "Phani", "Philip", "Philippos",
+				"Phinehas", "Phoenix", "Phoevos", "Pierce", "Pierre-Antoine", "Pieter", "Pietro", "Piotr", "Porter",
+				"Prabhjoit", "Prabodhan", "Praise", "Pranav", "Pravin", "Precious", "Prentice", "Presley", "Preston",
+				"Preston-Jay", "Prinay", "Prince", "Prithvi", "Promise", "Puneetpaul", "Pushkar", "Qasim", "Qirui",
+				"Quinlan", "Quinn", "Radmiras", "Raees", "Raegan", "Rafael", "Rafal", "Rafferty", "Rafi", "Raheem", "Rahil",
+				"Rahim", "Rahman", "Raith", "Raithin", "Raja", "Rajab-Ali", "Rajan", "Ralfs", "Ralph", "Ramanas", "Ramit",
+				"Ramone", "Ramsay", "Ramsey", "Rana", "Ranolph", "Raphael", "Rasmus", "Rasul", "Raul", "Raunaq", "Ravin",
+				"Ray", "Rayaan", "Rayan", "Rayane", "Rayden", "Rayhan", "Raymond", "Rayne", "Rayyan", "Raza", "Reace",
+				"Reagan", "Reean", "Reece", "Reed", "Reegan", "Rees", "Reese", "Reeve", "Regan", "Regean", "Reggie",
+				"Rehaan", "Rehan", "Reice", "Reid", "Reigan", "Reilly", "Reily", "Reis", "Reiss", "Remigiusz", "Remo",
+				"Remy", "Ren", "Renars", "Reng", "Rennie", "Reno", "Reo", "Reuben", "Rexford", "Reynold", "Rhein", "Rheo",
+				"Rhett", "Rheyden", "Rhian", "Rhoan", "Rholmark", "Rhoridh", "Rhuairidh", "Rhuan", "Rhuaridh", "Rhudi",
+				"Rhy", "Rhyan", "Rhyley", "Rhyon", "Rhys", "Rhys-Bernard", "Rhyse", "Riach", "Rian", "Ricards", "Riccardo",
+				"Ricco", "Rice", "Richard", "Richey", "Richie", "Ricky", "Rico", "Ridley", "Ridwan", "Rihab", "Rihan",
+				"Rihards", "Rihonn", "Rikki", "Riley", "Rio", "Rioden", "Rishi", "Ritchie", "Rivan", "Riyadh", "Riyaj",
+				"Roan", "Roark", "Roary", "Rob", "Robbi", "Robbie", "Robbie-lee", "Robby", "Robert", "Robert-Gordon",
+				"Robertjohn", "Robi", "Robin", "Rocco", "Roddy", "Roderick", "Rodrigo", "Roen", "Rogan", "Roger", "Rohaan",
+				"Rohan", "Rohin", "Rohit", "Rokas", "Roman", "Ronald", "Ronan", "Ronan-Benedict", "Ronin", "Ronnie",
+				"Rooke", "Roray", "Rori", "Rorie", "Rory", "Roshan", "Ross", "Ross-Andrew", "Rossi", "Rowan", "Rowen",
+				"Roy", "Ruadhan", "Ruaidhri", "Ruairi", "Ruairidh", "Ruan", "Ruaraidh", "Ruari", "Ruaridh", "Ruben",
+				"Rubhan", "Rubin", "Rubyn", "Rudi", "Rudy", "Rufus", "Rui", "Ruo", "Rupert", "Ruslan", "Russel", "Russell",
+				"Ryaan", "Ryan", "Ryan-Lee", "Ryden", "Ryder", "Ryese", "Ryhs", "Rylan", "Rylay", "Rylee", "Ryleigh",
+				"Ryley", "Rylie", "Ryo", "Ryszard", "Saad", "Sabeen", "Sachkirat", "Saffi", "Saghun", "Sahaib", "Sahbian",
+				"Sahil", "Saif", "Saifaddine", "Saim", "Sajid", "Sajjad", "Salahudin", "Salman", "Salter", "Salvador",
+				"Sam", "Saman", "Samar", "Samarjit", "Samatar", "Sambrid", "Sameer", "Sami", "Samir", "Sami-Ullah",
+				"Samual", "Samuel", "Samuela", "Samy", "Sanaullah", "Sandro", "Sandy", "Sanfur", "Sanjay", "Santiago",
+				"Santino", "Satveer", "Saul", "Saunders", "Savin", "Sayad", "Sayeed", "Sayf", "Scot", "Scott",
+				"Scott-Alexander", "Seaan", "Seamas", "Seamus", "Sean", "Seane", "Sean-James", "Sean-Paul", "Sean-Ray",
+				"Seb", "Sebastian", "Sebastien", "Selasi", "Seonaidh", "Sephiroth", "Sergei", "Sergio", "Seth", "Sethu",
+				"Seumas", "Shaarvin", "Shadow", "Shae", "Shahmir", "Shai", "Shane", "Shannon", "Sharland", "Sharoz",
+				"Shaughn", "Shaun", "Shaunpaul", "Shaun-Paul", "Shaun-Thomas", "Shaurya", "Shaw", "Shawn", "Shawnpaul",
+				"Shay", "Shayaan", "Shayan", "Shaye", "Shayne", "Shazil", "Shea", "Sheafan", "Sheigh", "Shenuk", "Sher",
+				"Shergo", "Sheriff", "Sherwyn", "Shiloh", "Shiraz", "Shreeram", "Shreyas", "Shyam", "Siddhant", "Siddharth",
+				"Sidharth", "Sidney", "Siergiej", "Silas", "Simon", "Sinai", "Skye", "Sofian", "Sohaib", "Sohail", "Soham",
+				"Sohan", "Sol", "Solomon", "Sonneey", "Sonni", "Sonny", "Sorley", "Soul", "Spencer", "Spondon", "Stanislaw",
+				"Stanley", "Stefan", "Stefano", "Stefin", "Stephen", "Stephenjunior", "Steve", "Steven", "Steven-lee",
+				"Stevie", "Stewart", "Stewarty", "Strachan", "Struan", "Stuart", "Su", "Subhaan", "Sudais", "Suheyb",
+				"Suilven", "Sukhi", "Sukhpal", "Sukhvir", "Sulayman", "Sullivan", "Sultan", "Sung", "Sunny", "Suraj",
+				"Surien", "Sweyn", "Syed", "Sylvain", "Symon", "Szymon", "Tadd", "Taddy", "Tadhg", "Taegan", "Taegen",
+				"Tai", "Tait", "Taiwo", "Talha", "Taliesin", "Talon", "Talorcan", "Tamar", "Tamiem", "Tammam", "Tanay",
+				"Tane", "Tanner", "Tanvir", "Tanzeel", "Taonga", "Tarik", "Tariq-Jay", "Tate", "Taylan", "Taylar", "Tayler",
+				"Taylor", "Taylor-Jay", "Taylor-Lee", "Tayo", "Tayyab", "Tayye", "Tayyib", "Teagan", "Tee", "Teejay",
+				"Tee-jay", "Tegan", "Teighen", "Teiyib", "Te-Jay", "Temba", "Teo", "Teodor", "Teos", "Terry", "Teydren",
+				"Theo", "Theodore", "Thiago", "Thierry", "Thom", "Thomas", "Thomas-Jay", "Thomson", "Thorben", "Thorfinn",
+				"Thrinei", "Thumbiko", "Tiago", "Tian", "Tiarnan", "Tibet", "Tieran", "Tiernan", "Timothy", "Timucin",
+				"Tiree", "Tisloh", "Titi", "Titus", "Tiylar", "TJ", "Tjay", "T'jay", "T-Jay", "Tobey", "Tobi", "Tobias",
+				"Tobie", "Toby", "Todd", "Tokinaga", "Toluwalase", "Tom", "Tomas", "Tomasz", "Tommi-Lee", "Tommy", "Tomson",
+				"Tony", "Torin", "Torquil", "Torran", "Torrin", "Torsten", "Trafford", "Trai", "Travis", "Tre", "Trent",
+				"Trey", "Tristain", "Tristan", "Troy", "Tubagus", "Turki", "Turner", "Ty", "Ty-Alexander", "Tye", "Tyelor",
+				"Tylar", "Tyler", "Tyler-James", "Tyler-Jay", "Tyllor", "Tylor", "Tymom", "Tymon", "Tymoteusz", "Tyra",
+				"Tyree", "Tyrnan", "Tyrone", "Tyson", "Ubaid", "Ubayd", "Uchenna", "Uilleam", "Umair", "Umar", "Umer",
+				"Umut", "Urban", "Uri", "Usman", "Uzair", "Uzayr", "Valen", "Valentin", "Valentino", "Valery", "Valo",
+				"Vasyl", "Vedantsinh", "Veeran", "Victor", "Victory", "Vinay", "Vince", "Vincent", "Vincenzo", "Vinh",
+				"Vinnie", "Vithujan", "Vladimir", "Vladislav", "Vrishin", "Vuyolwethu", "Wabuya", "Wai", "Walid", "Wallace",
+				"Walter", "Waqaas", "Warkhas", "Warren", "Warrick", "Wasif", "Wayde", "Wayne", "Wei", "Wen", "Wesley",
+				"Wesley-Scott", "Wiktor", "Wilkie", "Will", "William", "William-John", "Willum", "Wilson", "Windsor",
+				"Wojciech", "Woyenbrakemi", "Wyatt", "Wylie", "Wynn", "Xabier", "Xander", "Xavier", "Xiao", "Xida", "Xin",
+				"Xue", "Yadgor", "Yago", "Yahya", "Yakup", "Yang", "Yanick", "Yann", "Yannick", "Yaseen", "Yasin", "Yasir",
+				"Yassin", "Yoji", "Yong", "Yoolgeun", "Yorgos", "Youcef", "Yousif", "Youssef", "Yu", "Yuanyu", "Yuri",
+				"Yusef", "Yusuf", "Yves", "Zaaine", "Zaak", "Zac", "Zach", "Zachariah", "Zacharias", "Zacharie",
+				"Zacharius", "Zachariya", "Zachary", "Zachary-Marc", "Zachery", "Zack", "Zackary", "Zaid", "Zain", "Zaine",
+				"Zaineddine", "Zainedin", "Zak", "Zakaria", "Zakariya", "Zakary", "Zaki", "Zakir", "Zakk", "Zamaar",
+				"Zander", "Zane", "Zarran", "Zayd", "Zayn", "Zayne", "Ze", "Zechariah", "Zeek", "Zeeshan", "Zeid", "Zein",
+				"Zen", "Zendel", "Zenith", "Zennon", "Zeph", "Zerah", "Zhen", "Zhi", "Zhong", "Zhuo", "Zi", "Zidane",
+				"Zijie", "Zinedine", "Zion", "Zishan", "Ziya", "Ziyaan", "Zohaib", "Zohair", "Zoubaeir", "Zubair", "Zubayr",
+				"Zuriel", "Jaime", "Jayden", "Josie", "Juliet", "Karys", "Kathleen", "Kendra", "Keri", "Keris", "Kirstin",
+				"Klaudia", "Luisa", "Lydia", "Maeve", "Marnie", "Miah", "Mirrin", "Nancy", "Nia", "Nikki", "Oliwia",
+				"Paris", "Piper", "Pippa", "Polly", "Rhona", "Safa", "Saira", "Sarah-Louise", "Shona", "Sorcha", "Stacey",
+				"Tessa", "Tiffany", "Verity", "Zarah", "Zoya", "Alexandria", "Alina", "Alison", "Angela", "Arianna",
+				"Chanel", "Chelsey", "Coral", "Corinne", "Danni", "Darci", "Dionne", "Eliza", "Elsie", "Fatima", "Freyja",
+				"Holli", "Jane", "Joanne", "Karina", "Katrina", "Kaylah", "Kaylee", "Lori", "Mila", "Nikita", "Penny",
+				"Sylvie", "Tammy", "Alexa", "Brooklyn", "Caragh", "Codie", "Constance", "Dana", "Demi-Lee", "Emilie",
+				"Esther", "Frankie", "Isabelle", "Jamie-Leigh", "Jessie", "Josephine", "Kady", "Kaila", "Kerri", "Kirstie",
+				"Lyla", "Macey", "Maisy", "Margaret", "Marie", "Maryam", "Mercedes", "Mischa", "Rosa", "Serena", "Sian",
+				"Tamzin", "Vanessa", "Violet", "Yasmine", "Aisha", "Aleisha", "Ana", "Daniella", "Elsa", "Jodi", "Karly",
+				"Leigha", "Lila", "Melanie", "Miriam", "Regan", "Sally", "Saskia", "Simone", "Tess", "Thea", "Zainab",
+				"Arwen", "Bonnie", "Eloise", "Emma-Louise", "Halle", "Hana", "Honey", "Jamie-Lee", "Karla", "Leia", "Leila",
+				"Madeline", "Neave", "Orlaith", "Rhea", "Sarah-Jane", "Tara", "Adele", "Alannah", "Alesha", "Annabelle",
+				"Ayla", "Becca", "Darcie", "Ebony", "Erica", "Georgie", "Hanna", "Julie", "Kadie", "Kelly", "Kiara",
+				"Lillie", "Mariam", "Mikayla", "Monica", "Roisin", "Savannah", "Sky", "Zahra", "Alanna", "Caoimhe",
+				"Chanelle", "Elisha", "Emilia", "Iris", "Kacie", "Lia", "Maja", "Mary", "Michelle", "Tyler", "Willow",
+				"Yasmin", "Becky", "Billie", "Clara", "Claudia", "Cody", "Elena", "Eryn", "Georgina", "Kayley", "Kimberley",
+				"Kira", "Laila", "Lauryn", "Murron", "Natalia", "Ruth", "Siobhan", "Tiana", "Bethan", "Brodie", "Cameron",
+				"Cassie", "Harriet", "Helen", "Kathryn", "Kyra", "Mairi", "Mckenzie", "Tilly", "Zuzanna", "April",
+				"Christina", "Claire", "Darcey", "Fern", "Fiona", "Joanna", "Lucia", "Charli", "Jamie", "Karis",
+				"Mackenzie", "Marissa", "Rihanna", "Teagan", "Tiegan", "Kaitlin", "Keeley", "Leigh", "Nadia", "Alix",
+				"Callie", "Carrie", "Eden", "Esme", "Hazel", "Miya", "Nieve", "Sadie", "Sasha", "Sinead", "Stella",
+				"Ashleigh", "Jade", "Jemma", "Michaela", "Alexis", "Aoife", "Francesca", "Lisa", "Matilda", "Annabel",
+				"Carmen", "Eleanor", "Faye", "Kaci", "Kasey", "Kerry", "Louisa", "Macy", "Mhairi", "Rebekah", "Teigan",
+				"Amie", "Brogan", "Catriona", "Scarlett", "Connie", "Katelyn", "Kenzie", "Lexi", "Nicola", "Sienna", "Abbi",
+				"Angel", "Martha", "Anya", "Toni", "Chantelle", "Gabriella", "Lexie", "Abbey", "Bailey", "Isobel", "Kelsie",
+				"Maia", "Nina", "Darcy", "Lacey", "Lana", "Sofia", "Stephanie", "Ellen", "Alicia", "Gabrielle", "Heidi",
+				"Jorja", "Kyla", "Rhiannon", "Tegan", "Maddison", "Madeleine", "Morven", "Rowan", "Lucie", "Milly", "Annie",
+				"Ashley", "Ellis", "Hope", "Mirren", "Rose", "Alexandra", "Jodie", "Kacey", "Phoebe", "Tia", "Ailsa",
+				"Alana", "Kirsten", "Charlie", "Katy", "Lilly", "Alyssa", "Maria", "Naomi", "Alisha", "Danielle", "Lola",
+				"Ciara", "Elle", "Faith", "Natasha", "Katherine", "Lois", "Mollie", "Carla", "Catherine", "Cerys", "Maisie",
+				"Victoria", "Amelie", "Demi", "Gracie", "Carys", "Isabella", "Leona", "Alex", "Hollie", "Sara", "Caitlyn",
+				"Kiera", "Lara", "Kate", "Louise", "Libby", "Rhianna", "Rosie", "Alice", "Julia", "Maya", "Natalie",
+				"Chelsea", "Layla", "Samantha", "Heather", "Kirsty", "Rachael", "Charley", "Imogen", "Elise", "Hayley",
+				"Kelsey", "Kara", "Orla", "Abi", "Gemma", "Laura", "Mya", "Bethany", "Jasmine", "Melissa", "Poppy", "Casey",
+				"Elizabeth", "Kaitlyn", "Carly", "Abby", "Neve", "Courtney", "Jennifer", "Sophia", "Shannon", "Georgia",
+				"Amber", "Robyn", "Beth", "Zara", "Amelia", "Taylor", "Daisy", "Paige", "Kayleigh", "Summer", "Madison",
+				"Jenna", "Morgan", "Evie", "Nicole", "Ella", "Cara", "Iona", "Eve", "Zoe", "Kayla", "Molly", "Abigail",
+				"Charlotte", "Millie", "Holly", "Leah", "Keira", "Lily", "Freya", "Caitlin", "Lauren", "Rachel", "Anna",
+				"Sarah", "Ruby", "Aimee", "Mia", "Skye", "Abbie", "Eva", "Eilidh", "Niamh", "Megan", "Brooke", "Isla",
+				"Rebecca", "Ava", "Grace", "Jessica", "Hannah", "Olivia", "Chloe", "Emily", "Amy", "Ellie", "Erin", "Katie",
+				"Lucy", "Emma", "Sophie" };
+	}
+
+	private static final String[] generateFirstNames() {
+		return new String[] { "AARON", "ABBIE", "ABBY", "ABEL", "ABIGAIL", "ABRAHAM",
+				"ADA", "ADAM", "ADAN", "ADDIE", "ADELA", "ADELAIDE", "ADELE", "ADELINE", "ADOLFO", "ADOLPH", "ADRIAN",
+				"ADRIANA", "ADRIENNE", "AGNES", "AGUSTIN", "AIDA", "AILEEN", "AIMEE", "AISHA", "AL", "ALAN", "ALANA",
+				"ALBA", "ALBERT", "ALBERTA", "ALBERTO", "ALEJANDRA", "ALEJANDRO", "ALEX", "ALEXANDER", "ALEXANDRA",
+				"ALEXANDRIA", "ALEXIS", "ALFONSO", "ALFRED", "ALFREDA", "ALFREDO", "ALI", "ALICE", "ALICIA", "ALINE",
+				"ALISA", "ALISHA", "ALISON", "ALISSA", "ALLAN", "ALLEN", "ALLENE", "ALLIE", "ALLISON", "ALLYSON", "ALMA",
+				"ALONZO", "ALPHONSO", "ALTA", "ALTHEA", "ALTON", "ALVARO", "ALVIN", "ALYCE", "ALYSON", "ALYSSA", "AMALIA",
+				"AMANDA", "AMBER", "AMELIA", "AMIE", "AMOS", "AMPARO", "AMY", "ANA", "ANASTASIA", "ANDRE", "ANDREA",
+				"ANDRES", "ANDREW", "ANDY", "ANGEL", "ANGELA", "ANGELIA", "ANGELICA", "ANGELINA", "ANGELINE", "ANGELIQUE",
+				"ANGELITA", "ANGELO", "ANGIE", "ANITA", "ANN", "ANNA", "ANNABELLE", "ANNE", "ANNETTE", "ANNIE", "ANNMARIE",
+				"ANTHONY", "ANTIONETTE", "ANTOINE", "ANTOINETTE", "ANTON", "ANTONIA", "ANTONIO", "ANTONY", "APRIL",
+				"ARACELI", "ARCHIE", "ARLENE", "ARLINE", "ARMAND", "ARMANDO", "ARNOLD", "ARRON", "ART", "ARTHUR", "ARTURO",
+				"ASHLEE", "ASHLEIGH", "ASHLEY", "AUBREY", "AUDRA", "AUDREY", "AUGUST", "AUGUSTA", "AURELIA", "AURELIO",
+				"AURORA", "AUSTIN", "AUTUMN", "AVA", "AVERY", "AVIS", "BARBARA", "BARBRA", "BARNEY", "BARRY", "BART",
+				"BASIL", "BEATRICE", "BEATRIZ", "BEAU", "BECKY", "BELINDA", "BEN", "BENITA", "BENITO", "BENJAMIN",
+				"BENNETT", "BENNIE", "BENNY", "BERNADETTE", "BERNADINE", "BERNARD", "BERNARDO", "BERNICE", "BERNIE", "BERT",
+				"BERTA", "BERTHA", "BERTIE", "BERYL", "BESSIE", "BETH", "BETHANY", "BETSY", "BETTE", "BETTIE", "BETTY",
+				"BETTYE", "BEULAH", "BEVERLEY", "BEVERLY", "BIANCA", "BILL", "BILLIE", "BILLY", "BLAINE", "BLAIR", "BLAKE",
+				"BLANCA", "BLANCHE", "BOB", "BOBBI", "BOBBIE", "BOBBY", "BONITA", "BONNIE", "BOOKER", "BOYD", "BRAD",
+				"BRADFORD", "BRADLEY", "BRADY", "BRAIN", "BRANDEN", "BRANDI", "BRANDIE", "BRANDON", "BRANDY", "BRENDA",
+				"BRENDAN", "BRENT", "BRET", "BRETT", "BRIAN", "BRIANA", "BRIANNA", "BRIDGET", "BRIDGETT", "BRIDGETTE",
+				"BRIGITTE", "BRITNEY", "BRITTANY", "BRITTNEY", "BROCK", "BROOKE", "BRUCE", "BRUNO", "BRYAN", "BRYANT",
+				"BRYCE", "BRYON", "BUDDY", "BUFORD", "BURTON", "BYRON", "CAITLIN", "CALEB", "CALLIE", "CALVIN", "CAMERON",
+				"CAMILLA", "CAMILLE", "CANDACE", "CANDICE", "CANDY", "CARA", "CAREY", "CARISSA", "CARL", "CARLA", "CARLENE",
+				"CARLO", "CARLOS", "CARLTON", "CARLY", "CARMELA", "CARMELLA", "CARMELO", "CARMEN", "CAROL", "CAROLE",
+				"CAROLINA", "CAROLINE", "CAROLYN", "CARRIE", "CARROLL", "CARSON", "CARTER", "CARY", "CARYN", "CASANDRA",
+				"CASEY", "CASSANDRA", "CASSIE", "CATALINA", "CATHERINE", "CATHLEEN", "CATHRYN", "CATHY", "CECELIA", "CECIL",
+				"CECILE", "CECILIA", "CEDRIC", "CELESTE", "CELIA", "CELINA", "CESAR", "CHAD", "CHANDRA", "CHARITY",
+				"CHARLENE", "CHARLES", "CHARLEY", "CHARLIE", "CHARLOTTE", "CHARMAINE", "CHASE", "CHASITY", "CHELSEA",
+				"CHELSEY", "CHERI", "CHERIE", "CHERRY", "CHERYL", "CHESTER", "CHRIS", "CHRISTA", "CHRISTI", "CHRISTIAN",
+				"CHRISTIE", "CHRISTINA", "CHRISTINE", "CHRISTOPHER", "CHRISTY", "CHRYSTAL", "CHUCK", "CINDY", "CLAIR",
+				"CLAIRE", "CLARA", "CLARE", "CLARENCE", "CLARICE", "CLARISSA", "CLARK", "CLAUDE", "CLAUDETTE", "CLAUDIA",
+				"CLAUDINE", "CLAY", "CLAYTON", "CLEMENT", "CLEO", "CLEVELAND", "CLIFF", "CLIFFORD", "CLIFTON", "CLINT",
+				"CLINTON", "CLYDE", "CODY", "COLBY", "COLE", "COLEEN", "COLETTE", "COLIN", "COLLEEN", "COLLIN",
+				"CONCEPCION", "CONCETTA", "CONNIE", "CONRAD", "CONSTANCE", "CONSUELO", "CORA", "COREY", "CORINA", "CORINE",
+				"CORINNE", "CORNELIA", "CORNELIUS", "CORNELL", "CORRINE", "CORTNEY", "CORY", "COURTNEY", "COY", "CRAIG",
+				"CRISTINA", "CRUZ", "CRYSTAL", "CURT", "CURTIS", "CYNTHIA", "DAISY", "DALE", "DALLAS", "DALTON", "DAMIAN",
+				"DAMIEN", "DAMON", "DAN", "DANA", "DANE", "DANIAL", "DANIEL", "DANIELLE", "DANNY", "DANTE", "DAPHNE",
+				"DARCY", "DAREN", "DARIN", "DARIUS", "DARLA", "DARLENE", "DARNELL", "DARREL", "DARRELL", "DARREN", "DARRIN",
+				"DARRYL", "DARWIN", "DARYL", "DAVE", "DAVID", "DAVIS", "DAWN", "DAYNA", "DEAN", "DEANA", "DEANN", "DEANNA",
+				"DEANNE", "DEBBIE", "DEBORA", "DEBORAH", "DEBRA", "DEE", "DEENA", "DEIDRA", "DEIDRE", "DEIRDRE", "DELBERT",
+				"DELIA", "DELLA", "DELMAR", "DELORES", "DELORIS", "DEMETRIUS", "DENA", "DENICE", "DENIS", "DENISE",
+				"DENNIS", "DENNY", "DENVER", "DEREK", "DERICK", "DERRICK", "DESIREE", "DESMOND", "DESSIE", "DEVIN", "DEVON",
+				"DEWAYNE", "DEWEY", "DEXTER", "DIANA", "DIANE", "DIANN", "DIANNA", "DIANNE", "DICK", "DIEGO", "DINA",
+				"DION", "DIONNE", "DIRK", "DIXIE", "DOLLIE", "DOLLY", "DOLORES", "DOMINGO", "DOMINIC", "DOMINICK",
+				"DOMINIQUE", "DON", "DONA", "DONALD", "DONNA", "DONNELL", "DONNIE", "DONNY", "DONOVAN", "DORA", "DOREEN",
+				"DORETHA", "DORIS", "DOROTHEA", "DOROTHY", "DORTHY", "DOUG", "DOUGLAS", "DOYLE", "DREW", "DUANE", "DUDLEY",
+				"DUSTIN", "DWAYNE", "DWIGHT", "DYLAN", "EARL", "EARLENE", "EARLINE", "EARNEST", "EARNESTINE", "EBONY", "ED",
+				"EDDIE", "EDDY", "EDGAR", "EDITH", "EDMOND", "EDMUND", "EDNA", "EDUARDO", "EDWARD", "EDWARDO", "EDWIN",
+				"EDWINA", "EDYTHE", "EFFIE", "EFRAIN", "EILEEN", "ELAINE", "ELBA", "ELBERT", "ELDA", "ELDON", "ELEANOR",
+				"ELENA", "ELI", "ELIAS", "ELIJAH", "ELINOR", "ELISA", "ELISABETH", "ELISE", "ELISHA", "ELIZA", "ELIZABETH",
+				"ELLA", "ELLEN", "ELLIOT", "ELLIOTT", "ELLIS", "ELMA", "ELMER", "ELNORA", "ELOISE", "ELSA", "ELSIE",
+				"ELTON", "ELVA", "ELVIA", "ELVIN", "ELVIRA", "ELVIS", "ELWOOD", "EMANUEL", "EMERSON", "EMERY", "EMIL",
+				"EMILIA", "EMILIE", "EMILIO", "EMILY", "EMMA", "EMMANUEL", "EMMETT", "EMORY", "ENID", "ENRIQUE", "ERIC",
+				"ERICA", "ERICK", "ERICKA", "ERIK", "ERIKA", "ERIN", "ERMA", "ERNA", "ERNEST", "ERNESTINE", "ERNESTO",
+				"ERNIE", "ERROL", "ERVIN", "ERWIN", "ESMERALDA", "ESPERANZA", "ESSIE", "ESTEBAN", "ESTELA", "ESTELLA",
+				"ESTELLE", "ESTER", "ESTHER", "ETHAN", "ETHEL", "ETTA", "EUGENE", "EUGENIA", "EULA", "EUNICE", "EVA",
+				"EVAN", "EVANGELINA", "EVANGELINE", "EVE", "EVELYN", "EVERETT", "FABIAN", "FAITH", "FANNIE", "FANNY", "FAY",
+				"FAYE", "FEDERICO", "FELECIA", "FELICIA", "FELIPE", "FELIX", "FERN", "FERNANDO", "FIDEL", "FLETCHER",
+				"FLORA", "FLORENCE", "FLORINE", "FLOSSIE", "FLOYD", "FORREST", "FRAN", "FRANCES", "FRANCESCA", "FRANCINE",
+				"FRANCIS", "FRANCISCA", "FRANCISCO", "FRANK", "FRANKIE", "FRANKLIN", "FRED", "FREDA", "FREDDIE", "FREDDY",
+				"FREDERIC", "FREDERICK", "FREDRICK", "FREIDA", "FRIEDA", "GABRIEL", "GABRIELA", "GABRIELLE", "GAIL", "GALE",
+				"GALEN", "GARLAND", "GARRETT", "GARRY", "GARY", "GAVIN", "GAY", "GAYLA", "GAYLE", "GENA", "GENARO", "GENE",
+				"GENEVA", "GENEVIEVE", "GEOFFREY", "GEORGE", "GEORGETTE", "GEORGIA", "GEORGINA", "GERALD", "GERALDINE",
+				"GERARD", "GERARDO", "GERI", "GERMAINE", "GERMAN", "GERRY", "GERTRUDE", "GILBERT", "GILBERTO", "GILDA",
+				"GINA", "GINGER", "GLADYS", "GLEN", "GLENDA", "GLENN", "GLENNA", "GLORIA", "GOLDIE", "GONZALO", "GORDON",
+				"GRACE", "GRACIE", "GRACIELA", "GRADY", "GRAHAM", "GRANT", "GREG", "GREGG", "GREGORIO", "GREGORY", "GRETA",
+				"GRETCHEN", "GROVER", "GUADALUPE", "GUILLERMO", "GUS", "GUSSIE", "GUSTAVO", "GUY", "GWEN", "GWENDOLYN",
+				"HAL", "HALEY", "HALLIE", "HANNAH", "HANS", "HARLAN", "HARLEY", "HAROLD", "HARRIET", "HARRIETT", "HARRIS",
+				"HARRISON", "HARRY", "HARVEY", "HATTIE", "HAZEL", "HEATH", "HEATHER", "HECTOR", "HEIDI", "HELEN", "HELENA",
+				"HELENE", "HELGA", "HENRIETTA", "HENRY", "HERBERT", "HERIBERTO", "HERMAN", "HERMINIA", "HESTER", "HILARY",
+				"HILDA", "HILLARY", "HIRAM", "HOLLIE", "HOLLIS", "HOLLY", "HOMER", "HOPE", "HORACE", "HOUSTON", "HOWARD",
+				"HUBERT", "HUGH", "HUGO", "HUMBERTO", "HUNG", "HUNTER", "IAN", "IDA", "IGNACIO", "ILA", "ILENE", "IMELDA",
+				"IMOGENE", "INA", "INES", "INEZ", "INGRID", "IRA", "IRENE", "IRIS", "IRMA", "IRVIN", "IRVING", "IRWIN",
+				"ISAAC", "ISABEL", "ISABELLA", "ISABELLE", "ISAIAH", "ISIDRO", "ISMAEL", "ISRAEL", "ISSAC", "IVA", "IVAN",
+				"IVY", "JACK", "JACKIE", "JACKLYN", "JACKSON", "JACLYN", "JACOB", "JACQUELINE", "JACQUELYN", "JACQUES",
+				"JADE", "JAIME", "JAKE", "JAMAL", "JAME", "JAMES", "JAMI", "JAMIE", "JAN", "JANA", "JANE", "JANELL",
+				"JANELLE", "JANET", "JANETTE", "JANICE", "JANIE", "JANINE", "JANIS", "JANNA", "JANNIE", "JARED", "JARROD",
+				"JARVIS", "JASMIN", "JASMINE", "JASON", "JASPER", "JAVIER", "JAY", "JAYNE", "JAYSON", "JEAN", "JEANETTE",
+				"JEANIE", "JEANINE", "JEANNE", "JEANNETTE", "JEANNIE", "JEANNINE", "JEFF", "JEFFERSON", "JEFFERY",
+				"JEFFREY", "JEFFRY", "JENIFER", "JENNA", "JENNIE", "JENNIFER", "JENNY", "JERALD", "JEREMIAH", "JEREMY",
+				"JERI", "JERMAINE", "JEROME", "JERRI", "JERRY", "JESS", "JESSE", "JESSICA", "JESSIE", "JESUS", "JEWEL",
+				"JEWELL", "JILL", "JILLIAN", "JIM", "JIMMIE", "JIMMY", "JO", "JOAN", "JOANN", "JOANNA", "JOANNE", "JOAQUIN",
+				"JOCELYN", "JODI", "JODIE", "JODY", "JOE", "JOEL", "JOESPH", "JOEY", "JOHANNA", "JOHN", "JOHNATHAN",
+				"JOHNATHON", "JOHNNIE", "JOHNNY", "JOLENE", "JON", "JONATHAN", "JONATHON", "JONI", "JORDAN", "JORGE",
+				"JOSE", "JOSEFA", "JOSEFINA", "JOSEPH", "JOSEPHINE", "JOSH", "JOSHUA", "JOSIE", "JOSUE", "JOY", "JOYCE",
+				"JUAN", "JUANA", "JUANITA", "JUDI", "JUDITH", "JUDY", "JULIA", "JULIAN", "JULIANA", "JULIANNE", "JULIE",
+				"JULIET", "JULIETTE", "JULIO", "JULIUS", "JUNE", "JUNIOR", "JUSTIN", "JUSTINA", "JUSTINE", "KAITLIN",
+				"KAITLYN", "KARA", "KAREN", "KARI", "KARIN", "KARINA", "KARL", "KARLA", "KARYN", "KASEY", "KATE", "KATELYN",
+				"KATHARINE", "KATHERINE", "KATHERYN", "KATHI", "KATHIE", "KATHLEEN", "KATHRINE", "KATHRYN", "KATHY",
+				"KATIE", "KATINA", "KATRINA", "KATY", "KAY", "KAYE", "KAYLA", "KEISHA", "KEITH", "KELLEY", "KELLI",
+				"KELLIE", "KELLY", "KELSEY", "KELVIN", "KEN", "KENDALL", "KENDRA", "KENDRICK", "KENNETH", "KENNY", "KENT",
+				"KENYA", "KERI", "KERMIT", "KERRI", "KERRY", "KEVIN", "KIM", "KIMBERLEE", "KIMBERLEY", "KIMBERLY", "KIRBY",
+				"KIRK", "KIRSTEN", "KITTY", "KRIS", "KRISTA", "KRISTEN", "KRISTI", "KRISTIE", "KRISTIN", "KRISTINA",
+				"KRISTINE", "KRISTOPHER", "KRISTY", "KRYSTAL", "KURT", "KURTIS", "KYLE", "LACEY", "LACY", "LADONNA",
+				"LAKEISHA", "LAKESHA", "LAKISHA", "LAMAR", "LAMONT", "LANA", "LANCE", "LANDON", "LANE", "LARA", "LARRY",
+				"LASHONDA", "LATANYA", "LATASHA", "LATISHA", "LATONYA", "LATOYA", "LAURA", "LAUREL", "LAUREN", "LAURENCE",
+				"LAURI", "LAURIE", "LAVERNE", "LAVONNE", "LAWANDA", "LAWRENCE", "LEA", "LEAH", "LEANN", "LEANNA", "LEANNE",
+				"LEE", "LEEANN", "LEIGH", "LEILA", "LELA", "LELAND", "LELIA", "LENA", "LENORA", "LENORE", "LEO", "LEOLA",
+				"LEON", "LEONA", "LEONARD", "LEONARDO", "LEONEL", "LEONOR", "LEROY", "LESA", "LESLEY", "LESLIE", "LESSIE",
+				"LESTER", "LETA", "LETHA", "LETICIA", "LETITIA", "LEVI", "LEWIS", "LIBBY", "LIDIA", "LILA", "LILIA",
+				"LILIAN", "LILIANA", "LILLIAN", "LILLIE", "LILLY", "LILY", "LINA", "LINCOLN", "LINDA", "LINDSAY", "LINDSEY",
+				"LINWOOD", "LIONEL", "LISA", "LIZ", "LIZA", "LIZZIE", "LLOYD", "LOGAN", "LOIS", "LOLA", "LOLITA", "LONNIE",
+				"LORA", "LORAINE", "LOREN", "LORENA", "LORENE", "LORENZO", "LORETTA", "LORI", "LORIE", "LORNA", "LORRAINE",
+				"LORRIE", "LOTTIE", "LOU", "LOUELLA", "LOUIE", "LOUIS", "LOUISA", "LOUISE", "LOURDES", "LOWELL", "LOYD",
+				"LUANN", "LUCAS", "LUCIA", "LUCILE", "LUCILLE", "LUCINDA", "LUCY", "LUELLA", "LUIS", "LUISA", "LUKE",
+				"LULA", "LUPE", "LUTHER", "LUZ", "LYDIA", "LYLE", "LYNDA", "LYNETTE", "LYNN", "LYNNE", "LYNNETTE", "MA",
+				"MABEL", "MABLE", "MACK", "MADELEINE", "MADELINE", "MADELYN", "MADGE", "MAE", "MAGDALENA", "MAGGIE", "MAI",
+				"MALCOLM", "MALINDA", "MALLORY", "MAMIE", "MANDY", "MANUEL", "MANUELA", "MARA", "MARC", "MARCEL",
+				"MARCELINO", "MARCELLA", "MARCI", "MARCIA", "MARCIE", "MARCO", "MARCOS", "MARCUS", "MARCY", "MARGARET",
+				"MARGARITA", "MARGERY", "MARGIE", "MARGO", "MARGOT", "MARGRET", "MARGUERITE", "MARI", "MARIA", "MARIAN",
+				"MARIANA", "MARIANNE", "MARIANO", "MARIBEL", "MARICELA", "MARIE", "MARIETTA", "MARILYN", "MARINA", "MARIO",
+				"MARION", "MARISA", "MARISOL", "MARISSA", "MARITZA", "MARJORIE", "MARK", "MARLA", "MARLENE", "MARLIN",
+				"MARLON", "MARQUITA", "MARSHA", "MARSHALL", "MARTA", "MARTHA", "MARTIN", "MARTINA", "MARTY", "MARVA",
+				"MARVIN", "MARY", "MARYANN", "MARYANNE", "MARYELLEN", "MARYLOU", "MASON", "MATHEW", "MATILDA", "MATT",
+				"MATTHEW", "MATTIE", "MAUDE", "MAURA", "MAUREEN", "MAURICE", "MAURICIO", "MAVIS", "MAX", "MAXINE",
+				"MAXWELL", "MAY", "MAYNARD", "MAYRA", "MEAGAN", "MEGAN", "MEGHAN", "MELANIE", "MELBA", "MELINDA", "MELISA",
+				"MELISSA", "MELLISA", "MELODY", "MELVA", "MELVIN", "MERCEDES", "MEREDITH", "MERLE", "MERLIN", "MERRILL",
+				"MIA", "MICAH", "MICHAEL", "MICHAELA", "MICHEAL", "MICHEL", "MICHELE", "MICHELL", "MICHELLE", "MICKEY",
+				"MIGUEL", "MIKE", "MILAGROS", "MILDRED", "MILES", "MILLARD", "MILLICENT", "MILLIE", "MILTON", "MINA",
+				"MINDY", "MINERVA", "MINNIE", "MIRANDA", "MIRIAM", "MISTY", "MITCHELL", "MITZI", "MOHAMMAD", "MOISES",
+				"MOLLIE", "MOLLY", "MONA", "MONICA", "MONIKA", "MONIQUE", "MONROE", "MONTE", "MONTY", "MORGAN", "MORRIS",
+				"MOSES", "MURIEL", "MURRAY", "MYRA", "MYRNA", "MYRON", "MYRTLE", "NADIA", "NADINE", "NAN", "NANCY",
+				"NANETTE", "NANNIE", "NAOMI", "NATALIA", "NATALIE", "NATASHA", "NATHAN", "NATHANIEL", "NEAL", "NED", "NEIL",
+				"NELDA", "NELL", "NELLIE", "NELLY", "NELSON", "NESTOR", "NETTIE", "NEVA", "NICHOLAS", "NICHOLE", "NICK",
+				"NICKOLAS", "NICOLAS", "NICOLE", "NIKKI", "NINA", "NITA", "NOAH", "NOE", "NOEL", "NOELLE", "NOEMI", "NOLA",
+				"NOLAN", "NONA", "NORA", "NORBERT", "NOREEN", "NORMA", "NORMAN", "NORRIS", "NUMBERS", "OCTAVIA", "OCTAVIO",
+				"ODELL", "ODESSA", "OFELIA", "OLA", "OLGA", "OLIVE", "OLIVER", "OLIVIA", "OLLIE", "OMAR", "OPAL", "OPHELIA",
+				"ORA", "ORLANDO", "ORVILLE", "OSCAR", "OTIS", "OTTO", "OWEN", "PABLO", "PAIGE", "PAM", "PAMALA", "PAMELA",
+				"PANSY", "PASQUALE", "PAT", "PATRICA", "PATRICE", "PATRICIA", "PATRICK", "PATSY", "PATTI", "PATTY", "PAUL",
+				"PAULA", "PAULETTE", "PAULINE", "PEARL", "PEARLIE", "PEDRO", "PEGGY", "PENELOPE", "PENNY", "PERCY", "PERRY",
+				"PETE", "PETER", "PETRA", "PHIL", "PHILIP", "PHILLIP", "PHOEBE", "PHYLLIS", "PIERRE", "POLLY", "PRESTON",
+				"PRISCILLA", "QUEEN", "QUENTIN", "QUINCY", "QUINTON", "RACHAEL", "RACHEL", "RACHELLE", "RAE", "RAFAEL",
+				"RALPH", "RAMIRO", "RAMON", "RAMONA", "RANDAL", "RANDALL", "RANDI", "RANDOLPH", "RANDY", "RAPHAEL",
+				"RAQUEL", "RAUL", "RAY", "RAYMOND", "RAYMUNDO", "REBA", "REBECCA", "REBEKAH", "REED", "REGGIE", "REGINA",
+				"REGINALD", "RENA", "RENAE", "RENE", "RENEE", "REUBEN", "REVA", "REX", "REYNA", "REYNALDO", "RHEA", "RHODA",
+				"RHONDA", "RICARDO", "RICHARD", "RICK", "RICKEY", "RICKIE", "RICKY", "RIGOBERTO", "RILEY", "RITA", "ROB",
+				"ROBBIE", "ROBBY", "ROBERT", "ROBERTA", "ROBERTO", "ROBIN", "ROBYN", "ROCCO", "ROCHELLE", "ROCIO", "ROCKY",
+				"ROD", "RODERICK", "RODGER", "RODNEY", "RODOLFO", "RODRIGO", "ROGELIO", "ROGER", "ROLAND", "ROLANDO",
+				"ROMAN", "ROMEO", "RON", "RONALD", "RONDA", "RONNIE", "ROOSEVELT", "RORY", "ROSA", "ROSALIA", "ROSALIE",
+				"ROSALIND", "ROSALINDA", "ROSALYN", "ROSANNA", "ROSANNE", "ROSARIO", "ROSCOE", "ROSE", "ROSEANN", "ROSELLA",
+				"ROSEMARIE", "ROSEMARY", "ROSETTA", "ROSIE", "ROSLYN", "ROSS", "ROWENA", "ROXANNE", "ROXIE", "ROY", "ROYCE",
+				"RUBEN", "RUBY", "RUDOLPH", "RUDY", "RUFUS", "RUSSEL", "RUSSELL", "RUSTY", "RUTH", "RUTHIE", "RYAN",
+				"SABRINA", "SADIE", "SALLIE", "SALLY", "SALVADOR", "SALVATORE", "SAM", "SAMANTHA", "SAMMIE", "SAMMY",
+				"SAMUEL", "SANDRA", "SANDY", "SANFORD", "SANTIAGO", "SANTOS", "SARA", "SARAH", "SASHA", "SAUL", "SAUNDRA",
+				"SAVANNAH", "SCOT", "SCOTT", "SCOTTY", "SEAN", "SEBASTIAN", "SELENA", "SELINA", "SELMA", "SERENA", "SERGIO",
+				"SETH", "SHANA", "SHANE", "SHANNA", "SHANNON", "SHARI", "SHARLENE", "SHARON", "SHARRON", "SHAUN", "SHAUNA",
+				"SHAWN", "SHAWNA", "SHEENA", "SHEILA", "SHELBY", "SHELDON", "SHELIA", "SHELLEY", "SHELLY", "SHELTON",
+				"SHEREE", "SHERI", "SHERMAN", "SHERRI", "SHERRIE", "SHERRY", "SHERYL", "SHIRLEY", "SIDNEY", "SIERRA",
+				"SILAS", "SILVIA", "SIMON", "SIMONE", "SOCORRO", "SOFIA", "SOLOMON", "SON", "SONDRA", "SONIA", "SONJA",
+				"SONNY", "SONYA", "SOPHIA", "SOPHIE", "SPENCER", "STACEY", "STACI", "STACIE", "STACY", "STAN", "STANLEY",
+				"STEFAN", "STEFANIE", "STELLA", "STEPHAN", "STEPHANIE", "STEPHEN", "STERLING", "STEVE", "STEVEN", "STEWART",
+				"STUART", "SUE", "SUMMER", "SUSAN", "SUSANA", "SUSANNA", "SUSANNE", "SUSIE", "SUZANNE", "SUZETTE", "SYBIL",
+				"SYDNEY", "SYLVESTER", "SYLVIA", "TABATHA", "TABITHA", "TAMARA", "TAMEKA", "TAMERA", "TAMI", "TAMIKA",
+				"TAMMI", "TAMMIE", "TAMMY", "TAMRA", "TANIA", "TANISHA", "TANYA", "TARA", "TASHA", "TAYLOR", "TED", "TEDDY",
+				"TERENCE", "TERESA", "TERI", "TERRA", "TERRANCE", "TERRELL", "TERRENCE", "TERRI", "TERRIE", "TERRY",
+				"TESSA", "THADDEUS", "THELMA", "THEODORE", "THERESA", "THERESE", "THERON", "THOMAS", "THURMAN", "TIA",
+				"TIFFANY", "TIM", "TIMMY", "TIMOTHY", "TINA", "TISHA", "TOBY", "TODD", "TOM", "TOMAS", "TOMMIE", "TOMMY",
+				"TONI", "TONIA", "TONY", "TONYA", "TORI", "TRACEY", "TRACI", "TRACIE", "TRACY", "TRAVIS", "TRENT",
+				"TRENTON", "TREVOR", "TRICIA", "TRINA", "TRISHA", "TRISTAN", "TROY", "TRUDY", "TRUMAN", "TWILA", "TY",
+				"TYLER", "TYRONE", "TYSON", "ULYSSES", "URSULA", "VALARIE", "VALERIA", "VALERIE", "VAN", "VANCE", "VANESSA",
+				"VAUGHN", "VELMA", "VERA", "VERN", "VERNA", "VERNON", "VERONICA", "VICENTE", "VICKI", "VICKIE", "VICKY",
+				"VICTOR", "VICTORIA", "VILMA", "VINCE", "VINCENT", "VIOLA", "VIOLET", "VIRGIE", "VIRGIL", "VIRGINIA",
+				"VITO", "VIVIAN", "VONDA", "WADE", "WALLACE", "WALTER", "WANDA", "WARD", "WARREN", "WAYNE", "WELDON",
+				"WENDELL", "WENDI", "WENDY", "WESLEY", "WHITNEY", "WILBERT", "WILBUR", "WILDA", "WILEY", "WILFORD",
+				"WILFRED", "WILFREDO", "WILL", "WILLA", "WILLARD", "WILLIAM", "WILLIAMS", "WILLIE", "WILLIS", "WILMA",
+				"WILMER", "WILSON", "WINFRED", "WINIFRED", "WINNIE", "WINSTON", "WM", "WOODROW", "XAVIER", "YESENIA",
+				"YOLANDA", "YOUNG", "YVETTE", "YVONNE", "ZACHARY", "ZACHERY", "ZELDA", "ZELMA" };
+	}
+
+	private static final String[] generateLastNames() {
+		return new String[] { "AARON", "ABBOTT", "ABEL", "ABELL", "ABERNATHY", "ABNER",
+				"ABNEY", "ABRAHAM", "ABRAMS", "ABREU", "ACEVEDO", "ACKER", "ACKERMAN", "ACKLEY", "ACOSTA", "ACUNA", "ADAIR",
+				"ADAM", "ADAME", "ADAMS", "ADAMSON", "ADCOCK", "ADDISON", "ADKINS", "ADLER", "AGEE", "AGNEW", "AGUAYO",
+				"AGUIAR", "AGUILAR", "AGUILERA", "AGUIRRE", "AHERN", "AHMAD", "AHMED", "AHRENS", "AIELLO", "AIKEN",
+				"AINSWORTH", "AKERS", "AKIN", "AKINS", "ALANIZ", "ALARCON", "ALBA", "ALBERS", "ALBERT", "ALBERTSON",
+				"ALBRECHT", "ALBRIGHT", "ALCALA", "ALCORN", "ALDERMAN", "ALDRICH", "ALDRIDGE", "ALEMAN", "ALEXANDER",
+				"ALFARO", "ALFONSO", "ALFORD", "ALFRED", "ALGER", "ALI", "ALICEA", "ALLAN", "ALLARD", "ALLEN", "ALLEY",
+				"ALLISON", "ALLMAN", "ALLRED", "ALMANZA", "ALMEIDA", "ALMOND", "ALONSO", "ALONZO", "ALSTON", "ALTMAN",
+				"ALVARADO", "ALVAREZ", "ALVES", "AMADOR", "AMARAL", "AMATO", "AMAYA", "AMBROSE", "AMES", "AMMONS", "AMOS",
+				"AMUNDSON", "ANAYA", "ANDERS", "ANDERSEN", "ANDERSON", "ANDRADE", "ANDRE", "ANDRES", "ANDREW", "ANDREWS",
+				"ANDRUS", "ANGEL", "ANGELO", "ANGLIN", "ANGULO", "ANTHONY", "ANTOINE", "ANTONIO", "APODACA", "APONTE",
+				"APPEL", "APPLE", "APPLEGATE", "APPLETON", "AQUINO", "ARAGON", "ARANDA", "ARAUJO", "ARCE", "ARCHER",
+				"ARCHIBALD", "ARCHIE", "ARCHULETA", "ARELLANO", "AREVALO", "ARIAS", "ARMENTA", "ARMIJO", "ARMSTEAD",
+				"ARMSTRONG", "ARNDT", "ARNETT", "ARNOLD", "ARREDONDO", "ARREOLA", "ARRIAGA", "ARRINGTON", "ARROYO",
+				"ARSENAULT", "ARTEAGA", "ARTHUR", "ARTIS", "ASBURY", "ASH", "ASHBY", "ASHCRAFT", "ASHE", "ASHER", "ASHFORD",
+				"ASHLEY", "ASHMORE", "ASHTON", "ASHWORTH", "ASKEW", "ATCHISON", "ATHERTON", "ATKINS", "ATKINSON", "ATWELL",
+				"ATWOOD", "AUGUST", "AUGUSTINE", "AULT", "AUSTIN", "AUTRY", "AVALOS", "AVERY", "AVILA", "AVILES", "AYALA",
+				"AYERS", "AYRES", "BABB", "BABCOCK", "BABIN", "BACA", "BACH", "BACHMAN", "BACK", "BACON", "BADER", "BADGER",
+				"BADILLO", "BAER", "BAEZ", "BAGGETT", "BAGLEY", "BAGWELL", "BAILEY", "BAIN", "BAINES", "BAIR", "BAIRD",
+				"BAKER", "BALDERAS", "BALDWIN", "BALES", "BALL", "BALLARD", "BANDA", "BANDY", "BANKS", "BANKSTON",
+				"BANNISTER", "BANUELOS", "BAPTISTE", "BARAJAS", "BARBA", "BARBEE", "BARBER", "BARBOSA", "BARBOUR",
+				"BARCLAY", "BARDEN", "BARELA", "BARFIELD", "BARGER", "BARHAM", "BARKER", "BARKLEY", "BARKSDALE", "BARLOW",
+				"BARNARD", "BARNES", "BARNETT", "BARNETTE", "BARNEY", "BARNHART", "BARNHILL", "BARON", "BARONE", "BARR",
+				"BARRAZA", "BARRERA", "BARRETO", "BARRETT", "BARRIENTOS", "BARRIOS", "BARRON", "BARROW", "BARROWS", "BARRY",
+				"BARTELS", "BARTH", "BARTHOLOMEW", "BARTLETT", "BARTLEY", "BARTON", "BASHAM", "BASKIN", "BASS", "BASSETT",
+				"BATCHELOR", "BATEMAN", "BATES", "BATISTA", "BATISTE", "BATSON", "BATTAGLIA", "BATTEN", "BATTLE", "BATTLES",
+				"BATTS", "BAUER", "BAUGH", "BAUGHMAN", "BAUM", "BAUMAN", "BAUMANN", "BAUMGARDNER", "BAUMGARTNER",
+				"BAUTISTA", "BAXLEY", "BAXTER", "BAYER", "BAYLOR", "BAYNE", "BAYS", "BEACH", "BEAL", "BEALE", "BEALL",
+				"BEALS", "BEAM", "BEAMON", "BEAN", "BEANE", "BEAR", "BEARD", "BEARDEN", "BEASLEY", "BEATTIE", "BEATTY",
+				"BEATY", "BEAUCHAMP", "BEAUDOIN", "BEAULIEU", "BEAUREGARD", "BEAVER", "BEAVERS", "BECERRA", "BECK",
+				"BECKER", "BECKETT", "BECKHAM", "BECKMAN", "BECKWITH", "BECNEL", "BEDARD", "BEDFORD", "BEEBE", "BEELER",
+				"BEERS", "BEESON", "BEGAY", "BEGLEY", "BEHRENS", "BELANGER", "BELCHER", "BELL", "BELLAMY", "BELLO", "BELT",
+				"BELTON", "BELTRAN", "BENAVIDES", "BENAVIDEZ", "BENDER", "BENEDICT", "BENEFIELD", "BENITEZ", "BENJAMIN",
+				"BENNER", "BENNETT", "BENOIT", "BENSON", "BENTLEY", "BENTON", "BERG", "BERGER", "BERGERON", "BERGMAN",
+				"BERGSTROM", "BERLIN", "BERMAN", "BERMUDEZ", "BERNAL", "BERNARD", "BERNHARDT", "BERNIER", "BERNSTEIN",
+				"BERRIOS", "BERRY", "BERRYMAN", "BERTRAM", "BERTRAND", "BERUBE", "BESS", "BEST", "BETANCOURT", "BETHEA",
+				"BETHEL", "BETTS", "BETZ", "BEVERLY", "BEVINS", "BEYER", "BIBLE", "BICKFORD", "BIDDLE", "BIGELOW", "BIGGS",
+				"BILLINGS", "BILLINGSLEY", "BILLIOT", "BILLS", "BILLUPS", "BILODEAU", "BINDER", "BINGHAM", "BINKLEY",
+				"BIRCH", "BIRD", "BISHOP", "BISSON", "BITTNER", "BIVENS", "BIVINS", "BLACK", "BLACKBURN", "BLACKMAN",
+				"BLACKMON", "BLACKWELL", "BLACKWOOD", "BLAINE", "BLAIR", "BLAIS", "BLAKE", "BLAKELY", "BLALOCK",
+				"BLANCHARD", "BLANCHETTE", "BLANCO", "BLAND", "BLANK", "BLANKENSHIP", "BLANTON", "BLAYLOCK", "BLEDSOE",
+				"BLEVINS", "BLISS", "BLOCK", "BLOCKER", "BLODGETT", "BLOOM", "BLOUNT", "BLUE", "BLUM", "BLUNT", "BLYTHE",
+				"BOATRIGHT", "BOATWRIGHT", "BOBBITT", "BOBO", "BOCK", "BOEHM", "BOETTCHER", "BOGAN", "BOGGS", "BOHANNON",
+				"BOHN", "BOISVERT", "BOLAND", "BOLDEN", "BOLDUC", "BOLEN", "BOLES", "BOLIN", "BOLING", "BOLLING",
+				"BOLLINGER", "BOLT", "BOLTON", "BOND", "BONDS", "BONE", "BONILLA", "BONNER", "BOOKER", "BOONE", "BOOTH",
+				"BOOTHE", "BORDELON", "BORDEN", "BORDERS", "BOREN", "BORGES", "BORREGO", "BOSS", "BOSTIC", "BOSTICK",
+				"BOSTON", "BOSWELL", "BOTTOMS", "BOUCHARD", "BOUCHER", "BOUDREAU", "BOUDREAUX", "BOUNDS", "BOURGEOIS",
+				"BOURNE", "BOURQUE", "BOWDEN", "BOWEN", "BOWENS", "BOWER", "BOWERS", "BOWIE", "BOWLES", "BOWLIN", "BOWLING",
+				"BOWMAN", "BOWSER", "BOX", "BOYCE", "BOYD", "BOYER", "BOYKIN", "BOYLE", "BOYLES", "BOYNTON", "BOZEMAN",
+				"BRACKEN", "BRACKETT", "BRADBURY", "BRADEN", "BRADFORD", "BRADLEY", "BRADSHAW", "BRADY", "BRAGG", "BRANCH",
+				"BRAND", "BRANDENBURG", "BRANDON", "BRANDT", "BRANHAM", "BRANNON", "BRANSON", "BRANT", "BRANTLEY",
+				"BRASWELL", "BRATCHER", "BRATTON", "BRAUN", "BRAVO", "BRAXTON", "BRAY", "BRAZIL", "BREAUX", "BREEDEN",
+				"BREEDLOVE", "BREEN", "BRENNAN", "BRENNER", "BRENT", "BREWER", "BREWSTER", "BRICE", "BRIDGES", "BRIGGS",
+				"BRIGHT", "BRILEY", "BRILL", "BRIM", "BRINK", "BRINKLEY", "BRINKMAN", "BRINSON", "BRIONES", "BRISCOE",
+				"BRISENO", "BRITO", "BRITT", "BRITTAIN", "BRITTON", "BROADNAX", "BROADWAY", "BROCK", "BROCKMAN",
+				"BRODERICK", "BRODY", "BROGAN", "BRONSON", "BROOKINS", "BROOKS", "BROOME", "BROTHERS", "BROUGHTON",
+				"BROUSSARD", "BROWDER", "BROWER", "BROWN", "BROWNE", "BROWNELL", "BROWNING", "BROWNLEE", "BROYLES",
+				"BRUBAKER", "BRUCE", "BRUMFIELD", "BRUNER", "BRUNNER", "BRUNO", "BRUNS", "BRUNSON", "BRUTON", "BRYAN",
+				"BRYANT", "BRYSON", "BUCHANAN", "BUCHER", "BUCK", "BUCKINGHAM", "BUCKLEY", "BUCKNER", "BUENO", "BUFFINGTON",
+				"BUFORD", "BUI", "BULL", "BULLARD", "BULLOCK", "BUMGARNER", "BUNCH", "BUNDY", "BUNKER", "BUNN", "BUNNELL",
+				"BUNTING", "BURCH", "BURCHETT", "BURCHFIELD", "BURDEN", "BURDETTE", "BURDICK", "BURGE", "BURGER", "BURGESS",
+				"BURGOS", "BURK", "BURKE", "BURKETT", "BURKHART", "BURKHOLDER", "BURKS", "BURLESON", "BURLEY", "BURNETT",
+				"BURNETTE", "BURNEY", "BURNHAM", "BURNS", "BURNSIDE", "BURR", "BURRELL", "BURRIS", "BURROUGHS", "BURROW",
+				"BURROWS", "BURT", "BURTON", "BUSBY", "BUSCH", "BUSH", "BUSS", "BUSSEY", "BUSTAMANTE", "BUSTOS", "BUTCHER",
+				"BUTLER", "BUTTERFIELD", "BUTTON", "BUTTS", "BUXTON", "BYARS", "BYERS", "BYNUM", "BYRD", "BYRNE", "BYRNES",
+				"CABALLERO", "CABAN", "CABLE", "CABRAL", "CABRERA", "CADE", "CADY", "CAGLE", "CAHILL", "CAIN", "CALABRESE",
+				"CALDERON", "CALDWELL", "CALHOUN", "CALKINS", "CALL", "CALLAGHAN", "CALLAHAN", "CALLAWAY", "CALLENDER",
+				"CALLOWAY", "CALVERT", "CALVIN", "CAMACHO", "CAMARILLO", "CAMBELL", "CAMERON", "CAMP", "CAMPBELL", "CAMPOS",
+				"CANADA", "CANADY", "CANALES", "CANDELARIA", "CANFIELD", "CANNON", "CANO", "CANTRELL", "CANTU", "CANTWELL",
+				"CANTY", "CAPPS", "CARABALLO", "CARAWAY", "CARBAJAL", "CARBONE", "CARD", "CARDEN", "CARDENAS", "CARDER",
+				"CARDONA", "CARDOZA", "CARDWELL", "CAREY", "CARL", "CARLIN", "CARLISLE", "CARLOS", "CARLSON", "CARLTON",
+				"CARMAN", "CARMICHAEL", "CARMONA", "CARNAHAN", "CARNES", "CARNEY", "CARO", "CARON", "CARPENTER", "CARR",
+				"CARRANZA", "CARRASCO", "CARRERA", "CARRICO", "CARRIER", "CARRILLO", "CARRINGTON", "CARRION", "CARROLL",
+				"CARSON", "CARSWELL", "CARTER", "CARTWRIGHT", "CARUSO", "CARVALHO", "CARVER", "CARY", "CASAS", "CASE",
+				"CASEY", "CASH", "CASILLAS", "CASKEY", "CASON", "CASPER", "CASS", "CASSELL", "CASSIDY", "CASTANEDA",
+				"CASTEEL", "CASTELLANO", "CASTELLANOS", "CASTILLO", "CASTLE", "CASTLEBERRY", "CASTRO", "CASWELL",
+				"CATALANO", "CATES", "CATHEY", "CATO", "CATRON", "CAUDILL", "CAUDLE", "CAUSEY", "CAVANAUGH", "CAVAZOS",
+				"CAVE", "CECIL", "CENTENO", "CERDA", "CERVANTES", "CHACON", "CHADWICK", "CHAFFIN", "CHALMERS",
+				"CHAMBERLAIN", "CHAMBERLIN", "CHAMBERS", "CHAMBLISS", "CHAMPAGNE", "CHAMPION", "CHAN", "CHANCE", "CHANDLER",
+				"CHANEY", "CHANG", "CHAPA", "CHAPIN", "CHAPMAN", "CHAPPELL", "CHARLES", "CHARLTON", "CHASE", "CHASTAIN",
+				"CHATMAN", "CHAU", "CHAVARRIA", "CHAVES", "CHAVEZ", "CHAVIS", "CHEATHAM", "CHEEK", "CHEN", "CHENEY",
+				"CHENG", "CHERRY", "CHESSER", "CHESTER", "CHESTNUT", "CHEUNG", "CHEW", "CHILD", "CHILDERS", "CHILDRESS",
+				"CHILDS", "CHILTON", "CHIN", "CHISHOLM", "CHISM", "CHISOLM", "CHITWOOD", "CHO", "CHOATE", "CHOI", "CHONG",
+				"CHOW", "CHRISTENSEN", "CHRISTENSON", "CHRISTIAN", "CHRISTIANSEN", "CHRISTIANSON", "CHRISTIE", "CHRISTMAN",
+				"CHRISTMAS", "CHRISTOPHER", "CHRISTY", "CHU", "CHUN", "CHUNG", "CHURCH", "CHURCHILL", "CINTRON", "CISNEROS",
+				"CLANCY", "CLANTON", "CLAPP", "CLARK", "CLARKE", "CLARKSON", "CLARY", "CLAUSEN", "CLAWSON", "CLAY",
+				"CLAYTON", "CLEARY", "CLEGG", "CLEM", "CLEMENS", "CLEMENT", "CLEMENTS", "CLEMMONS", "CLEMONS", "CLEVELAND",
+				"CLEVENGER", "CLICK", "CLIFFORD", "CLIFTON", "CLINE", "CLINTON", "CLOSE", "CLOUD", "CLOUGH", "CLOUTIER",
+				"COATES", "COATS", "COBB", "COBBS", "COBLE", "COBURN", "COCHRAN", "COCHRANE", "COCKRELL", "CODY", "COE",
+				"COFFEY", "COFFIN", "COFFMAN", "COGGINS", "COHEN", "COHN", "COKER", "COLBERT", "COLBURN", "COLBY", "COLE",
+				"COLEMAN", "COLES", "COLEY", "COLLADO", "COLLAZO", "COLLEY", "COLLIER", "COLLINS", "COLON", "COLSON",
+				"COLVIN", "COLWELL", "COMBS", "COMEAUX", "COMER", "COMPTON", "COMSTOCK", "CONAWAY", "CONCEPCION", "CONDON",
+				"CONE", "CONGER", "CONKLIN", "CONLEY", "CONN", "CONNELL", "CONNELLY", "CONNER", "CONNERS", "CONNOLLY",
+				"CONNOR", "CONNORS", "CONOVER", "CONRAD", "CONROY", "CONTE", "CONTI", "CONTRERAS", "CONWAY", "CONYERS",
+				"COOK", "COOKE", "COOKS", "COOKSEY", "COOLEY", "COOMBS", "COON", "COONEY", "COONS", "COOPER", "COPE",
+				"COPELAND", "COPLEY", "COPPOLA", "CORBETT", "CORBIN", "CORBITT", "CORCORAN", "CORDELL", "CORDERO",
+				"CORDOVA", "COREY", "CORLEY", "CORMIER", "CORNELIUS", "CORNELL", "CORNETT", "CORNISH", "CORNWELL", "CORONA",
+				"CORONADO", "CORRAL", "CORREA", "CORREIA", "CORRIGAN", "CORTES", "CORTEZ", "CORWIN", "COSBY", "COSGROVE",
+				"COSTA", "COSTELLO", "COTA", "COTE", "COTHRAN", "COTTER", "COTTON", "COTTRELL", "COUCH", "COUGHLIN",
+				"COULTER", "COUNCIL", "COUNTS", "COURTNEY", "COUSINS", "COUTURE", "COVERT", "COVEY", "COVINGTON", "COWAN",
+				"COWARD", "COWART", "COWELL", "COWLES", "COWLEY", "COX", "COY", "COYLE", "COYNE", "CRABTREE", "CRADDOCK",
+				"CRAFT", "CRAIG", "CRAIN", "CRAMER", "CRANDALL", "CRANE", "CRANFORD", "CRAVEN", "CRAWFORD", "CRAWLEY",
+				"CRAYTON", "CREAMER", "CREECH", "CREEL", "CREIGHTON", "CRENSHAW", "CRESPO", "CREWS", "CRIDER", "CRISP",
+				"CRIST", "CRISWELL", "CRITTENDEN", "CROCKER", "CROCKETT", "CROFT", "CROMER", "CROMWELL", "CRONIN", "CROOK",
+				"CROOKS", "CROSBY", "CROSS", "CROTEAU", "CROUCH", "CROUSE", "CROW", "CROWDER", "CROWE", "CROWELL",
+				"CROWLEY", "CRUM", "CRUMP", "CRUSE", "CRUTCHER", "CRUTCHFIELD", "CRUZ", "CUELLAR", "CUEVAS", "CULBERTSON",
+				"CULLEN", "CULP", "CULPEPPER", "CULVER", "CUMMINGS", "CUMMINS", "CUNNINGHAM", "CUPP", "CURLEY", "CURRAN",
+				"CURRIE", "CURRIER", "CURRY", "CURTIN", "CURTIS", "CUSHMAN", "CUSTER", "CUTLER", "CYR", "DABNEY", "DAHL",
+				"DAIGLE", "DAILEY", "DAILY", "DALE", "DALEY", "DALLAS", "DALTON", "DALY", "DAMICO", "DAMON", "DAMRON",
+				"DANCY", "DANG", "DANGELO", "DANIEL", "DANIELS", "DANIELSON", "DANNER", "DARBY", "DARDEN", "DARLING",
+				"DARNELL", "DASILVA", "DAUGHERTY", "DAUGHTRY", "DAVENPORT", "DAVID", "DAVIDSON", "DAVIES", "DAVILA",
+				"DAVIS", "DAVISON", "DAWKINS", "DAWSON", "DAY", "DAYTON", "DEAL", "DEAN", "DEATON", "DEBERRY", "DECKER",
+				"DEES", "DEHART", "DEJESUS", "DELACRUZ", "DELAGARZA", "DELANEY", "DELAROSA", "DELATORRE", "DELEON",
+				"DELGADILLO", "DELGADO", "DELL", "DELLINGER", "DELOACH", "DELONG", "DELOSSANTOS", "DELUCA", "DELVALLE",
+				"DEMARCO", "DEMERS", "DEMPSEY", "DENHAM", "DENNEY", "DENNING", "DENNIS", "DENNISON", "DENNY", "DENSON",
+				"DENT", "DENTON", "DEROSA", "DERR", "DERRICK", "DESANTIS", "DESIMONE", "DEVINE", "DEVITO", "DEVLIN",
+				"DEVORE", "DEVRIES", "DEW", "DEWEY", "DEWITT", "DEXTER", "DIAL", "DIAMOND", "DIAS", "DIAZ", "DICK",
+				"DICKENS", "DICKERSON", "DICKEY", "DICKINSON", "DICKSON", "DIEHL", "DIETRICH", "DIETZ", "DIGGS", "DILL",
+				"DILLARD", "DILLON", "DINKINS", "DION", "DIX", "DIXON", "DO", "DOAN", "DOBBINS", "DOBBS", "DOBSON",
+				"DOCKERY", "DODD", "DODDS", "DODGE", "DODSON", "DOE", "DOHERTY", "DOLAN", "DOLL", "DOLLAR", "DOMINGO",
+				"DOMINGUEZ", "DOMINQUEZ", "DONAHUE", "DONALD", "DONALDSON", "DONATO", "DONNELL", "DONNELLY", "DONOHUE",
+				"DONOVAN", "DOOLEY", "DOOLITTLE", "DORAN", "DORMAN", "DORN", "DORRIS", "DORSEY", "DORTCH", "DOSS", "DOTSON",
+				"DOTY", "DOUCETTE", "DOUGHERTY", "DOUGHTY", "DOUGLAS", "DOUGLASS", "DOVE", "DOVER", "DOW", "DOWD", "DOWDY",
+				"DOWELL", "DOWLING", "DOWNEY", "DOWNING", "DOWNS", "DOYLE", "DOZIER", "DRAKE", "DRAPER", "DRAYTON", "DREW",
+				"DRISCOLL", "DRIVER", "DRUMMOND", "DRURY", "DUARTE", "DUBE", "DUBOIS", "DUBOSE", "DUCKETT", "DUCKWORTH",
+				"DUDLEY", "DUFF", "DUFFY", "DUGAN", "DUGAS", "DUGGAN", "DUGGER", "DUKE", "DUKES", "DUMAS", "DUMONT",
+				"DUNAWAY", "DUNBAR", "DUNCAN", "DUNHAM", "DUNLAP", "DUNN", "DUNNE", "DUNNING", "DUONG", "DUPONT", "DUPRE",
+				"DUPREE", "DUPUIS", "DURAN", "DURAND", "DURANT", "DURBIN", "DURDEN", "DURHAM", "DURKIN", "DURR", "DUTTON",
+				"DUVAL", "DUVALL", "DWYER", "DYE", "DYER", "DYKES", "DYSON", "EAGLE", "EARL", "EARLE", "EARLEY", "EARLS",
+				"EARLY", "EARNEST", "EASLEY", "EASON", "EAST", "EASTER", "EASTERLING", "EASTMAN", "EASTON", "EATON",
+				"EAVES", "EBERT", "ECHEVARRIA", "ECHOLS", "ECKERT", "EDDY", "EDGAR", "EDGE", "EDMOND", "EDMONDS",
+				"EDMONDSON", "EDWARD", "EDWARDS", "EGAN", "EGGLESTON", "ELAM", "ELDER", "ELDRIDGE", "ELIAS", "ELIZONDO",
+				"ELKINS", "ELLER", "ELLINGTON", "ELLIOT", "ELLIOTT", "ELLIS", "ELLISON", "ELLSWORTH", "ELMORE", "ELROD",
+				"ELSTON", "ELY", "EMANUEL", "EMBRY", "EMERSON", "EMERY", "EMMONS", "ENG", "ENGEL", "ENGLAND", "ENGLE",
+				"ENGLISH", "ENNIS", "ENOS", "ENRIGHT", "ENRIQUEZ", "EPPERSON", "EPPS", "EPSTEIN", "ERDMANN", "ERICKSON",
+				"ERNST", "ERVIN", "ERWIN", "ESCALANTE", "ESCAMILLA", "ESCOBAR", "ESCOBEDO", "ESPARZA", "ESPINAL", "ESPINO",
+				"ESPINOSA", "ESPINOZA", "ESPOSITO", "ESQUIVEL", "ESTEP", "ESTES", "ESTRADA", "ESTRELLA", "ETHERIDGE",
+				"ETHRIDGE", "EUBANKS", "EVANS", "EVERETT", "EVERHART", "EVERS", "EVERSON", "EWING", "EZELL", "FABER",
+				"FABIAN", "FAGAN", "FAHEY", "FAIN", "FAIR", "FAIRBANKS", "FAIRCHILD", "FAIRLEY", "FAISON", "FAJARDO",
+				"FALCON", "FALK", "FALLON", "FALLS", "FANNING", "FARIAS", "FARLEY", "FARMER", "FARNSWORTH", "FARR",
+				"FARRAR", "FARRELL", "FARRINGTON", "FARRIS", "FARROW", "FAULK", "FAULKNER", "FAUST", "FAY", "FEENEY",
+				"FELDER", "FELDMAN", "FELICIANO", "FELIX", "FELLOWS", "FELTON", "FELTS", "FENNELL", "FENNER", "FENTON",
+				"FERGUSON", "FERNANDES", "FERNANDEZ", "FERRARA", "FERRARI", "FERRARO", "FERREIRA", "FERRELL", "FERRER",
+				"FERRIS", "FERRY", "FIELD", "FIELDER", "FIELDS", "FIERRO", "FIFE", "FIGUEROA", "FINCH", "FINCHER",
+				"FINDLEY", "FINE", "FINK", "FINLEY", "FINN", "FINNEGAN", "FINNEY", "FIORE", "FISCHER", "FISH", "FISHER",
+				"FISHMAN", "FISK", "FITCH", "FITE", "FITTS", "FITZGERALD", "FITZPATRICK", "FITZSIMMONS", "FLAGG",
+				"FLAHERTY", "FLANAGAN", "FLANDERS", "FLANIGAN", "FLANNERY", "FLECK", "FLEMING", "FLEMMING", "FLETCHER",
+				"FLINT", "FLOOD", "FLORA", "FLORENCE", "FLORES", "FLOREZ", "FLOURNOY", "FLOWERS", "FLOYD", "FLYNN",
+				"FOGARTY", "FOGG", "FOGLE", "FOLEY", "FOLSE", "FOLSOM", "FOLTZ", "FONG", "FONSECA", "FONTAINE", "FONTENOT",
+				"FOOTE", "FORBES", "FORD", "FOREMAN", "FOREST", "FORET", "FORMAN", "FORNEY", "FORREST", "FORRESTER",
+				"FORSTER", "FORSYTH", "FORSYTHE", "FORT", "FORTE", "FORTENBERRY", "FORTIER", "FORTIN", "FORTNER", "FORTUNE",
+				"FOSS", "FOSTER", "FOUNTAIN", "FOURNIER", "FOUST", "FOWLER", "FOX", "FOY", "FRALEY", "FRAME", "FRANCE",
+				"FRANCIS", "FRANCISCO", "FRANCO", "FRANCOIS", "FRANK", "FRANKLIN", "FRANKS", "FRANTZ", "FRANZ", "FRASER",
+				"FRASIER", "FRAZER", "FRAZIER", "FREDERICK", "FREDERICKS", "FREDRICK", "FREDRICKSON", "FREE", "FREED",
+				"FREEDMAN", "FREEMAN", "FREESE", "FREITAS", "FRENCH", "FREUND", "FREY", "FRIAS", "FRICK", "FRIEDMAN",
+				"FRIEND", "FRIERSON", "FRIES", "FRITZ", "FRIZZELL", "FROST", "FRY", "FRYE", "FRYER", "FUCHS", "FUENTES",
+				"FUGATE", "FULCHER", "FULLER", "FULLERTON", "FULMER", "FULTON", "FULTZ", "FUNDERBURK", "FUNK", "FUQUA",
+				"FURMAN", "FURR", "FUSCO", "GABLE", "GABRIEL", "GADDIS", "GADDY", "GAFFNEY", "GAGE", "GAGNE", "GAGNON",
+				"GAINES", "GAINEY", "GAITHER", "GALARZA", "GALBRAITH", "GALE", "GALINDO", "GALLAGHER", "GALLANT",
+				"GALLARDO", "GALLEGOS", "GALLO", "GALLOWAY", "GALVAN", "GALVEZ", "GALVIN", "GAMBLE", "GAMBOA", "GAMEZ",
+				"GANDY", "GANN", "GANNON", "GANT", "GANTT", "GARAY", "GARBER", "GARCIA", "GARDINER", "GARDNER", "GARLAND",
+				"GARMON", "GARNER", "GARNETT", "GARRETT", "GARRIS", "GARRISON", "GARVEY", "GARVIN", "GARY", "GARZA",
+				"GASKIN", "GASKINS", "GASS", "GASTON", "GATES", "GATEWOOD", "GATLIN", "GAULT", "GAUTHIER", "GAVIN", "GAY",
+				"GAYLORD", "GEARY", "GEE", "GEER", "GEIGER", "GENTILE", "GENTRY", "GEORGE", "GERALD", "GERARD", "GERBER",
+				"GERMAN", "GETZ", "GIBBONS", "GIBBS", "GIBSON", "GIFFORD", "GIL", "GILBERT", "GILBERTSON", "GILBREATH",
+				"GILCHRIST", "GILES", "GILL", "GILLEN", "GILLESPIE", "GILLETTE", "GILLEY", "GILLIAM", "GILLILAND", "GILLIS",
+				"GILMAN", "GILMER", "GILMORE", "GILSON", "GINN", "GIORDANO", "GIPSON", "GIRARD", "GIRON", "GIROUX", "GIST",
+				"GIVENS", "GLADDEN", "GLADNEY", "GLASER", "GLASGOW", "GLASS", "GLAZE", "GLEASON", "GLENN", "GLOVER",
+				"GLYNN", "GOAD", "GOBLE", "GODDARD", "GODFREY", "GODINEZ", "GODWIN", "GOEBEL", "GOETZ", "GOFF", "GOFORTH",
+				"GOINS", "GOLD", "GOLDBERG", "GOLDEN", "GOLDMAN", "GOLDSMITH", "GOLDSTEIN", "GOMES", "GOMEZ", "GONSALVES",
+				"GONZALES", "GONZALEZ", "GOOCH", "GOOD", "GOODE", "GOODEN", "GOODIN", "GOODING", "GOODMAN", "GOODRICH",
+				"GOODSON", "GOODWIN", "GOOLSBY", "GORDON", "GORE", "GORHAM", "GORMAN", "GOSS", "GOSSETT", "GOUGH", "GOULD",
+				"GOULET", "GRACE", "GRACIA", "GRADY", "GRAF", "GRAFF", "GRAGG", "GRAHAM", "GRANADOS", "GRANGER", "GRANT",
+				"GRANTHAM", "GRAVES", "GRAY", "GRAYSON", "GREATHOUSE", "GRECO", "GREEN", "GREENBERG", "GREENE",
+				"GREENFIELD", "GREENLEE", "GREENWOOD", "GREER", "GREGG", "GREGORY", "GREINER", "GRENIER", "GRESHAM", "GREY",
+				"GRICE", "GRIDER", "GRIER", "GRIFFIN", "GRIFFIS", "GRIFFITH", "GRIFFITHS", "GRIGGS", "GRIGSBY", "GRIMES",
+				"GRIMM", "GRISHAM", "GRISSOM", "GRISWOLD", "GROCE", "GROGAN", "GROOMS", "GROSS", "GROSSMAN", "GROVE",
+				"GROVER", "GROVES", "GRUBB", "GRUBBS", "GRUBER", "GUAJARDO", "GUENTHER", "GUERIN", "GUERRA", "GUERRERO",
+				"GUESS", "GUEST", "GUEVARA", "GUFFEY", "GUIDRY", "GUILLEN", "GUILLORY", "GUINN", "GULLEY", "GUNDERSON",
+				"GUNN", "GUNTER", "GUNTHER", "GURLEY", "GUSTAFSON", "GUTHRIE", "GUTIERREZ", "GUY", "GUYTON", "GUZMAN", "HA",
+				"HAAG", "HAAS", "HAASE", "HACKER", "HACKETT", "HACKNEY", "HADDEN", "HADLEY", "HAGAN", "HAGEN", "HAGER",
+				"HAGGARD", "HAGGERTY", "HAHN", "HAIGHT", "HAILEY", "HAINES", "HAIR", "HAIRSTON", "HALCOMB", "HALE", "HALES",
+				"HALEY", "HALL", "HALLER", "HALLMAN", "HALSEY", "HALSTEAD", "HALVERSON", "HAM", "HAMBLIN", "HAMBY", "HAMEL",
+				"HAMER", "HAMILTON", "HAMLIN", "HAMM", "HAMMER", "HAMMETT", "HAMMOND", "HAMMONDS", "HAMMONS", "HAMPTON",
+				"HAMRICK", "HAN", "HANCOCK", "HAND", "HANDLEY", "HANDY", "HANES", "HANEY", "HANKINS", "HANKS", "HANLEY",
+				"HANLON", "HANNA", "HANNAH", "HANNAN", "HANNON", "HANSEN", "HANSON", "HARBIN", "HARDAWAY", "HARDEE",
+				"HARDEN", "HARDER", "HARDESTY", "HARDIN", "HARDING", "HARDISON", "HARDMAN", "HARDWICK", "HARDY", "HARE",
+				"HARGIS", "HARGRAVE", "HARGROVE", "HARKINS", "HARLAN", "HARLEY", "HARLOW", "HARMAN", "HARMON", "HARMS",
+				"HARNESS", "HARP", "HARPER", "HARR", "HARRELL", "HARRINGTON", "HARRIS", "HARRISON", "HARRY", "HART",
+				"HARTER", "HARTLEY", "HARTMAN", "HARTMANN", "HARTWELL", "HARVEY", "HARWELL", "HARWOOD", "HASKELL",
+				"HASKINS", "HASS", "HASSELL", "HASTINGS", "HATCH", "HATCHER", "HATCHETT", "HATFIELD", "HATHAWAY", "HATLEY",
+				"HATTON", "HAUGEN", "HAUSER", "HAVENS", "HAWES", "HAWK", "HAWKINS", "HAWKS", "HAWLEY", "HAWTHORNE", "HAY",
+				"HAYDEN", "HAYES", "HAYNES", "HAYS", "HAYWARD", "HAYWOOD", "HAZEL", "HEAD", "HEADLEY", "HEADRICK", "HEALEY",
+				"HEALY", "HEARD", "HEARN", "HEATH", "HEATON", "HEBERT", "HECK", "HECKMAN", "HEDGES", "HEDRICK", "HEFFNER",
+				"HEFLIN", "HEFNER", "HEIM", "HEIN", "HEINRICH", "HEINZ", "HELD", "HELLER", "HELM", "HELMS", "HELTON",
+				"HEMBREE", "HEMPHILL", "HENDERSON", "HENDON", "HENDRICK", "HENDRICKS", "HENDRICKSON", "HENDRIX", "HENKE",
+				"HENLEY", "HENNESSEY", "HENNING", "HENRY", "HENSLEY", "HENSON", "HER", "HERBERT", "HEREDIA", "HERMAN",
+				"HERMANN", "HERNANDEZ", "HERNDON", "HERR", "HERRERA", "HERRICK", "HERRIN", "HERRING", "HERRINGTON",
+				"HERRMANN", "HERRON", "HERSHBERGER", "HERZOG", "HESS", "HESTER", "HEWITT", "HEYWARD", "HIATT", "HIBBARD",
+				"HICKEY", "HICKMAN", "HICKS", "HICKSON", "HIDALGO", "HIGDON", "HIGGINBOTHAM", "HIGGINS", "HIGGS", "HIGH",
+				"HIGHTOWER", "HILDEBRAND", "HILDRETH", "HILL", "HILLARD", "HILLER", "HILLIARD", "HILLMAN", "HILLS",
+				"HILTON", "HIMES", "HINDMAN", "HINDS", "HINES", "HINKLE", "HINOJOSA", "HINSON", "HINTON", "HIRSCH",
+				"HITCHCOCK", "HITE", "HITT", "HO", "HOANG", "HOBBS", "HOBSON", "HODGE", "HODGES", "HODGSON", "HOFF",
+				"HOFFMAN", "HOFFMANN", "HOGAN", "HOGG", "HOGUE", "HOKE", "HOLBROOK", "HOLCOMB", "HOLCOMBE", "HOLDEN",
+				"HOLDER", "HOLGUIN", "HOLIDAY", "HOLLAND", "HOLLENBECK", "HOLLEY", "HOLLIDAY", "HOLLINGSWORTH", "HOLLINS",
+				"HOLLIS", "HOLLOMAN", "HOLLOWAY", "HOLLY", "HOLM", "HOLMAN", "HOLMES", "HOLT", "HOLTON", "HOLTZ", "HOMAN",
+				"HOMER", "HONEYCUTT", "HONG", "HOOD", "HOOK", "HOOKER", "HOOKS", "HOOPER", "HOOVER", "HOPE", "HOPKINS",
+				"HOPPE", "HOPPER", "HOPSON", "HORAN", "HORN", "HORNE", "HORNER", "HORNSBY", "HOROWITZ", "HORSLEY", "HORTON",
+				"HORVATH", "HOSKINS", "HOSTETLER", "HOUCK", "HOUGH", "HOUGHTON", "HOULE", "HOUSE", "HOUSER", "HOUSTON",
+				"HOWARD", "HOWE", "HOWELL", "HOWERTON", "HOWES", "HOWLAND", "HOY", "HOYLE", "HOYT", "HSU", "HUANG",
+				"HUBBARD", "HUBER", "HUBERT", "HUDDLESTON", "HUDGENS", "HUDGINS", "HUDSON", "HUERTA", "HUEY", "HUFF",
+				"HUFFMAN", "HUGGINS", "HUGHES", "HUGHEY", "HULL", "HULSEY", "HUMES", "HUMMEL", "HUMPHREY", "HUMPHREYS",
+				"HUMPHRIES", "HUNDLEY", "HUNT", "HUNTER", "HUNTINGTON", "HUNTLEY", "HURD", "HURLEY", "HURST", "HURT",
+				"HURTADO", "HUSKEY", "HUSSEY", "HUSTON", "HUTCHENS", "HUTCHERSON", "HUTCHESON", "HUTCHINGS", "HUTCHINS",
+				"HUTCHINSON", "HUTCHISON", "HUTSON", "HUTTO", "HUTTON", "HUYNH", "HWANG", "HYATT", "HYDE", "HYLAND",
+				"HYLTON", "HYMAN", "HYNES", "IBARRA", "INGLE", "INGRAHAM", "INGRAM", "INMAN", "IRBY", "IRELAND", "IRISH",
+				"IRIZARRY", "IRONS", "IRVIN", "IRVINE", "IRVING", "IRWIN", "ISAAC", "ISAACS", "ISAACSON", "ISBELL", "ISOM",
+				"ISON", "ISRAEL", "IVERSON", "IVES", "IVEY", "IVORY", "IVY", "JACK", "JACKMAN", "JACKS", "JACKSON", "JACOB",
+				"JACOBS", "JACOBSEN", "JACOBSON", "JACOBY", "JACQUES", "JAEGER", "JAMES", "JAMESON", "JAMISON", "JANES",
+				"JANKOWSKI", "JANSEN", "JANSSEN", "JARAMILLO", "JARRELL", "JARRETT", "JARVIS", "JASPER", "JAY", "JAYNES",
+				"JEAN", "JEFFERIES", "JEFFERS", "JEFFERSON", "JEFFERY", "JEFFREY", "JEFFRIES", "JENKINS", "JENNINGS",
+				"JENSEN", "JENSON", "JERNIGAN", "JESSUP", "JETER", "JETT", "JEWELL", "JEWETT", "JIMENEZ", "JOBE", "JOE",
+				"JOHANSEN", "JOHN", "JOHNS", "JOHNSON", "JOHNSTON", "JOINER", "JOLLEY", "JOLLY", "JONES", "JORDAN",
+				"JORDON", "JORGENSEN", "JORGENSON", "JOSE", "JOSEPH", "JOY", "JOYCE", "JOYNER", "JUAREZ", "JUDD", "JUDE",
+				"JUDGE", "JUDKINS", "JULIAN", "JUNG", "JUSTICE", "JUSTUS", "KAHN", "KAISER", "KAMINSKI", "KANE", "KANG",
+				"KAPLAN", "KARR", "KASPER", "KATZ", "KAUFFMAN", "KAUFMAN", "KAY", "KAYE", "KEANE", "KEARNEY", "KEARNS",
+				"KEATING", "KEATON", "KECK", "KEE", "KEEFE", "KEEFER", "KEEGAN", "KEEL", "KEELER", "KEELING", "KEEN",
+				"KEENAN", "KEENE", "KEENER", "KEENEY", "KEETON", "KEITH", "KELLEHER", "KELLER", "KELLEY", "KELLOGG",
+				"KELLUM", "KELLY", "KELSEY", "KELSO", "KEMP", "KEMPER", "KENDALL", "KENDRICK", "KENNEDY", "KENNEY", "KENNY",
+				"KENT", "KENYON", "KERN", "KERNS", "KERR", "KESSLER", "KETCHUM", "KEY", "KEYES", "KEYS", "KEYSER", "KHAN",
+				"KIDD", "KIDWELL", "KIEFER", "KILGORE", "KILLIAN", "KILPATRICK", "KIM", "KIMBALL", "KIMBLE", "KIMBRELL",
+				"KIMBROUGH", "KIMMEL", "KINARD", "KINCAID", "KINDER", "KING", "KINGSLEY", "KINNEY", "KINSEY", "KIRBY",
+				"KIRCHNER", "KIRK", "KIRKLAND", "KIRKPATRICK", "KIRKWOOD", "KISER", "KISH", "KITCHEN", "KITCHENS", "KLEIN",
+				"KLINE", "KLINGER", "KNAPP", "KNIGHT", "KNOLL", "KNOTT", "KNOTTS", "KNOWLES", "KNOWLTON", "KNOX", "KNUDSEN",
+				"KNUDSON", "KNUTSON", "KOCH", "KOEHLER", "KOENIG", "KOHL", "KOHLER", "KOHN", "KOLB", "KONG", "KOONCE",
+				"KOONTZ", "KOPP", "KOVACH", "KOWALSKI", "KOZAK", "KOZLOWSKI", "KRAFT", "KRAMER", "KRAUS", "KRAUSE",
+				"KRAUSS", "KREBS", "KRIEGER", "KROLL", "KRUEGER", "KRUG", "KRUGER", "KRUSE", "KUHN", "KUNKEL", "KUNTZ",
+				"KUNZ", "KURTZ", "KUYKENDALL", "KYLE", "LABBE", "LABELLE", "LACEY", "LACHANCE", "LACKEY", "LACROIX", "LACY",
+				"LADD", "LADNER", "LAFFERTY", "LAFLAMME", "LAFLEUR", "LAI", "LAIRD", "LAKE", "LAM", "LAMAR", "LAMB",
+				"LAMBERT", "LAMM", "LANCASTER", "LANCE", "LAND", "LANDERS", "LANDIS", "LANDON", "LANDRUM", "LANDRY", "LANE",
+				"LANEY", "LANG", "LANGDON", "LANGE", "LANGER", "LANGFORD", "LANGLEY", "LANGLOIS", "LANGSTON", "LANHAM",
+				"LANIER", "LANKFORD", "LANNING", "LANTZ", "LAPLANTE", "LAPOINTE", "LAPORTE", "LARA", "LARGE", "LARKIN",
+				"LAROCHE", "LAROSE", "LARRY", "LARSEN", "LARSON", "LARUE", "LASH", "LASHLEY", "LASSITER", "LASTER",
+				"LATHAM", "LATIMER", "LATTIMORE", "LAU", "LAUER", "LAUGHLIN", "LAVENDER", "LAVIGNE", "LAVOIE", "LAW",
+				"LAWHORN", "LAWLER", "LAWLESS", "LAWRENCE", "LAWS", "LAWSON", "LAWTON", "LAY", "LAYMAN", "LAYNE", "LAYTON",
+				"LE", "LEA", "LEACH", "LEAHY", "LEAK", "LEAKE", "LEAL", "LEAR", "LEARY", "LEAVITT", "LEBLANC", "LEBRON",
+				"LECLAIR", "LEDBETTER", "LEDESMA", "LEDFORD", "LEDOUX", "LEE", "LEEPER", "LEES", "LEFEBVRE", "LEGER",
+				"LEGG", "LEGGETT", "LEHMAN", "LEHMANN", "LEIGH", "LEIGHTON", "LEMASTER", "LEMAY", "LEMIEUX", "LEMKE",
+				"LEMMON", "LEMON", "LEMONS", "LEMUS", "LENNON", "LENTZ", "LENZ", "LEON", "LEONARD", "LEONE", "LERMA",
+				"LERNER", "LEROY", "LESLIE", "LESSARD", "LESTER", "LEUNG", "LEVESQUE", "LEVI", "LEVIN", "LEVINE", "LEVY",
+				"LEW", "LEWANDOWSKI", "LEWIS", "LEYVA", "LI", "LIBBY", "LIDDELL", "LIEBERMAN", "LIGHT", "LIGHTFOOT",
+				"LIGHTNER", "LIGON", "LILES", "LILLEY", "LILLY", "LIM", "LIMA", "LIMON", "LIN", "LINARES", "LINCOLN",
+				"LIND", "LINDBERG", "LINDER", "LINDGREN", "LINDLEY", "LINDQUIST", "LINDSAY", "LINDSEY", "LINDSTROM", "LINK",
+				"LINKOUS", "LINN", "LINTON", "LINVILLE", "LIPSCOMB", "LIRA", "LISTER", "LITTLE", "LITTLEFIELD",
+				"LITTLEJOHN", "LITTLETON", "LIU", "LIVELY", "LIVINGSTON", "LLOYD", "LO", "LOCKE", "LOCKETT", "LOCKHART",
+				"LOCKLEAR", "LOCKWOOD", "LOERA", "LOFTIN", "LOFTIS", "LOFTON", "LOGAN", "LOGSDON", "LOGUE", "LOMAX",
+				"LOMBARD", "LOMBARDI", "LOMBARDO", "LONDON", "LONG", "LONGO", "LONGORIA", "LOOMIS", "LOONEY", "LOPER",
+				"LOPES", "LOPEZ", "LORD", "LORENZ", "LORENZO", "LOTT", "LOUIS", "LOVE", "LOVEJOY", "LOVELACE", "LOVELESS",
+				"LOVELL", "LOVETT", "LOVING", "LOW", "LOWE", "LOWELL", "LOWERY", "LOWMAN", "LOWRY", "LOY", "LOYA", "LOYD",
+				"LOZANO", "LU", "LUCAS", "LUCE", "LUCERO", "LUCIANO", "LUCKETT", "LUDWIG", "LUGO", "LUIS", "LUJAN", "LUKE",
+				"LUMPKIN", "LUNA", "LUND", "LUNDBERG", "LUNDY", "LUNSFORD", "LUONG", "LUSK", "LUSTER", "LUTHER", "LUTTRELL",
+				"LUTZ", "LY", "LYLE", "LYLES", "LYMAN", "LYNCH", "LYNN", "LYON", "LYONS", "LYTLE", "MA", "MAAS", "MABE",
+				"MABRY", "MACDONALD", "MACE", "MACHADO", "MACIAS", "MACK", "MACKAY", "MACKENZIE", "MACKEY", "MACKIE",
+				"MACKLIN", "MACLEAN", "MACLEOD", "MACON", "MADDEN", "MADDOX", "MADERA", "MADISON", "MADRID", "MADRIGAL",
+				"MADSEN", "MAES", "MAESTAS", "MAGANA", "MAGEE", "MAGGARD", "MAGNUSON", "MAGUIRE", "MAHAFFEY", "MAHAN",
+				"MAHER", "MAHON", "MAHONEY", "MAIER", "MAIN", "MAJOR", "MAJORS", "MAKI", "MALCOLM", "MALDONADO", "MALLEY",
+				"MALLORY", "MALLOY", "MALONE", "MALONEY", "MANCINI", "MANCUSO", "MANESS", "MANGUM", "MANLEY", "MANN",
+				"MANNING", "MANNS", "MANSFIELD", "MANSON", "MANUEL", "MANZO", "MAPLE", "MAPLES", "MARBLE", "MARCH",
+				"MARCHAND", "MARCOTTE", "MARCUM", "MARCUS", "MARES", "MARIN", "MARINO", "MARION", "MARK", "MARKHAM",
+				"MARKLEY", "MARKS", "MARLER", "MARLOW", "MARLOWE", "MARQUEZ", "MARQUIS", "MARR", "MARRERO", "MARROQUIN",
+				"MARSH", "MARSHALL", "MARTEL", "MARTELL", "MARTENS", "MARTIN", "MARTINDALE", "MARTINEZ", "MARTINO",
+				"MARTINS", "MARTINSON", "MARTZ", "MARVIN", "MARX", "MASON", "MASSEY", "MASSIE", "MAST", "MASTERS",
+				"MASTERSON", "MATA", "MATHENY", "MATHESON", "MATHEWS", "MATHIAS", "MATHIS", "MATLOCK", "MATNEY", "MATOS",
+				"MATSON", "MATTESON", "MATTHEW", "MATTHEWS", "MATTINGLY", "MATTISON", "MATTOS", "MATTOX", "MATTSON",
+				"MAULDIN", "MAUPIN", "MAURER", "MAURO", "MAXEY", "MAXFIELD", "MAXWELL", "MAY", "MAYBERRY", "MAYER",
+				"MAYERS", "MAYES", "MAYFIELD", "MAYHEW", "MAYNARD", "MAYO", "MAYS", "MAZZA", "MCADAMS", "MCAFEE",
+				"MCALISTER", "MCALLISTER", "MCARTHUR", "MCBEE", "MCBRIDE", "MCCABE", "MCCAFFREY", "MCCAIN", "MCCALL",
+				"MCCALLISTER", "MCCALLUM", "MCCANN", "MCCANTS", "MCCARTER", "MCCARTHY", "MCCARTNEY", "MCCARTY", "MCCASKILL",
+				"MCCAULEY", "MCCLAIN", "MCCLANAHAN", "MCCLARY", "MCCLEARY", "MCCLELLAN", "MCCLELLAND", "MCCLENDON",
+				"MCCLINTOCK", "MCCLINTON", "MCCLOSKEY", "MCCLOUD", "MCCLUNG", "MCCLURE", "MCCOLLUM", "MCCOMBS", "MCCONNELL",
+				"MCCOOL", "MCCORD", "MCCORKLE", "MCCORMACK", "MCCORMICK", "MCCOY", "MCCRACKEN", "MCCRARY", "MCCRAY",
+				"MCCREARY", "MCCUE", "MCCULLOCH", "MCCULLOUGH", "MCCUNE", "MCCURDY", "MCCURRY", "MCCUTCHEON", "MCDADE",
+				"MCDANIEL", "MCDANIELS", "MCDERMOTT", "MCDONALD", "MCDONNELL", "MCDONOUGH", "MCDOUGAL", "MCDOUGALL",
+				"MCDOWELL", "MCDUFFIE", "MCELROY", "MCEWEN", "MCFADDEN", "MCFALL", "MCFARLAND", "MCFARLANE", "MCGEE",
+				"MCGEHEE", "MCGHEE", "MCGILL", "MCGINNIS", "MCGOVERN", "MCGOWAN", "MCGRATH", "MCGRAW", "MCGREGOR", "MCGREW",
+				"MCGRIFF", "MCGUIRE", "MCHENRY", "MCHUGH", "MCINNIS", "MCINTIRE", "MCINTOSH", "MCINTYRE", "MCKAY", "MCKEE",
+				"MCKEEVER", "MCKENNA", "MCKENNEY", "MCKENZIE", "MCKEON", "MCKEOWN", "MCKINLEY", "MCKINNEY", "MCKINNON",
+				"MCKNIGHT", "MCLAIN", "MCLAUGHLIN", "MCLAURIN", "MCLEAN", "MCLEMORE", "MCLENDON", "MCLEOD", "MCMAHAN",
+				"MCMAHON", "MCMANUS", "MCMASTER", "MCMILLAN", "MCMILLEN", "MCMILLIAN", "MCMULLEN", "MCMURRAY", "MCNABB",
+				"MCNAIR", "MCNALLY", "MCNAMARA", "MCNEAL", "MCNEELY", "MCNEIL", "MCNEILL", "MCNULTY", "MCNUTT", "MCPHERSON",
+				"MCQUEEN", "MCRAE", "MCREYNOLDS", "MCSWAIN", "MCVAY", "MCVEY", "MCWHORTER", "MCWILLIAMS", "MEACHAM", "MEAD",
+				"MEADE", "MEADOR", "MEADOWS", "MEANS", "MEARS", "MEDEIROS", "MEDINA", "MEDLEY", "MEDLIN", "MEDLOCK",
+				"MEDRANO", "MEEHAN", "MEEK", "MEEKER", "MEEKS", "MEIER", "MEJIA", "MELANCON", "MELENDEZ", "MELLO", "MELTON",
+				"MELVIN", "MENA", "MENARD", "MENDENHALL", "MENDEZ", "MENDOZA", "MENENDEZ", "MERCADO", "MERCER", "MERCHANT",
+				"MERCIER", "MEREDITH", "MERRELL", "MERRICK", "MERRILL", "MERRIMAN", "MERRITT", "MESA", "MESSENGER",
+				"MESSER", "MESSINA", "METCALF", "METZ", "METZGER", "METZLER", "MEYER", "MEYERS", "MEZA", "MICHAEL",
+				"MICHAELS", "MICHAUD", "MICHEL", "MICKENS", "MIDDLETON", "MILAM", "MILBURN", "MILES", "MILLARD", "MILLER",
+				"MILLIGAN", "MILLIKEN", "MILLS", "MILNE", "MILNER", "MILTON", "MIMS", "MINER", "MINNICK", "MINOR", "MINTER",
+				"MINTON", "MINTZ", "MIRANDA", "MIRELES", "MITCHELL", "MIXON", "MIZE", "MOBLEY", "MOCK", "MOE", "MOELLER",
+				"MOEN", "MOFFETT", "MOFFITT", "MOHR", "MOJICA", "MOLINA", "MOLL", "MONACO", "MONAGHAN", "MONAHAN", "MONEY",
+				"MONIZ", "MONK", "MONROE", "MONSON", "MONTAGUE", "MONTALVO", "MONTANEZ", "MONTANO", "MONTEMAYOR", "MONTERO",
+				"MONTES", "MONTEZ", "MONTGOMERY", "MONTOYA", "MOODY", "MOON", "MOONEY", "MOORE", "MOORMAN", "MORA",
+				"MORALES", "MORAN", "MOREAU", "MOREHEAD", "MORELAND", "MORENO", "MOREY", "MORGAN", "MORIARTY", "MORIN",
+				"MORLEY", "MORRELL", "MORRILL", "MORRIS", "MORRISON", "MORRISSEY", "MORROW", "MORSE", "MORTENSEN", "MORTON",
+				"MOSBY", "MOSELEY", "MOSER", "MOSES", "MOSHER", "MOSIER", "MOSLEY", "MOSS", "MOTLEY", "MOTT", "MOULTON",
+				"MOULTRIE", "MOUNT", "MOWERY", "MOYA", "MOYE", "MOYER", "MUELLER", "MUHAMMAD", "MUIR", "MULKEY", "MULL",
+				"MULLEN", "MULLER", "MULLIGAN", "MULLIN", "MULLINS", "MULLIS", "MUNCY", "MUNDY", "MUNIZ", "MUNN", "MUNOZ",
+				"MUNSON", "MURDOCK", "MURILLO", "MURPHY", "MURRAY", "MURRELL", "MURRY", "MUSE", "MUSGROVE", "MUSSER",
+				"MYERS", "MYLES", "MYRICK", "NABORS", "NADEAU", "NAGEL", "NAGLE", "NAGY", "NAJERA", "NAKAMURA", "NALL",
+				"NANCE", "NAPIER", "NAQUIN", "NARANJO", "NARVAEZ", "NASH", "NATHAN", "NATION", "NAVA", "NAVARRETE",
+				"NAVARRO", "NAYLOR", "NEAL", "NEALY", "NEEDHAM", "NEEL", "NEELEY", "NEELY", "NEFF", "NEGRETE", "NEGRON",
+				"NEIL", "NEILL", "NELMS", "NELSON", "NESBITT", "NESMITH", "NESS", "NESTOR", "NETTLES", "NEUMAN", "NEUMANN",
+				"NEVAREZ", "NEVILLE", "NEW", "NEWBERRY", "NEWBY", "NEWCOMB", "NEWELL", "NEWKIRK", "NEWMAN", "NEWSOM",
+				"NEWSOME", "NEWTON", "NG", "NGO", "NGUYEN", "NICHOLAS", "NICHOLS", "NICHOLSON", "NICKEL", "NICKERSON",
+				"NIELSEN", "NIELSON", "NIETO", "NIEVES", "NILES", "NIX", "NIXON", "NOBLE", "NOBLES", "NOE", "NOEL", "NOLAN",
+				"NOLAND", "NOLEN", "NOLL", "NOONAN", "NORFLEET", "NORIEGA", "NORMAN", "NORRIS", "NORTH", "NORTON",
+				"NORWOOD", "NOVAK", "NOVOTNY", "NOWAK", "NOWLIN", "NOYES", "NUGENT", "NULL", "NUMBERS", "NUNES", "NUNEZ",
+				"NUNLEY", "NUNN", "NUTT", "NUTTER", "NYE", "OAKES", "OAKLEY", "OAKS", "OATES", "OBRIEN", "OBRYAN", "OCAMPO",
+				"OCASIO", "OCHOA", "OCHS", "OCONNELL", "OCONNER", "OCONNOR", "ODELL", "ODEN", "ODOM", "ODONNELL", "ODUM",
+				"OGDEN", "OGLE", "OGLESBY", "OH", "OHARA", "OJEDA", "OKEEFE", "OLDHAM", "OLDS", "OLEARY", "OLIPHANT",
+				"OLIVA", "OLIVARES", "OLIVAREZ", "OLIVAS", "OLIVE", "OLIVEIRA", "OLIVER", "OLIVO", "OLMSTEAD", "OLSEN",
+				"OLSON", "OLVERA", "OMALLEY", "ONEAL", "ONEIL", "ONEILL", "ONTIVEROS", "ORDONEZ", "OREILLY", "ORELLANA",
+				"ORLANDO", "ORNELAS", "OROSCO", "OROURKE", "OROZCO", "ORR", "ORTA", "ORTEGA", "ORTIZ", "OSBORN", "OSBORNE",
+				"OSBURN", "OSGOOD", "OSHEA", "OSORIO", "OSTEEN", "OSTRANDER", "OSULLIVAN", "OSWALD", "OSWALT", "OTERO",
+				"OTIS", "OTOOLE", "OTT", "OTTO", "OUELLETTE", "OUTLAW", "OVERBY", "OVERSTREET", "OVERTON", "OWEN", "OWENS",
+				"PACE", "PACHECO", "PACK", "PACKARD", "PACKER", "PADGETT", "PADILLA", "PAGAN", "PAGE", "PAIGE", "PAINE",
+				"PAINTER", "PAK", "PALACIOS", "PALMA", "PALMER", "PALUMBO", "PANNELL", "PANTOJA", "PAPE", "PAPPAS",
+				"PAQUETTE", "PARADIS", "PARDO", "PAREDES", "PARENT", "PARHAM", "PARIS", "PARISH", "PARK", "PARKER",
+				"PARKINSON", "PARKS", "PARNELL", "PARR", "PARRA", "PARRIS", "PARRISH", "PARROTT", "PARRY", "PARSON",
+				"PARSONS", "PARTIN", "PARTRIDGE", "PASSMORE", "PATE", "PATEL", "PATERSON", "PATINO", "PATRICK", "PATTEN",
+				"PATTERSON", "PATTON", "PAUL", "PAULEY", "PAULSEN", "PAULSON", "PAXTON", "PAYNE", "PAYTON", "PAZ", "PEACE",
+				"PEACHEY", "PEACOCK", "PEAK", "PEARCE", "PEARSON", "PEASE", "PECK", "PEDERSEN", "PEDERSON", "PEEBLES",
+				"PEEK", "PEEL", "PEELER", "PEEPLES", "PELLETIER", "PELTIER", "PEMBERTON", "PENA", "PENCE", "PENDER",
+				"PENDERGRASS", "PENDLETON", "PENN", "PENNELL", "PENNINGTON", "PENNY", "PEOPLES", "PEPPER", "PERALES",
+				"PERALTA", "PERDUE", "PEREA", "PEREIRA", "PEREZ", "PERKINS", "PERREAULT", "PERRIN", "PERRON", "PERRY",
+				"PERRYMAN", "PERSON", "PETER", "PETERMAN", "PETERS", "PETERSEN", "PETERSON", "PETIT", "PETRIE", "PETTIGREW",
+				"PETTIS", "PETTIT", "PETTWAY", "PETTY", "PEYTON", "PFEIFER", "PFEIFFER", "PHAM", "PHAN", "PHELAN", "PHELPS",
+				"PHIFER", "PHILLIPS", "PHIPPS", "PICARD", "PICKARD", "PICKENS", "PICKERING", "PICKETT", "PIERCE", "PIERRE",
+				"PIERSON", "PIKE", "PILCHER", "PIMENTEL", "PINA", "PINCKNEY", "PINEDA", "PINKERTON", "PINKSTON", "PINO",
+				"PINSON", "PINTO", "PIPER", "PIPKIN", "PIPPIN", "PITMAN", "PITRE", "PITT", "PITTMAN", "PITTS", "PLACE",
+				"PLANTE", "PLATT", "PLEASANT", "PLUMMER", "PLUNKETT", "POE", "POGUE", "POINDEXTER", "POINTER", "POIRIER",
+				"POLANCO", "POLAND", "POLING", "POLK", "POLLACK", "POLLARD", "POLLOCK", "POMEROY", "PONCE", "POND",
+				"PONDER", "POOL", "POOLE", "POORE", "POPE", "POPP", "PORTER", "PORTERFIELD", "PORTILLO", "POSEY", "POST",
+				"POSTON", "POTTER", "POTTS", "POULIN", "POUNDS", "POWELL", "POWER", "POWERS", "PRADO", "PRATER", "PRATHER",
+				"PRATT", "PRENTICE", "PRESCOTT", "PRESLEY", "PRESSLEY", "PRESTON", "PREWITT", "PRICE", "PRICHARD", "PRIDE",
+				"PRIDGEN", "PRIEST", "PRIETO", "PRINCE", "PRINGLE", "PRITCHARD", "PRITCHETT", "PROCTOR", "PROFFITT",
+				"PROSSER", "PROVOST", "PRUETT", "PRUITT", "PRYOR", "PUCKETT", "PUENTE", "PUGH", "PULIDO", "PULLEN",
+				"PULLEY", "PULLIAM", "PURCELL", "PURDY", "PURNELL", "PURVIS", "PUTMAN", "PUTNAM", "PYLE", "QUALLS",
+				"QUARLES", "QUEEN", "QUEZADA", "QUICK", "QUIGLEY", "QUILLEN", "QUINLAN", "QUINN", "QUINONES", "QUINONEZ",
+				"QUINTANA", "QUINTANILLA", "QUINTERO", "QUIROZ", "RADER", "RADFORD", "RAFFERTY", "RAGAN", "RAGLAND",
+				"RAGSDALE", "RAINES", "RAINEY", "RAINS", "RALEY", "RALPH", "RALSTON", "RAMEY", "RAMIREZ", "RAMON", "RAMOS",
+				"RAMSAY", "RAMSEY", "RAND", "RANDALL", "RANDLE", "RANDOLPH", "RANEY", "RANGEL", "RANKIN", "RANSOM", "RAPP",
+				"RASH", "RASMUSSEN", "RATCLIFF", "RATLIFF", "RAU", "RAUCH", "RAWLINGS", "RAWLINS", "RAWLS", "RAY",
+				"RAYBURN", "RAYFORD", "RAYMOND", "RAYNOR", "RAZO", "REA", "READ", "REAGAN", "REARDON", "REAVES", "RECTOR",
+				"REDD", "REDDEN", "REDDICK", "REDDING", "REDDY", "REDMAN", "REDMON", "REDMOND", "REECE", "REED", "REEDER",
+				"REEDY", "REES", "REESE", "REEVES", "REGALADO", "REGAN", "REGISTER", "REICH", "REICHERT", "REID", "REILLY",
+				"REINHARDT", "REINHART", "REIS", "REITER", "RENDON", "RENFRO", "RENNER", "RENO", "RENTERIA", "REUTER",
+				"REY", "REYES", "REYNA", "REYNOLDS", "REYNOSO", "RHEA", "RHOADES", "RHOADS", "RHODEN", "RHODES", "RICCI",
+				"RICE", "RICH", "RICHARD", "RICHARDS", "RICHARDSON", "RICHEY", "RICHIE", "RICHMOND", "RICHTER", "RICKARD",
+				"RICKER", "RICKETTS", "RICKMAN", "RICKS", "RICO", "RIDDELL", "RIDDICK", "RIDDLE", "RIDENOUR", "RIDER",
+				"RIDGEWAY", "RIDLEY", "RIFE", "RIGBY", "RIGGINS", "RIGGS", "RIGSBY", "RILEY", "RINALDI", "RINEHART", "RING",
+				"RIOS", "RIPLEY", "RITCHEY", "RITCHIE", "RITTER", "RIVAS", "RIVERA", "RIVERS", "RIZZO", "ROACH", "ROARK",
+				"ROBB", "ROBBINS", "ROBERGE", "ROBERSON", "ROBERT", "ROBERTS", "ROBERTSON", "ROBEY", "ROBINETTE", "ROBINS",
+				"ROBINSON", "ROBISON", "ROBLES", "ROBSON", "ROBY", "ROCHA", "ROCHE", "ROCK", "ROCKWELL", "RODEN",
+				"RODERICK", "RODGERS", "RODRIGUE", "RODRIGUES", "RODRIGUEZ", "RODRIQUEZ", "ROE", "ROGER", "ROGERS", "ROHR",
+				"ROJAS", "ROLAND", "ROLDAN", "ROLLER", "ROLLINS", "ROMAN", "ROMANO", "ROMEO", "ROMERO", "ROMO", "RONEY",
+				"ROONEY", "ROOT", "ROPER", "ROQUE", "ROSA", "ROSADO", "ROSALES", "ROSARIO", "ROSAS", "ROSE", "ROSEN",
+				"ROSENBAUM", "ROSENBERG", "ROSENTHAL", "ROSS", "ROSSER", "ROSSI", "ROTH", "ROUNDS", "ROUNDTREE", "ROUNTREE",
+				"ROUSE", "ROUSH", "ROUSSEAU", "ROUSSEL", "ROWAN", "ROWE", "ROWELL", "ROWLAND", "ROWLEY", "ROY", "ROYAL",
+				"ROYBAL", "ROYER", "ROYSTER", "RUBIN", "RUBIO", "RUBY", "RUCKER", "RUDD", "RUDOLPH", "RUFF", "RUFFIN",
+				"RUIZ", "RUNYAN", "RUNYON", "RUPERT", "RUPP", "RUSH", "RUSHING", "RUSS", "RUSSELL", "RUSSO", "RUST", "RUTH",
+				"RUTHERFORD", "RUTLEDGE", "RYAN", "RYDER", "SAAVEDRA", "SABO", "SACCO", "SADLER", "SAENZ", "SAGE", "SAGER",
+				"SALAS", "SALAZAR", "SALCEDO", "SALCIDO", "SALDANA", "SALDIVAR", "SALERNO", "SALES", "SALGADO", "SALINAS",
+				"SALISBURY", "SALLEE", "SALLEY", "SALMON", "SALTER", "SAM", "SAMMONS", "SAMPLE", "SAMPLES", "SAMPSON",
+				"SAMS", "SAMSON", "SAMUEL", "SAMUELS", "SANBORN", "SANCHES", "SANCHEZ", "SANDBERG", "SANDER", "SANDERS",
+				"SANDERSON", "SANDLIN", "SANDOVAL", "SANDS", "SANFORD", "SANTANA", "SANTIAGO", "SANTOS", "SAPP", "SARGENT",
+				"SASSER", "SATTERFIELD", "SAUCEDO", "SAUCIER", "SAUER", "SAULS", "SAUNDERS", "SAVAGE", "SAVOY", "SAWYER",
+				"SAWYERS", "SAXON", "SAXTON", "SAYERS", "SAYLOR", "SAYRE", "SCALES", "SCANLON", "SCARBOROUGH", "SCARBROUGH",
+				"SCHAEFER", "SCHAEFFER", "SCHAFER", "SCHAFFER", "SCHELL", "SCHERER", "SCHILLER", "SCHILLING", "SCHINDLER",
+				"SCHMID", "SCHMIDT", "SCHMITT", "SCHMITZ", "SCHNEIDER", "SCHOFIELD", "SCHOLL", "SCHOONOVER", "SCHOTT",
+				"SCHRADER", "SCHREIBER", "SCHREINER", "SCHROEDER", "SCHUBERT", "SCHULER", "SCHULTE", "SCHULTZ", "SCHULZ",
+				"SCHULZE", "SCHUMACHER", "SCHUSTER", "SCHWAB", "SCHWARTZ", "SCHWARZ", "SCHWEITZER", "SCOGGINS", "SCOTT",
+				"SCRIBNER", "SCROGGINS", "SCRUGGS", "SCULLY", "SEAL", "SEALS", "SEAMAN", "SEARCY", "SEARS", "SEATON",
+				"SEAY", "SEE", "SEELEY", "SEGURA", "SEIBERT", "SEIDEL", "SEIFERT", "SEILER", "SEITZ", "SELBY", "SELF",
+				"SELL", "SELLERS", "SELLS", "SENA", "SEPULVEDA", "SERNA", "SERRANO", "SESSIONS", "SETTLE", "SETTLES",
+				"SEVERSON", "SEWARD", "SEWELL", "SEXTON", "SEYMORE", "SEYMOUR", "SHACKELFORD", "SHADE", "SHAFER", "SHAFFER",
+				"SHAH", "SHANK", "SHANKS", "SHANNON", "SHAPIRO", "SHARKEY", "SHARP", "SHARPE", "SHAVER", "SHAW", "SHAY",
+				"SHEA", "SHEARER", "SHEEHAN", "SHEETS", "SHEFFIELD", "SHELBY", "SHELDON", "SHELL", "SHELLEY", "SHELLY",
+				"SHELTON", "SHEPARD", "SHEPHARD", "SHEPHERD", "SHEPPARD", "SHERIDAN", "SHERMAN", "SHERRILL", "SHERROD",
+				"SHERRY", "SHERWOOD", "SHIELDS", "SHIFFLETT", "SHIN", "SHINN", "SHIPLEY", "SHIPMAN", "SHIPP", "SHIRLEY",
+				"SHIVELY", "SHIVERS", "SHOCKLEY", "SHOEMAKER", "SHOOK", "SHORE", "SHORES", "SHORT", "SHORTER", "SHRADER",
+				"SHULER", "SHULL", "SHULTZ", "SHUMAKER", "SHUMAN", "SHUMATE", "SIBLEY", "SIDES", "SIEGEL", "SIERRA",
+				"SIGLER", "SIKES", "SILER", "SILLS", "SILVA", "SILVER", "SILVERMAN", "SILVERS", "SILVIA", "SIMMONS",
+				"SIMMS", "SIMON", "SIMONE", "SIMONS", "SIMONSON", "SIMPKINS", "SIMPSON", "SIMS", "SINCLAIR", "SINGER",
+				"SINGH", "SINGLETARY", "SINGLETON", "SIPES", "SISCO", "SISK", "SISSON", "SIZEMORE", "SKAGGS", "SKELTON",
+				"SKIDMORE", "SKINNER", "SKIPPER", "SLACK", "SLADE", "SLAGLE", "SLATER", "SLATON", "SLATTERY", "SLAUGHTER",
+				"SLAYTON", "SLEDGE", "SLOAN", "SLOCUM", "SLONE", "SMALL", "SMALLEY", "SMALLS", "SMALLWOOD", "SMART",
+				"SMILEY", "SMITH", "SMITHSON", "SMOOT", "SMOTHERS", "SMYTH", "SNEAD", "SNEED", "SNELL", "SNIDER", "SNIPES",
+				"SNODGRASS", "SNOW", "SNOWDEN", "SNYDER", "SOARES", "SOLANO", "SOLIS", "SOLIZ", "SOLOMON", "SOMERS",
+				"SOMERVILLE", "SOMMER", "SOMMERS", "SONG", "SORENSEN", "SORENSON", "SORIA", "SORIANO", "SORRELL", "SOSA",
+				"SOTELO", "SOTO", "SOUSA", "SOUTH", "SOUTHARD", "SOUTHERLAND", "SOUTHERN", "SOUZA", "SOWELL", "SOWERS",
+				"SPAIN", "SPALDING", "SPANGLER", "SPANN", "SPARKMAN", "SPARKS", "SPARROW", "SPAULDING", "SPEAR", "SPEARMAN",
+				"SPEARS", "SPEED", "SPEER", "SPEIGHT", "SPELLMAN", "SPENCE", "SPENCER", "SPERRY", "SPICER", "SPILLMAN",
+				"SPINKS", "SPIVEY", "SPOONER", "SPRADLIN", "SPRAGUE", "SPRIGGS", "SPRING", "SPRINGER", "SPROUSE", "SPRUILL",
+				"SPURGEON", "SPURLOCK", "SQUIRES", "STACEY", "STACK", "STACKHOUSE", "STACY", "STAFFORD", "STAGGS", "STAHL",
+				"STALEY", "STALLINGS", "STALLWORTH", "STAMM", "STAMPER", "STAMPS", "STANFIELD", "STANFORD", "STANLEY",
+				"STANTON", "STAPLES", "STAPLETON", "STARK", "STARKEY", "STARKS", "STARLING", "STARNES", "STARR", "STATEN",
+				"STATON", "STAUFFER", "STCLAIR", "STEADMAN", "STEARNS", "STEED", "STEEL", "STEELE", "STEEN", "STEFFEN",
+				"STEGALL", "STEIN", "STEINBERG", "STEINER", "STEPHEN", "STEPHENS", "STEPHENSON", "STEPP", "STERLING",
+				"STERN", "STEVENS", "STEVENSON", "STEWARD", "STEWART", "STIDHAM", "STILES", "STILL", "STILLMAN",
+				"STILLWELL", "STILTNER", "STINE", "STINNETT", "STINSON", "STITT", "STJOHN", "STOCK", "STOCKTON", "STODDARD",
+				"STOKER", "STOKES", "STOLL", "STONE", "STONER", "STOREY", "STORY", "STOTT", "STOUT", "STOVALL", "STOVER",
+				"STOWE", "STPIERRE", "STRAIN", "STRAND", "STRANGE", "STRATTON", "STRAUB", "STRAUSS", "STREET", "STREETER",
+				"STRICKLAND", "STRINGER", "STRONG", "STROTHER", "STROUD", "STROUP", "STRUNK", "STUART", "STUBBLEFIELD",
+				"STUBBS", "STUCKEY", "STULL", "STUMP", "STURDIVANT", "STURGEON", "STURGILL", "STURGIS", "STURM", "STYLES",
+				"SUAREZ", "SUGGS", "SULLIVAN", "SUMMERLIN", "SUMMERS", "SUMNER", "SUMPTER", "SUN", "SUTHERLAND", "SUTTER",
+				"SUTTON", "SWAFFORD", "SWAIN", "SWAN", "SWANK", "SWANN", "SWANSON", "SWARTZ", "SWEARINGEN", "SWEAT",
+				"SWEENEY", "SWEET", "SWENSON", "SWIFT", "SWISHER", "SWITZER", "SWOPE", "SYKES", "SYLVESTER", "TABER",
+				"TABOR", "TACKETT", "TAFT", "TAGGART", "TALBERT", "TALBOT", "TALBOTT", "TALLENT", "TALLEY", "TAM", "TAMAYO",
+				"TAN", "TANAKA", "TANG", "TANNER", "TAPIA", "TAPP", "TARVER", "TATE", "TATUM", "TAVARES", "TAYLOR",
+				"TEAGUE", "TEAL", "TEEL", "TEETER", "TEJADA", "TEJEDA", "TELLEZ", "TEMPLE", "TEMPLETON", "TENNANT",
+				"TENNEY", "TERRELL", "TERRILL", "TERRY", "THACKER", "THAMES", "THAO", "THARP", "THATCHER", "THAYER",
+				"THERIAULT", "THERIOT", "THIBODEAU", "THIBODEAUX", "THIEL", "THIGPEN", "THOMAS", "THOMASON", "THOMPSON",
+				"THOMSEN", "THOMSON", "THORN", "THORNBURG", "THORNE", "THORNHILL", "THORNTON", "THORP", "THORPE", "THORTON",
+				"THRASH", "THRASHER", "THURMAN", "THURSTON", "TIBBETTS", "TIBBS", "TICE", "TIDWELL", "TIERNEY", "TIJERINA",
+				"TILLER", "TILLERY", "TILLEY", "TILLMAN", "TILTON", "TIMM", "TIMMONS", "TINKER", "TINSLEY", "TIPTON",
+				"TIRADO", "TISDALE", "TITUS", "TOBIAS", "TOBIN", "TODD", "TOLBERT", "TOLEDO", "TOLER", "TOLIVER",
+				"TOLLIVER", "TOM", "TOMLIN", "TOMLINSON", "TOMPKINS", "TONEY", "TONG", "TORO", "TORRENCE", "TORRES",
+				"TORREZ", "TOTH", "TOTTEN", "TOVAR", "TOWNES", "TOWNS", "TOWNSEND", "TRACY", "TRAHAN", "TRAMMELL", "TRAN",
+				"TRAPP", "TRASK", "TRAVERS", "TRAVIS", "TRAYLOR", "TREADWAY", "TREADWELL", "TREJO", "TREMBLAY", "TRENT",
+				"TREVINO", "TRIBBLE", "TRICE", "TRIMBLE", "TRINIDAD", "TRIPLETT", "TRIPP", "TROTTER", "TROUT", "TROUTMAN",
+				"TROY", "TRUDEAU", "TRUE", "TRUITT", "TRUJILLO", "TRUONG", "TUBBS", "TUCK", "TUCKER", "TUGGLE", "TURK",
+				"TURLEY", "TURMAN", "TURNBULL", "TURNER", "TURNEY", "TURPIN", "TUTTLE", "TYLER", "TYNER", "TYREE", "TYSON",
+				"ULRICH", "UNDERHILL", "UNDERWOOD", "UNGER", "UPCHURCH", "UPSHAW", "UPTON", "URBAN", "URBINA", "URIBE",
+				"USHER", "UTLEY", "VAIL", "VALADEZ", "VALDES", "VALDEZ", "VALENCIA", "VALENTI", "VALENTIN", "VALENTINE",
+				"VALENZUELA", "VALERIO", "VALLE", "VALLEJO", "VALLES", "VAN", "VANBUREN", "VANCE", "VANDIVER", "VANDYKE",
+				"VANG", "VANHOOSE", "VANHORN", "VANMETER", "VANN", "VANOVER", "VANWINKLE", "VARELA", "VARGAS", "VARNER",
+				"VARNEY", "VASQUEZ", "VAUGHAN", "VAUGHN", "VAUGHT", "VAZQUEZ", "VEAL", "VEGA", "VELA", "VELASCO",
+				"VELASQUEZ", "VELAZQUEZ", "VELEZ", "VENABLE", "VENEGAS", "VENTURA", "VERA", "VERDIN", "VERGARA", "VERNON",
+				"VEST", "VETTER", "VICK", "VICKERS", "VICKERY", "VICTOR", "VIDAL", "VIEIRA", "VIERA", "VIGIL", "VILLA",
+				"VILLALOBOS", "VILLANUEVA", "VILLAREAL", "VILLARREAL", "VILLASENOR", "VILLEGAS", "VINCENT", "VINES",
+				"VINSON", "VITALE", "VO", "VOGEL", "VOGT", "VOSS", "VU", "VUE", "WADDELL", "WADE", "WADSWORTH", "WAGGONER",
+				"WAGNER", "WAGONER", "WAHL", "WAITE", "WAKEFIELD", "WALDEN", "WALDRON", "WALDROP", "WALKER", "WALL",
+				"WALLACE", "WALLEN", "WALLER", "WALLING", "WALLIS", "WALLS", "WALSH", "WALSTON", "WALTER", "WALTERS",
+				"WALTON", "WAMPLER", "WANG", "WARD", "WARDEN", "WARE", "WARFIELD", "WARNER", "WARREN", "WASHBURN",
+				"WASHINGTON", "WASSON", "WATERMAN", "WATERS", "WATKINS", "WATSON", "WATT", "WATTERS", "WATTS", "WAUGH",
+				"WAY", "WAYNE", "WEATHERFORD", "WEATHERLY", "WEATHERS", "WEAVER", "WEBB", "WEBBER", "WEBER", "WEBSTER",
+				"WEDDLE", "WEED", "WEEKS", "WEEMS", "WEINBERG", "WEINER", "WEINSTEIN", "WEIR", "WEIS", "WEISS", "WELCH",
+				"WELDON", "WELKER", "WELLER", "WELLMAN", "WELLS", "WELSH", "WENDT", "WENGER", "WENTWORTH", "WENTZ",
+				"WENZEL", "WERNER", "WERTZ", "WESLEY", "WEST", "WESTBROOK", "WESTER", "WESTFALL", "WESTMORELAND", "WESTON",
+				"WETZEL", "WHALEN", "WHALEY", "WHARTON", "WHATLEY", "WHEAT", "WHEATLEY", "WHEATON", "WHEELER", "WHELAN",
+				"WHIPPLE", "WHITAKER", "WHITCOMB", "WHITE", "WHITED", "WHITEHEAD", "WHITEHURST", "WHITEMAN", "WHITESIDE",
+				"WHITFIELD", "WHITING", "WHITLEY", "WHITLOCK", "WHITLOW", "WHITMAN", "WHITMIRE", "WHITMORE", "WHITNEY",
+				"WHITSON", "WHITT", "WHITTAKER", "WHITTEN", "WHITTINGTON", "WHITTLE", "WHITWORTH", "WHYTE", "WICK",
+				"WICKER", "WICKHAM", "WICKS", "WIESE", "WIGGINS", "WILBANKS", "WILBER", "WILBUR", "WILBURN", "WILCOX",
+				"WILD", "WILDE", "WILDER", "WILES", "WILEY", "WILHELM", "WILHITE", "WILKE", "WILKERSON", "WILKES",
+				"WILKINS", "WILKINSON", "WILKS", "WILL", "WILLARD", "WILLETT", "WILLEY", "WILLIAM", "WILLIAMS",
+				"WILLIAMSON", "WILLIFORD", "WILLINGHAM", "WILLIS", "WILLOUGHBY", "WILLS", "WILLSON", "WILMOTH", "WILSON",
+				"WILT", "WIMBERLY", "WINCHESTER", "WINDHAM", "WINFIELD", "WINFREY", "WING", "WINGATE", "WINGFIELD",
+				"WINKLER", "WINN", "WINSLOW", "WINSTEAD", "WINSTON", "WINTER", "WINTERS", "WIRTH", "WISE", "WISEMAN",
+				"WISNIEWSKI", "WITCHER", "WITHERS", "WITHERSPOON", "WITHROW", "WITT", "WITTE", "WOFFORD", "WOLF", "WOLFE",
+				"WOLFF", "WOLFORD", "WOMACK", "WONG", "WOO", "WOOD", "WOODALL", "WOODARD", "WOODBURY", "WOODCOCK", "WOODEN",
+				"WOODLEY", "WOODRUFF", "WOODS", "WOODSON", "WOODWARD", "WOODWORTH", "WOODY", "WOOLDRIDGE", "WOOLEY",
+				"WOOTEN", "WORD", "WORDEN", "WORKMAN", "WORLEY", "WORRELL", "WORSHAM", "WORTH", "WORTHAM", "WORTHINGTON",
+				"WORTHY", "WRAY", "WREN", "WRIGHT", "WU", "WYANT", "WYATT", "WYLIE", "WYMAN", "WYNN", "WYNNE", "XIONG",
+				"YAMAMOTO", "YANCEY", "YANEZ", "YANG", "YARBROUGH", "YATES", "YAZZIE", "YBARRA", "YEAGER", "YEE", "YI",
+				"YOCUM", "YODER", "YOO", "YOON", "YORK", "YOST", "YOUNG", "YOUNGBLOOD", "YOUNGER", "YOUNT", "YU",
+				"ZAMBRANO", "ZAMORA", "ZAPATA", "ZARAGOZA", "ZARATE", "ZAVALA", "ZEIGLER", "ZELLER", "ZEPEDA", "ZHANG",
+				"ZIEGLER", "ZIELINSKI", "ZIMMER", "ZIMMERMAN", "ZINK", "ZOOK", "ZUNIGA" };
+	}
+
+	public static String generateRandomName() {
+		String first, last;
+		
+		boolean isScottish = (MathUtils.randInt(0, 10) >= 9);
+		
+		if (isScottish) {
+			first = mScottishFirstNames[MathUtils.randInt(0, mScottishFirstNames.length - 1)].toLowerCase();
+		}
+		else {
+			first = mFirstNames[MathUtils.randInt(0, mFirstNames.length - 1)].toLowerCase();
+		}
+		
+		last = mLastNames[MathUtils.randInt(0, mLastNames.length - 1)].toLowerCase();
+		if (first.equalsIgnoreCase(last)) {
+			while (first.equalsIgnoreCase(last))
+				first = mFirstNames[MathUtils.randInt(0, mFirstNames.length - 1)].toLowerCase();
+		}
+		first = StringUtils.capitalize(first);
+		last = StringUtils.capitalize(last);
+		return first + " " + last;
+
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/VillagerEventHandler.java b/src/main/java/gtPlusPlus/plugin/villagers/VillagerEventHandler.java
new file mode 100644
index 0000000000..b515f0979e
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/VillagerEventHandler.java
@@ -0,0 +1,47 @@
+package gtPlusPlus.plugin.villagers;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.plugin.villagers.entity.EntityBaseVillager;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
+
+public class VillagerEventHandler {
+
+	private final static VillagerEventHandler mInstance;
+
+	static {
+		mInstance = new VillagerEventHandler();
+		Utils.registerEvent(mInstance);
+	}	
+
+	@SubscribeEvent
+	public void onEntityJoinWorld(EntityJoinWorldEvent event){
+		
+		
+		/*try {
+			if (event.entity != null && event.entity instanceof EntityLivingBase && event.entity instanceof EntityVillager){
+				EntityVillager entity = (EntityVillager) event.entity;
+				World world = entity.worldObj;	
+				int profession = entity.getProfession();			
+				if (world != null && (profession >= 7735 && profession <= 7737)){				
+					EntityBaseVillager mNew = new EntityBaseVillager(world, profession);				
+					mNew.copyLocationAndAnglesFrom(entity);	
+					if (mNew != null) {
+						world.removeEntity(entity);
+						world.spawnEntityInWorld(mNew);	
+					}
+				}
+
+			}
+		}
+		catch (Throwable t) {
+			t.printStackTrace();
+			return;
+		}*/
+
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/VillagerObject.java b/src/main/java/gtPlusPlus/plugin/villagers/VillagerObject.java
new file mode 100644
index 0000000000..a5587a1b52
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/VillagerObject.java
@@ -0,0 +1,40 @@
+package gtPlusPlus.plugin.villagers;
+
+import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.core.lib.CORE;
+import net.minecraft.util.ResourceLocation;
+
+public class VillagerObject {
+
+	public final int mID;
+	public final String mName;
+	public final IVillageTradeHandler mCustomTrade;
+
+
+	public VillagerObject(int aID, String aName, Object aProfession, Object aCareer, Object aSkin, IVillageTradeHandler aCustomTrade) {
+
+		mID = aID;
+		mName = aName;
+		mCustomTrade = aCustomTrade;
+
+		//Register Custom Trade to Registry.
+		if (aCustomTrade != null) {
+			Core_VillagerAdditions.mVillagerTrades.put(new Pair<Integer, IVillageTradeHandler>(7735+aID, aCustomTrade));
+		}
+		//Register Skin to Registry.
+		if (aSkin != null) {
+
+			if (aSkin instanceof String) {
+				String s = (String) aSkin;
+				aSkin = new ResourceLocation(CORE.MODID+":"+"textures/entity/villager/"+s+".png");
+			}
+			if (aSkin instanceof ResourceLocation) {
+				Core_VillagerAdditions.mVillagerSkins.put(aID, (ResourceLocation) aSkin);
+			}		
+
+		}				
+		VillagerUtils.registerNewVillager(aID, this);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/VillagerUtils.java b/src/main/java/gtPlusPlus/plugin/villagers/VillagerUtils.java
new file mode 100644
index 0000000000..f252ad068d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/VillagerUtils.java
@@ -0,0 +1,23 @@
+package gtPlusPlus.plugin.villagers;
+
+import java.util.HashMap;
+
+import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
+
+public class VillagerUtils {
+
+	public static final HashMap<Integer, VillagerObject> mVillagerMap = new HashMap<Integer, VillagerObject>();
+	
+	public static void registerNewVillager(int aID, String aName, Object aProfession, Object aCareer, Object aSkin, IVillageTradeHandler aCustomTrade) {
+		registerNewVillager(aID, new VillagerObject(aID, aName, aProfession, aCareer, aSkin, aCustomTrade));
+	}
+	
+	public static void registerNewVillager(int aID, VillagerObject aVillager) {
+		mVillagerMap.put(aID, aVillager);
+	}
+
+	
+	
+	
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/block/BlockGenericSpawner.java b/src/main/java/gtPlusPlus/plugin/villagers/block/BlockGenericSpawner.java
new file mode 100644
index 0000000000..916f360012
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/block/BlockGenericSpawner.java
@@ -0,0 +1,60 @@
+package gtPlusPlus.plugin.villagers.block;
+
+import static gtPlusPlus.core.lib.CORE.RANDOM;
+
+import java.util.List;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gtPlusPlus.core.item.base.itemblock.ItemBlockSpawner;
+import gtPlusPlus.plugin.villagers.Core_VillagerAdditions;
+import gtPlusPlus.plugin.villagers.tile.TileEntityGenericSpawner;
+import net.minecraft.block.BlockMobSpawner;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+public class BlockGenericSpawner extends BlockMobSpawner {
+	
+	public BlockGenericSpawner() {
+		this.disableStats();
+		this.setHardness(5.0F);
+		this.setStepSound(soundTypeMetal);
+		this.setBlockName("blockMobSpawnerEx");
+		this.setBlockTextureName("mob_spawner");
+		this.setResistance(2000.0F);
+		GameRegistry.registerBlock(this, ItemBlockSpawner.class, "blockMobSpawnerEx");
+		Core_VillagerAdditions.mInstance.log("Registered Custom Spawner Block.");
+	}
+	
+	/**
+     * Returns a new instance of a block's tile entity class. Called on placing the block.
+     */
+    @Override
+    public TileEntity createNewTileEntity(World world, int meta)
+    {
+        return new TileEntityGenericSpawner(meta);
+    }
+    
+    @Override
+    public int getExpDrop(IBlockAccess world, int metadata, int fortune){
+        return 15 + RANDOM.nextInt(15) + RANDOM.nextInt(15);
+    }
+    
+    /**
+     * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
+     */
+    @SideOnly(Side.CLIENT)
+    public void getSubBlocks(Item p_149666_1_, CreativeTabs p_149666_2_, List p_149666_3_)
+    {
+        for (int i = 0; i < Math.max(1,TileEntityGenericSpawner.mSpawners.size()); ++i)
+        {
+            p_149666_3_.add(new ItemStack(p_149666_1_, 1, i));
+        }
+    }
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/entity/EntityBaseVillager.java b/src/main/java/gtPlusPlus/plugin/villagers/entity/EntityBaseVillager.java
new file mode 100644
index 0000000000..c29aadb16b
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/entity/EntityBaseVillager.java
@@ -0,0 +1,538 @@
+package gtPlusPlus.plugin.villagers.entity;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Random;
+
+import cpw.mods.fml.common.registry.VillagerRegistry;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.plugin.villagers.NameLists;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentData;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.Tuple;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+import net.minecraft.village.Village;
+import net.minecraft.world.World;
+
+public class EntityBaseVillager extends EntityVillager {
+
+	// public static final VillagerProfession mProfession;
+
+	/*
+	 * 
+	 * Your problem is that you are extending EntityVillager, but buyingList and
+	 * addDefaultEquipment are both PRIVATE members of EntityVillager - you cannot
+	 * use or override them without Reflection or ASM.
+	 * 
+	 * What you can do, however, is override getRecipes to return your own list, but
+	 * because you override EntityVillager, your mob is still using the villager's
+	 * buyingList (which is NULL) when useRecipe or any other villager method is
+	 * called. You either have to override every method from EntityVillager which
+	 * interacts with buyingList and make it use your own list, or you need to not
+	 * extend EntityVillager and just implement IMerchant instead.
+	 */
+
+	private final int mRoleID;
+
+	public EntityBaseVillager(World aWorld){
+		this(aWorld, 0);
+	}
+
+	public EntityBaseVillager(World aWorld, int aID) {
+		super(aWorld, aID);
+		mRoleID = aID;
+	}
+
+	@Override
+	public void writeEntityToNBT(NBTTagCompound aNBT) {
+		if (this.hasCustomNameTag()) {
+			if (!aNBT.hasKey("aCustomName")) {
+				aNBT.setString("aCustomName", this.getCommandSenderName());
+			}
+		}
+		super.writeEntityToNBT(aNBT);
+	}
+
+	@Override
+	public void readEntityFromNBT(NBTTagCompound aNBT) {
+		if (aNBT.hasKey("aCustomName")) {
+			if (!this.getCustomNameTag().equals(aNBT.getString("aCustomName"))) {
+				this.setCustomNameTag(aNBT.getString("aCustomName"));
+			}
+		}
+		super.readEntityFromNBT(aNBT);
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound aNBT) {
+		// TODO Auto-generated method stub
+		super.writeToNBT(aNBT);
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound aNBT) {
+		// TODO Auto-generated method stub
+		super.readFromNBT(aNBT);
+	}
+
+	@Override
+	protected boolean canDespawn() {
+		return !this.hasCustomNameTag();
+	}
+
+	@Override
+	public void setProfession(int p_70938_1_) {
+		super.setProfession(p_70938_1_);
+	}
+
+	@Override
+	public int getProfession() {
+		int prof = super.getProfession();
+		//Logger.INFO(""+mRoleID);
+		return prof < 7735 ? 7738 : prof;
+	}
+
+	@Override
+	public void useRecipe(MerchantRecipe p_70933_1_) {
+		super.useRecipe(p_70933_1_);
+	}
+
+	@Override
+	public void setRecipes(MerchantRecipeList p_70930_1_) {
+		super.setRecipes(p_70930_1_);
+	}
+
+	public boolean shouldAlwaysSprint() {
+		return false;
+	};
+
+	@Override
+	public void onLivingUpdate() {
+
+		// Set Custom Name
+		if (!this.hasCustomNameTag()) {
+			this.setCustomNameTag(NameLists.generateRandomName());
+		}
+
+		super.onLivingUpdate();
+
+		// Make these guys always sprint
+		if (shouldAlwaysSprint()) {
+			if (!this.isSprinting()) {
+				this.setSprinting(true);
+			}
+		}
+		else {
+			if (this.isSprinting()) {
+				this.setSprinting(false);
+			}
+		}
+
+	}
+
+	@Override
+	public Entity getEntityToAttack() {
+		return super.getEntityToAttack();
+	}
+
+	@Override
+	public boolean getAlwaysRenderNameTag() {
+		return hasCustomNameTag();
+	}
+
+	@Override
+	public Random getRNG() {
+		return CORE.RANDOM;
+	}
+
+	@Override
+	public void setSprinting(boolean bool) {
+		super.setSprinting(bool);
+	}
+
+	/**
+	 * Custom Shit
+	 */
+
+	protected float getField_82191_bN() {
+		Field v82191 = ReflectionUtils.getField(getClass(), "field_82191_bN");
+		try {
+			return v82191 != null ? v82191.getFloat(this) : 0f;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return 0f;
+		}
+	}
+
+	protected void setField_82191_bN(float f) {
+		try {
+			ReflectionUtils.setField(this, "field_82191_bN", f);
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	protected boolean getNeedsInitilization() {
+		Field v82191 = ReflectionUtils.getField(EntityVillager.class, "needsInitilization");
+		try {
+			return v82191 != null ? v82191.getBoolean(this) : false;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return false;
+		}
+	}
+
+	protected void setNeedsInitilization(boolean f) {
+		try {
+			ReflectionUtils.setField(this, "needsInitilization", f);
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	protected MerchantRecipeList getBuyingList() {
+		Field v82191;
+		MerchantRecipeList o = null;
+		v82191 = ReflectionUtils.getField(getClass(), "buyingList");
+		try {
+			if (v82191 != null)
+			o = (MerchantRecipeList) v82191.get(this);
+			Logger.WARNING("Is BuyingList Valid? " + (v82191 != null));
+			return v82191 != null ? o : null;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			e.printStackTrace();
+			return null;
+		}
+
+	}
+
+	protected void setBuyingList(MerchantRecipeList f) {
+		try {
+			Logger.WARNING("set BuyingList? "+(ReflectionUtils.setField(this, "buyingList", f)));
+		} catch (IllegalArgumentException e) {
+			e.printStackTrace();
+		}
+	}
+
+	protected Village getVillageObject() {
+		Field v82191 = ReflectionUtils.getField(getClass(), "villageObj");
+		try {
+			return v82191 != null ? (Village) v82191.get(this) : null;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return null;
+		}
+	}
+
+	protected String getLastBuyingPlayer() {
+		Field v82191 = ReflectionUtils.getField(getClass(), "lastBuyingPlayer");
+		try {
+			return v82191 != null ? (String) v82191.get(this) : "";
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return "";
+		}
+	}
+
+	public MerchantRecipeList getRecipes(EntityPlayer p_70934_1_) {
+		if (getBuyingList() == null) {
+			this.addDefaultEquipmentAndRecipies(1);
+		}
+		return getBuyingList();
+	}
+
+	/**
+	 * Adjusts the probability of obtaining a given recipe being offered by a
+	 * villager
+	 */
+	private float adjustProbability(float p_82188_1_) {
+		float f1 = p_82188_1_ + getField_82191_bN();
+		return f1 > 0.9F ? 0.9F - (f1 - 0.9F) : f1;
+	}
+
+	/**
+	 * based on the villagers profession add items, equipment, and recipies adds
+	 * par1 random items to the list of things that the villager wants to buy. (at
+	 * most 1 of each wanted type is added)
+	 */
+	private void addDefaultEquipmentAndRecipies(int p_70950_1_) {
+		if (this.getBuyingList() != null) {
+			setField_82191_bN(MathHelper.sqrt_float((float) this.getBuyingList().size()) * 0.2F);
+		} else {
+			setField_82191_bN(0.0F);
+		}
+
+		MerchantRecipeList merchantrecipelist;
+		merchantrecipelist = new MerchantRecipeList();
+		VillagerRegistry.manageVillagerTrades(merchantrecipelist, this, this.getProfession(), this.rand);
+		int k;
+		label50:
+
+			switch (this.getProfession()) {
+			case 0:
+				addPurchaseRecipe(merchantrecipelist, Items.wheat, this.rand, this.adjustProbability(0.9F));
+				addPurchaseRecipe(merchantrecipelist, Item.getItemFromBlock(Blocks.wool), this.rand,
+						this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.chicken, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.cooked_fished, this.rand, this.adjustProbability(0.4F));
+				addEmeraldTrade(merchantrecipelist, Items.bread, this.rand, this.adjustProbability(0.9F));
+				addEmeraldTrade(merchantrecipelist, Items.melon, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.apple, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cookie, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.shears, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.flint_and_steel, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cooked_chicken, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.arrow, this.rand, this.adjustProbability(0.5F));
+
+				if (this.rand.nextFloat() < this.adjustProbability(0.5F)) {
+					merchantrecipelist.add(new MerchantRecipe(new ItemStack(Blocks.gravel, 10),
+							new ItemStack(Items.emerald), new ItemStack(Items.flint, 4 + this.rand.nextInt(2), 0)));
+				}
+
+				break;
+			case 1:
+				addPurchaseRecipe(merchantrecipelist, Items.paper, this.rand, this.adjustProbability(0.8F));
+				addPurchaseRecipe(merchantrecipelist, Items.book, this.rand, this.adjustProbability(0.8F));
+				addPurchaseRecipe(merchantrecipelist, Items.written_book, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Item.getItemFromBlock(Blocks.bookshelf), this.rand,
+						this.adjustProbability(0.8F));
+				addEmeraldTrade(merchantrecipelist, Item.getItemFromBlock(Blocks.glass), this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.compass, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.clock, this.rand, this.adjustProbability(0.2F));
+
+				if (this.rand.nextFloat() < this.adjustProbability(0.07F)) {
+					Enchantment enchantment = Enchantment.enchantmentsBookList[this.rand
+					                                                           .nextInt(Enchantment.enchantmentsBookList.length)];
+					int i1 = MathHelper.getRandomIntegerInRange(this.rand, enchantment.getMinLevel(),
+							enchantment.getMaxLevel());
+					ItemStack itemstack = Items.enchanted_book.getEnchantedItemStack(new EnchantmentData(enchantment, i1));
+					k = 2 + this.rand.nextInt(5 + i1 * 10) + 3 * i1;
+					merchantrecipelist
+					.add(new MerchantRecipe(new ItemStack(Items.book), new ItemStack(Items.emerald, k), itemstack));
+				}
+
+				break;
+			case 2:
+				addEmeraldTrade(merchantrecipelist, Items.ender_eye, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.experience_bottle, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.redstone, this.rand, this.adjustProbability(0.4F));
+				addEmeraldTrade(merchantrecipelist, Item.getItemFromBlock(Blocks.glowstone), this.rand,
+						this.adjustProbability(0.3F));
+				Item[] aitem = new Item[] { Items.iron_sword, Items.diamond_sword, Items.iron_chestplate,
+						Items.diamond_chestplate, Items.iron_axe, Items.diamond_axe, Items.iron_pickaxe,
+						Items.diamond_pickaxe };
+				Item[] aitem1 = aitem;
+				int j = aitem.length;
+				k = 0;
+
+				while (true) {
+					if (k >= j) {
+						break label50;
+					}
+
+					Item item = aitem1[k];
+
+					if (this.rand.nextFloat() < this.adjustProbability(0.05F)) {
+						merchantrecipelist.add(new MerchantRecipe(new ItemStack(item, 1, 0),
+								new ItemStack(Items.emerald, 2 + this.rand.nextInt(3), 0),
+								EnchantmentHelper.addRandomEnchantment(this.rand, new ItemStack(item, 1, 0),
+										5 + this.rand.nextInt(15))));
+					}
+
+					++k;
+				}
+			case 3:
+				addPurchaseRecipe(merchantrecipelist, Items.coal, this.rand, this.adjustProbability(0.7F));
+				addPurchaseRecipe(merchantrecipelist, Items.iron_ingot, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.gold_ingot, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.diamond, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_sword, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_sword, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_axe, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_axe, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_pickaxe, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_pickaxe, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_shovel, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_shovel, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_hoe, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_hoe, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_boots, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_boots, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_helmet, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_helmet, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_chestplate, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_chestplate, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_leggings, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_leggings, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_boots, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_helmet, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_chestplate, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_leggings, this.rand, this.adjustProbability(0.1F));
+				break;
+			case 4:
+				addPurchaseRecipe(merchantrecipelist, Items.coal, this.rand, this.adjustProbability(0.7F));
+				addPurchaseRecipe(merchantrecipelist, Items.porkchop, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.beef, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.saddle, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_chestplate, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_boots, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_helmet, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_leggings, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cooked_porkchop, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cooked_beef, this.rand, this.adjustProbability(0.3F));
+			}
+
+		if (merchantrecipelist.isEmpty()) {
+			addPurchaseRecipe(merchantrecipelist, Items.gold_ingot, this.rand, 1.0F);
+		}
+
+		Collections.shuffle(merchantrecipelist);
+
+		if (this.getBuyingList() == null) {
+			this.setBuyingList(new MerchantRecipeList());
+		}
+
+		for (int l = 0; l < p_70950_1_ && l < merchantrecipelist.size(); ++l) {
+			try {
+				this.getBuyingList().addToListWithCheck((MerchantRecipe) merchantrecipelist.get(l));
+			}
+			catch (Throwable t) {
+				Logger.INFO("Villager with ID "+this.entityUniqueID.toString()+" at  |  X: "+this.posX+"   Y: "+this.posY+"   Z: "+this.posZ+" may have corrupt trades, it is advised to remove/kill it.");
+			}
+		}
+
+		try {
+			if (this.getBuyingList() != null) {
+				for (Object g : this.getBuyingList()) {
+					if (g != null) {
+						if (g instanceof MerchantRecipe) {
+							MerchantRecipe m = (MerchantRecipe) g;
+							ItemStack selling = m.getItemToSell();
+							ItemStack[] buying = new ItemStack[] {m.getItemToBuy(), m.getSecondItemToBuy() != null ? m.getSecondItemToBuy() : null};
+							if (selling == null) {
+								Logger.WARNING("Villager is Selling an invalid item");
+							}
+							else if (buying[0] == null && buying[1] == null) {
+								Logger.WARNING("Villager is buying two invalid items");
+							}
+							else {
+								Logger.WARNING("Villager is Selling x"+selling.stackSize+selling.getDisplayName()+" for x"+buying[0].stackSize+" "+buying[0].getDisplayName()+buying[1] != null ? " and for x"+buying[1].stackSize+" "+buying[1].getDisplayName() : "");
+							}
+						}
+						else
+							Logger.WARNING("Found: "+g.getClass().getName());
+					}
+				}
+			}
+			else {
+
+			}
+		}
+		catch (Throwable t) {
+
+		}
+
+	}
+
+	/**
+	 * main AI tick function, replaces updateEntityActionState
+	 */
+	@Override
+	protected void updateAITick() {
+		if (!this.isTrading()) {
+			if (this.getNeedsInitilization()) {
+				if (this.getBuyingList().size() > 1) {
+					Iterator<MerchantRecipe> iterator = this.getBuyingList().iterator();
+
+					while (iterator.hasNext()) {
+						MerchantRecipe merchantrecipe = (MerchantRecipe) iterator.next();
+
+						if (merchantrecipe.isRecipeDisabled()) {
+							merchantrecipe.func_82783_a(this.rand.nextInt(6) + this.rand.nextInt(6) + 2);
+						}
+					}
+				}
+
+				this.addDefaultEquipmentAndRecipies(1);
+				this.setNeedsInitilization(false);
+
+				if (this.getVillageObject() != null && this.getLastBuyingPlayer() != null) {
+					this.worldObj.setEntityState(this, (byte) 14);
+					this.getVillageObject().setReputationForPlayer(this.getLastBuyingPlayer(), 1);
+				}
+			}
+		}
+		super.updateAITick();
+	}
+
+	public static void addEmeraldTrade(MerchantRecipeList aRecipeList, Item aItem, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {
+			int i = getLootAmount_BlacksmithSellingList(aItem, aRand);
+			ItemStack itemstack;
+			ItemStack itemstack1;
+
+			if (i < 0) {
+				itemstack = new ItemStack(Items.emerald, 1, 0);
+				itemstack1 = new ItemStack(aItem, -i, 0);
+			} else {
+				itemstack = new ItemStack(Items.emerald, i, 0);
+				itemstack1 = new ItemStack(aItem, 1, 0);
+			}
+
+			aRecipeList.add(new MerchantRecipe(itemstack, itemstack1));
+		}
+	}
+
+	public static void addCustomTrade(MerchantRecipeList aRecipeList, ItemStack aItem1, ItemStack aItem2, ItemStack aItem3, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {			
+			aRecipeList.add(new MerchantRecipe(aItem1, aItem2, aItem3));
+		}
+	}
+
+	private static int getLootAmount_BlacksmithSellingList(Item aItem, Random aRand) {
+		Tuple tuple = (Tuple) blacksmithSellingList.get(aItem);
+		return tuple == null ? 1
+				: (((Integer) tuple.getFirst()).intValue() >= ((Integer) tuple.getSecond()).intValue()
+				? ((Integer) tuple.getFirst()).intValue()
+						: ((Integer) tuple.getFirst()).intValue() + aRand.nextInt(
+								((Integer) tuple.getSecond()).intValue() - ((Integer) tuple.getFirst()).intValue()));
+	}
+
+	public static void addPurchaseRecipe(MerchantRecipeList aTradeList, Item aItem, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {
+			aTradeList.add(new MerchantRecipe(getSimpleLootStack(aItem, aRand), Items.emerald));
+		}
+	}
+
+	private static ItemStack getSimpleLootStack(Item aItem, Random aRand) {
+		return new ItemStack(aItem, getLootAmount_VillagerSellingList(aItem, aRand), 0);
+	}
+
+	public static void addPurchaseRecipe(MerchantRecipeList aTradeList, Item aItem, int aMeta, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {
+			aTradeList.add(new MerchantRecipe(getComplexLootStack(aItem, aMeta, aRand), Items.emerald));
+		}
+	}
+
+	private static ItemStack getComplexLootStack(Item aItem, int aMeta, Random aRand) {
+		return new ItemStack(aItem, getLootAmount_VillagerSellingList(aItem, aRand), aMeta);
+	}
+
+	private static int getLootAmount_VillagerSellingList(Item aItem, Random aRand) {
+		Tuple tuple = (Tuple) villagersSellingList.get(aItem);
+		return tuple == null ? 1
+				: (((Integer) tuple.getFirst()).intValue() >= ((Integer) tuple.getSecond()).intValue()
+				? ((Integer) tuple.getFirst()).intValue()
+						: ((Integer) tuple.getFirst()).intValue() + aRand.nextInt(
+								((Integer) tuple.getSecond()).intValue() - ((Integer) tuple.getFirst()).intValue()));
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/entity/EntityNativeAustralian.java b/src/main/java/gtPlusPlus/plugin/villagers/entity/EntityNativeAustralian.java
new file mode 100644
index 0000000000..4f9e2954a4
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/entity/EntityNativeAustralian.java
@@ -0,0 +1,525 @@
+package gtPlusPlus.plugin.villagers.entity;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Random;
+
+import cpw.mods.fml.common.registry.VillagerRegistry;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.plugin.villagers.NameLists;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentData;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.IEntityLivingData;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.Tuple;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+import net.minecraft.village.Village;
+import net.minecraft.world.World;
+
+public class EntityNativeAustralian extends EntityVillager {
+
+	// public static final VillagerProfession mProfession;
+
+	/*
+	 * 
+	 * Your problem is that you are extending EntityVillager, but buyingList and
+	 * addDefaultEquipment are both PRIVATE members of EntityVillager - you cannot
+	 * use or override them without Reflection or ASM.
+	 * 
+	 * What you can do, however, is override getRecipes to return your own list, but
+	 * because you override EntityVillager, your mob is still using the villager's
+	 * buyingList (which is NULL) when useRecipe or any other villager method is
+	 * called. You either have to override every method from EntityVillager which
+	 * interacts with buyingList and make it use your own list, or you need to not
+	 * extend EntityVillager and just implement IMerchant instead.
+	 */
+
+	private final int mRoleID;
+
+	public EntityNativeAustralian(World aWorld) {
+		super(aWorld, 7738);
+		mRoleID = 7738;
+	}
+
+	public EntityVillager createChild(EntityAgeable p_90011_1_){
+		EntityNativeAustralian entityvillager = new EntityNativeAustralian(this.worldObj);
+		entityvillager.onSpawnWithEgg((IEntityLivingData)null);
+		return entityvillager;
+	}
+
+	public boolean allowLeashing()
+	{
+		return true;
+	}
+
+	@Override
+	public void writeEntityToNBT(NBTTagCompound aNBT) {
+		if (this.hasCustomNameTag()) {
+			if (!aNBT.hasKey("aCustomName")) {
+				aNBT.setString("aCustomName", this.getCommandSenderName());
+			}
+		}
+		super.writeEntityToNBT(aNBT);
+	}
+
+	@Override
+	public void readEntityFromNBT(NBTTagCompound aNBT) {
+		if (aNBT.hasKey("aCustomName")) {
+			if (!this.getCustomNameTag().equals(aNBT.getString("aCustomName"))) {
+				this.setCustomNameTag(aNBT.getString("aCustomName"));
+			}
+		}
+		super.readEntityFromNBT(aNBT);
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound aNBT) {
+		// TODO Auto-generated method stub
+		super.writeToNBT(aNBT);
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound aNBT) {
+		// TODO Auto-generated method stub
+		super.readFromNBT(aNBT);
+	}
+
+	@Override
+	protected boolean canDespawn() {
+		return !false;
+	}
+
+	@Override
+	public void setProfession(int p_70938_1_) {
+		super.setProfession(7738);
+	}
+
+	@Override
+	public int getProfession() {
+		return mRoleID;
+	}
+
+	@Override
+	public void useRecipe(MerchantRecipe p_70933_1_) {
+		super.useRecipe(p_70933_1_);
+	}
+
+	@Override
+	public void setRecipes(MerchantRecipeList p_70930_1_) {
+		super.setRecipes(p_70930_1_);
+	}
+
+	public boolean shouldAlwaysSprint() {
+		return false;
+	};
+
+	@Override
+	public void onLivingUpdate() {
+		super.onLivingUpdate();
+	}
+
+	@Override
+	public Entity getEntityToAttack() {
+		return super.getEntityToAttack();
+	}
+
+	@Override
+	public boolean getAlwaysRenderNameTag() {
+		return hasCustomNameTag();
+	}
+
+	@Override
+	public Random getRNG() {
+		return CORE.RANDOM;
+	}
+
+	@Override
+	public void setSprinting(boolean bool) {
+		super.setSprinting(bool);
+	}
+
+	/**
+	 * Custom Shit
+	 */
+
+	protected float getField_82191_bN() {
+		Field v82191 = ReflectionUtils.getField(getClass(), "field_82191_bN");
+		try {
+			return v82191 != null ? v82191.getFloat(this) : 0f;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return 0f;
+		}
+	}
+
+	protected void setField_82191_bN(float f) {
+		try {
+			ReflectionUtils.setField(this, "field_82191_bN", f);
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	protected boolean getNeedsInitilization() {
+		Field v82191 = ReflectionUtils.getField(EntityVillager.class, "needsInitilization");
+		try {
+			return v82191 != null ? v82191.getBoolean(this) : false;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return false;
+		}
+	}
+
+	protected void setNeedsInitilization(boolean f) {
+		try {
+			ReflectionUtils.setField(this, "needsInitilization", f);
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	protected MerchantRecipeList getBuyingList() {
+		Field v82191;
+		MerchantRecipeList o = null;
+		v82191 = ReflectionUtils.getField(getClass(), "buyingList");
+		try {
+			if (v82191 != null)
+			o = (MerchantRecipeList) v82191.get(this);
+			Logger.WARNING("Is BuyingList Valid? " + (v82191 != null));
+			return v82191 != null ? o : null;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	protected void setBuyingList(MerchantRecipeList f) {
+		try {
+			Logger.WARNING("set BuyingList? "+(ReflectionUtils.setField(this, "buyingList", f)));
+		} catch (IllegalArgumentException e) {
+			e.printStackTrace();
+		}
+	}
+
+	protected Village getVillageObject() {
+		Field v82191 = ReflectionUtils.getField(getClass(), "villageObj");
+		try {
+			return v82191 != null ? (Village) v82191.get(this) : null;
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return null;
+		}
+	}
+
+	protected String getLastBuyingPlayer() {
+		Field v82191 = ReflectionUtils.getField(getClass(), "lastBuyingPlayer");
+		try {
+			return v82191 != null ? (String) v82191.get(this) : "";
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			return "";
+		}
+	}
+
+	public MerchantRecipeList getRecipes(EntityPlayer p_70934_1_) {
+		if (getBuyingList() == null) {
+			this.addDefaultEquipmentAndRecipies(1);
+		}
+		return getBuyingList();
+	}
+
+	/**
+	 * Adjusts the probability of obtaining a given recipe being offered by a
+	 * villager
+	 */
+	private float adjustProbability(float p_82188_1_) {
+		float f1 = p_82188_1_ + getField_82191_bN();
+		return f1 > 0.9F ? 0.9F - (f1 - 0.9F) : f1;
+	}
+
+	/**
+	 * based on the villagers profession add items, equipment, and recipies adds
+	 * par1 random items to the list of things that the villager wants to buy. (at
+	 * most 1 of each wanted type is added)
+	 */
+	private void addDefaultEquipmentAndRecipies(int p_70950_1_) {
+		if (this.getBuyingList() != null) {
+			setField_82191_bN(MathHelper.sqrt_float((float) this.getBuyingList().size()) * 0.2F);
+		} else {
+			setField_82191_bN(0.0F);
+		}
+
+		MerchantRecipeList merchantrecipelist;
+		merchantrecipelist = new MerchantRecipeList();
+		VillagerRegistry.manageVillagerTrades(merchantrecipelist, this, this.getProfession(), this.rand);
+		int k;
+		label50:
+
+			switch (this.getProfession()) {
+			case 0:
+				addPurchaseRecipe(merchantrecipelist, Items.wheat, this.rand, this.adjustProbability(0.9F));
+				addPurchaseRecipe(merchantrecipelist, Item.getItemFromBlock(Blocks.wool), this.rand,
+						this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.chicken, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.cooked_fished, this.rand, this.adjustProbability(0.4F));
+				addEmeraldTrade(merchantrecipelist, Items.bread, this.rand, this.adjustProbability(0.9F));
+				addEmeraldTrade(merchantrecipelist, Items.melon, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.apple, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cookie, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.shears, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.flint_and_steel, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cooked_chicken, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.arrow, this.rand, this.adjustProbability(0.5F));
+
+				if (this.rand.nextFloat() < this.adjustProbability(0.5F)) {
+					merchantrecipelist.add(new MerchantRecipe(new ItemStack(Blocks.gravel, 10),
+							new ItemStack(Items.emerald), new ItemStack(Items.flint, 4 + this.rand.nextInt(2), 0)));
+				}
+
+				break;
+			case 1:
+				addPurchaseRecipe(merchantrecipelist, Items.paper, this.rand, this.adjustProbability(0.8F));
+				addPurchaseRecipe(merchantrecipelist, Items.book, this.rand, this.adjustProbability(0.8F));
+				addPurchaseRecipe(merchantrecipelist, Items.written_book, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Item.getItemFromBlock(Blocks.bookshelf), this.rand,
+						this.adjustProbability(0.8F));
+				addEmeraldTrade(merchantrecipelist, Item.getItemFromBlock(Blocks.glass), this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.compass, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.clock, this.rand, this.adjustProbability(0.2F));
+
+				if (this.rand.nextFloat() < this.adjustProbability(0.07F)) {
+					Enchantment enchantment = Enchantment.enchantmentsBookList[this.rand
+					                                                           .nextInt(Enchantment.enchantmentsBookList.length)];
+					int i1 = MathHelper.getRandomIntegerInRange(this.rand, enchantment.getMinLevel(),
+							enchantment.getMaxLevel());
+					ItemStack itemstack = Items.enchanted_book.getEnchantedItemStack(new EnchantmentData(enchantment, i1));
+					k = 2 + this.rand.nextInt(5 + i1 * 10) + 3 * i1;
+					merchantrecipelist
+					.add(new MerchantRecipe(new ItemStack(Items.book), new ItemStack(Items.emerald, k), itemstack));
+				}
+
+				break;
+			case 2:
+				addEmeraldTrade(merchantrecipelist, Items.ender_eye, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.experience_bottle, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.redstone, this.rand, this.adjustProbability(0.4F));
+				addEmeraldTrade(merchantrecipelist, Item.getItemFromBlock(Blocks.glowstone), this.rand,
+						this.adjustProbability(0.3F));
+				Item[] aitem = new Item[] { Items.iron_sword, Items.diamond_sword, Items.iron_chestplate,
+						Items.diamond_chestplate, Items.iron_axe, Items.diamond_axe, Items.iron_pickaxe,
+						Items.diamond_pickaxe };
+				Item[] aitem1 = aitem;
+				int j = aitem.length;
+				k = 0;
+
+				while (true) {
+					if (k >= j) {
+						break label50;
+					}
+
+					Item item = aitem1[k];
+
+					if (this.rand.nextFloat() < this.adjustProbability(0.05F)) {
+						merchantrecipelist.add(new MerchantRecipe(new ItemStack(item, 1, 0),
+								new ItemStack(Items.emerald, 2 + this.rand.nextInt(3), 0),
+								EnchantmentHelper.addRandomEnchantment(this.rand, new ItemStack(item, 1, 0),
+										5 + this.rand.nextInt(15))));
+					}
+
+					++k;
+				}
+			case 3:
+				addPurchaseRecipe(merchantrecipelist, Items.coal, this.rand, this.adjustProbability(0.7F));
+				addPurchaseRecipe(merchantrecipelist, Items.iron_ingot, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.gold_ingot, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.diamond, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_sword, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_sword, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_axe, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_axe, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_pickaxe, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_pickaxe, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_shovel, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_shovel, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_hoe, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_hoe, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_boots, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_boots, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_helmet, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_helmet, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_chestplate, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_chestplate, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.iron_leggings, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.diamond_leggings, this.rand, this.adjustProbability(0.2F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_boots, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_helmet, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_chestplate, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.chainmail_leggings, this.rand, this.adjustProbability(0.1F));
+				break;
+			case 4:
+				addPurchaseRecipe(merchantrecipelist, Items.coal, this.rand, this.adjustProbability(0.7F));
+				addPurchaseRecipe(merchantrecipelist, Items.porkchop, this.rand, this.adjustProbability(0.5F));
+				addPurchaseRecipe(merchantrecipelist, Items.beef, this.rand, this.adjustProbability(0.5F));
+				addEmeraldTrade(merchantrecipelist, Items.saddle, this.rand, this.adjustProbability(0.1F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_chestplate, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_boots, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_helmet, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.leather_leggings, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cooked_porkchop, this.rand, this.adjustProbability(0.3F));
+				addEmeraldTrade(merchantrecipelist, Items.cooked_beef, this.rand, this.adjustProbability(0.3F));
+			}
+
+		if (merchantrecipelist.isEmpty()) {
+			addPurchaseRecipe(merchantrecipelist, Items.gold_ingot, this.rand, 1.0F);
+		}
+
+		Collections.shuffle(merchantrecipelist);
+
+		if (this.getBuyingList() == null) {
+			this.setBuyingList(new MerchantRecipeList());
+		}
+
+		for (int l = 0; l < p_70950_1_ && l < merchantrecipelist.size(); ++l) {
+			try {
+				this.getBuyingList().addToListWithCheck((MerchantRecipe) merchantrecipelist.get(l));
+			}
+			catch (Throwable t) {
+				Logger.INFO("Villager with ID "+this.entityUniqueID.toString()+" at  |  X: "+this.posX+"   Y: "+this.posY+"   Z: "+this.posZ+" may have corrupt trades, it is advised to remove/kill it.");
+			}
+		}
+
+		try {
+			if (this.getBuyingList() != null) {
+				for (Object g : this.getBuyingList()) {
+					if (g != null) {
+						if (g instanceof MerchantRecipe) {
+							MerchantRecipe m = (MerchantRecipe) g;
+							ItemStack selling = m.getItemToSell();
+							ItemStack[] buying = new ItemStack[] {m.getItemToBuy(), m.getSecondItemToBuy() != null ? m.getSecondItemToBuy() : null};
+							if (selling == null) {
+								Logger.WARNING("Villager is Selling an invalid item");
+							}
+							else if (buying[0] == null && buying[1] == null) {
+								Logger.WARNING("Villager is buying two invalid items");
+							}
+							else {
+								Logger.WARNING("Villager is Selling x"+selling.stackSize+selling.getDisplayName()+" for x"+buying[0].stackSize+" "+buying[0].getDisplayName()+buying[1] != null ? " and for x"+buying[1].stackSize+" "+buying[1].getDisplayName() : "");
+							}
+						}
+						else
+							Logger.WARNING("Found: "+g.getClass().getName());
+					}
+				}
+			}
+			else {
+
+			}
+		}
+		catch (Throwable t) {
+
+		}
+
+	}
+
+	/**
+	 * main AI tick function, replaces updateEntityActionState
+	 */
+	@Override
+	protected void updateAITick() {
+		if (!this.isTrading()) {
+			if (this.getNeedsInitilization()) {
+				if (this.getBuyingList().size() > 1) {
+					Iterator<MerchantRecipe> iterator = this.getBuyingList().iterator();
+
+					while (iterator.hasNext()) {
+						MerchantRecipe merchantrecipe = (MerchantRecipe) iterator.next();
+
+						if (merchantrecipe.isRecipeDisabled()) {
+							merchantrecipe.func_82783_a(this.rand.nextInt(6) + this.rand.nextInt(6) + 2);
+						}
+					}
+				}
+
+				this.addDefaultEquipmentAndRecipies(1);
+				this.setNeedsInitilization(false);
+
+				if (this.getVillageObject() != null && this.getLastBuyingPlayer() != null) {
+					this.worldObj.setEntityState(this, (byte) 14);
+					this.getVillageObject().setReputationForPlayer(this.getLastBuyingPlayer(), 1);
+				}
+			}
+		}
+		super.updateAITick();
+	}
+
+	public static void addEmeraldTrade(MerchantRecipeList aRecipeList, Item aItem, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {
+			int i = getLootAmount_BlacksmithSellingList(aItem, aRand);
+			ItemStack itemstack;
+			ItemStack itemstack1;
+
+			if (i < 0) {
+				itemstack = new ItemStack(Items.emerald, 1, 0);
+				itemstack1 = new ItemStack(aItem, -i, 0);
+			} else {
+				itemstack = new ItemStack(Items.emerald, i, 0);
+				itemstack1 = new ItemStack(aItem, 1, 0);
+			}
+
+			aRecipeList.add(new MerchantRecipe(itemstack, itemstack1));
+		}
+	}
+
+	public static void addCustomTrade(MerchantRecipeList aRecipeList, ItemStack aItem1, ItemStack aItem2, ItemStack aItem3, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {			
+			aRecipeList.add(new MerchantRecipe(aItem1, aItem2, aItem3));
+		}
+	}
+
+	private static int getLootAmount_BlacksmithSellingList(Item aItem, Random aRand) {
+		Tuple tuple = (Tuple) blacksmithSellingList.get(aItem);
+		return tuple == null ? 1
+				: (((Integer) tuple.getFirst()).intValue() >= ((Integer) tuple.getSecond()).intValue()
+				? ((Integer) tuple.getFirst()).intValue()
+						: ((Integer) tuple.getFirst()).intValue() + aRand.nextInt(
+								((Integer) tuple.getSecond()).intValue() - ((Integer) tuple.getFirst()).intValue()));
+	}
+
+	public static void addPurchaseRecipe(MerchantRecipeList aTradeList, Item aItem, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {
+			aTradeList.add(new MerchantRecipe(getSimpleLootStack(aItem, aRand), Items.emerald));
+		}
+	}
+
+	private static ItemStack getSimpleLootStack(Item aItem, Random aRand) {
+		return new ItemStack(aItem, getLootAmount_VillagerSellingList(aItem, aRand), 0);
+	}
+
+	public static void addPurchaseRecipe(MerchantRecipeList aTradeList, Item aItem, int aMeta, Random aRand, float aChance) {
+		if (aRand.nextFloat() < aChance) {
+			aTradeList.add(new MerchantRecipe(getComplexLootStack(aItem, aMeta, aRand), Items.emerald));
+		}
+	}
+
+	private static ItemStack getComplexLootStack(Item aItem, int aMeta, Random aRand) {
+		return new ItemStack(aItem, getLootAmount_VillagerSellingList(aItem, aRand), aMeta);
+	}
+
+	private static int getLootAmount_VillagerSellingList(Item aItem, Random aRand) {
+		Tuple tuple = (Tuple) villagersSellingList.get(aItem);
+		return tuple == null ? 1
+				: (((Integer) tuple.getFirst()).intValue() >= ((Integer) tuple.getSecond()).intValue()
+				? ((Integer) tuple.getFirst()).intValue()
+						: ((Integer) tuple.getFirst()).intValue() + aRand.nextInt(
+								((Integer) tuple.getSecond()).intValue() - ((Integer) tuple.getFirst()).intValue()));
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/entity/trade/BaseVillagerTrade.java b/src/main/java/gtPlusPlus/plugin/villagers/entity/trade/BaseVillagerTrade.java
new file mode 100644
index 0000000000..61db98e803
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/entity/trade/BaseVillagerTrade.java
@@ -0,0 +1,32 @@
+package gtPlusPlus.plugin.villagers.entity.trade;
+
+import java.util.Random;
+
+import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.village.MerchantRecipeList;
+
+public abstract class BaseVillagerTrade implements IVillageTradeHandler {
+
+
+	/*
+	Recently in my mod I started working on a new villager and after doing so I could not figure out to assign new trades to this villager.
+	Registering the villager
+	VillagerRegistry.instance().registerVillageTradeHandler(i, new TradeHandler());}
+    VillagerRegistry.instance().registerVillagerId(8);
+    VillagerRegistry.instance().registerVillagerSkin(8, new ResourceLocation("chow", "textures/dealer.png"));
+    VillagerRegistry.instance().getRegisteredVillagers();
+	In my trade handler for vanilla villagers it goes off case 0 for instance being the farmer. I thought that it being case 8 would represent the id 8 for the custom villager but it still doesn't work. Could anyone help me out with this please?
+	 * 
+	 * 
+	First, you'll need to make a new class that extends IVillageTradeHandler.
+	In the constructor, add ItemStacks of the items you want it to trade to an ArrayList,
+	then in the manipulateTradesForVillager method, have it make sure the villager is yours by using villager.getProfession() 
+	and your villager ID, then in a for loop use recipeList.addToListWithCheck to add new instances of MerchantRecipe to your villager's trade list.
+	Then, in your mod's main class, register the trade handler with VillageRegistry.instance().registerVillagerTradeHandler(villagerId, instanceOfTradeHandler);
+	 */
+
+	@Override
+	public abstract void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random);
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/tile/MobSpawnerCustomLogic.java b/src/main/java/gtPlusPlus/plugin/villagers/tile/MobSpawnerCustomLogic.java
new file mode 100644
index 0000000000..28416793f5
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/tile/MobSpawnerCustomLogic.java
@@ -0,0 +1,69 @@
+package gtPlusPlus.plugin.villagers.tile;
+
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import gtPlusPlus.core.block.ModBlocks;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.MobSpawnerBaseLogic;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+public class MobSpawnerCustomLogic extends MobSpawnerBaseLogic {
+
+	private TileEntityGenericSpawner mTile;
+
+	public MobSpawnerCustomLogic(TileEntityGenericSpawner tile) {
+		if (tile != null) {
+			mTile = tile;
+		}
+		
+		if (TileEntityGenericSpawner.mSpawners.get(mTile.getID()) != null) {
+			Class<Entity> c = TileEntityGenericSpawner.mSpawners.get(mTile.getID());
+			EntityRegistration x = EntityRegistry.instance().lookupModSpawn(c, false);
+			if (x != null) {
+				this.setEntityName(x.getEntityName());
+			}
+		}
+		
+	}
+
+	@Override
+	public void func_98267_a(int eventID) {
+		if (mTile != null) mTile.getWorldObj().addBlockEvent(mTile.xCoord, mTile.yCoord, mTile.zCoord, ModBlocks.blockCustomMobSpawner, eventID, 0);
+	}
+
+	@Override
+	public World getSpawnerWorld() {
+		if (mTile != null) return mTile.getWorldObj();
+		return null;
+	}
+
+	@Override
+	public int getSpawnerX() {
+		if (mTile != null) return mTile.xCoord;
+		return 0;
+	}
+
+	@Override
+	public int getSpawnerY() {
+		if (mTile != null) return mTile.yCoord;
+		return 0;
+	}
+
+	@Override
+	public int getSpawnerZ() {
+		if (mTile != null) return mTile.zCoord;
+		return 0;
+	}
+
+	@Override
+	public void setRandomEntity(MobSpawnerBaseLogic.WeightedRandomMinecart p_98277_1_) {
+		super.setRandomEntity(p_98277_1_);
+		if (mTile != null) {
+			if (this.getSpawnerWorld() != null) {
+				this.getSpawnerWorld().markBlockForUpdate(mTile.xCoord, mTile.yCoord, mTile.zCoord);
+			}
+		}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/tile/TileEntityGenericSpawner.java b/src/main/java/gtPlusPlus/plugin/villagers/tile/TileEntityGenericSpawner.java
new file mode 100644
index 0000000000..45b8c9941b
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/tile/TileEntityGenericSpawner.java
@@ -0,0 +1,245 @@
+package gtPlusPlus.plugin.villagers.tile;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.entity.Entity;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.MobSpawnerBaseLogic;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntityMobSpawner;
+
+public class TileEntityGenericSpawner extends TileEntityMobSpawner {
+
+	/*
+	 * Static Variables
+	 */
+
+	/** A HashMap storing string names of classes mapping to the actual java.lang.Class type. */
+	private static Map<?, ?> nameToClassMap_Ex = new HashMap<Object, Object>();
+	/** A HashMap storing the classes and mapping to the string names (reverse of nameToClassMap). */
+	private static Map<?, ?> classToNameMap_Ex = new HashMap<Object, Object>();
+
+	/**
+	 * The Mob Spawner Map
+	 */
+	public static HashMap<Integer, Class<Entity>> mSpawners = new HashMap<Integer, Class<Entity>>();
+
+	/**
+	 * Registers a New Mob Spawner Type
+	 * 
+	 * @param aID
+	 *            - the Spawner type ID
+	 * @param aEntity
+	 *            - the Entity which you'd like to spawn
+	 */
+	public static boolean registerNewMobSpawner(int aID, Class<Entity> aEntity) {
+		int registered = mSpawners.size();
+		Logger.INFO("Currently "+registered+" spawners are registered.");
+		if (!mSpawners.containsKey(aID) && !mSpawners.containsValue(aEntity)) {
+			mSpawners.put(aID, aEntity);
+		}
+		return mSpawners.size() > registered;
+	}
+
+	/*
+	 * Instance Variables
+	 */
+
+	/**
+	 * The {@link Entity} type which spawns.
+	 */
+	protected int mID;
+	private final Class mSpawnType;
+	private MobSpawnerCustomLogic spawnerLogic;
+
+	/*
+	 * Constructors
+	 */
+
+	/**
+	 * Constructs a new Spawner, based on an existing type registered.
+	 * 
+	 * @param aID
+	 *            - The ID in the {@link mSpawners} map.
+	 */
+	public TileEntityGenericSpawner(int aID) {
+		mID = aID;
+		if (mSpawners.get(aID) != null) {
+			mSpawnType = mSpawners.get(aID);
+		} else {
+			mSpawnType = null;
+		}
+
+		// Last thing to Init
+		generateLogicObject();
+	}
+
+	/**
+	 * Constructs a new Spawner, then registers it.
+	 * 
+	 * @param aID
+	 *            - The ID to be used in the {@link mSpawners} map.
+	 * @param aEntity
+	 *            - The {@link Entity} type which will be spawned.
+	 */
+	public TileEntityGenericSpawner(int aID, Entity aEntity) {
+		mID = aID;
+		if (aEntity != null) {
+			mSpawnType = aEntity.getClass();
+			if (mSpawners.containsKey(aID)) {
+				registerNewMobSpawner(aID, mSpawnType);
+			}
+		} else {
+			mSpawnType = null;
+		}
+
+		// Last thing to Init
+		generateLogicObject();
+	}
+
+	public final MobSpawnerCustomLogic getLogic() {
+		if (spawnerLogic == null || spawnerLogic.getSpawnerWorld() == null) {
+			generateLogicObject();
+		}
+		return spawnerLogic;
+	}
+
+	private final void generateLogicObject() {
+		spawnerLogic = new MobSpawnerCustomLogic(this);
+	}
+
+	public int getID() {
+		return this.mID;
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound p_145839_1_) {
+		if (hasInternalFieldBeenSet()) {
+			this.getLogic().readFromNBT(p_145839_1_);
+			this.xCoord = p_145839_1_.getInteger("x");
+			this.yCoord = p_145839_1_.getInteger("y");
+			this.zCoord = p_145839_1_.getInteger("z");
+			this.mID = p_145839_1_.getInteger("mID");
+		}
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound p_145841_1_) {
+		if (hasInternalFieldBeenSet()) {
+			String s = (String) classToNameMap_Ex.get(this.getClass());
+			if (s == null){				
+				for (Object g : classToNameMap_Ex.values()) {
+					if (g instanceof String) {
+						Logger.INFO("Found Translation for "+((Class) nameToClassMap_Ex.get(g)).getName()+": "+g);
+					}
+				}
+
+				//throw new RuntimeException(this.getClass() + " is missing a mapping! This is a bug!");
+				s = mSpawners.containsKey(this.mID) ? mSpawners.get(this.mID).getSimpleName() : "bad.class.name";  
+				p_145841_1_.setString("id", s);
+				Logger.WARNING(this.getClass() + " is missing a mapping! This is a bug! Used key: "+s);
+				p_145841_1_.setInteger("x", this.xCoord);
+				p_145841_1_.setInteger("y", this.yCoord);
+				p_145841_1_.setInteger("z", this.zCoord);
+				p_145841_1_.setInteger("mID", this.mID);
+			}
+			else {
+				Logger.INFO(this.getClass() + " is not missing a mapping! Used key: "+s);
+				p_145841_1_.setString("id", s);
+				p_145841_1_.setInteger("x", this.xCoord);
+				p_145841_1_.setInteger("y", this.yCoord);
+				p_145841_1_.setInteger("z", this.zCoord);
+				p_145841_1_.setInteger("mID", this.mID);
+			}
+			this.getLogic().writeToNBT(p_145841_1_);
+		}
+	}
+
+	@Override
+	public void updateEntity() {
+		if (Utils.isServer()) {
+			mTicks++;
+			if (hasInternalFieldBeenSet()) {
+				this.getLogic().updateSpawner();
+			}
+		}
+	}
+
+	private boolean isReady = false;
+	private long mTicks = 0;
+
+	private boolean hasInternalFieldBeenSet() {
+		if (isReady && mTicks % 200 != 0) {
+			return true;
+		} else {
+
+			if (Utils.isServer()) {
+				try {				
+					Map<?, ?> a1 = (Map<?, ?>) ReflectionUtils.getField(TileEntity.class, "nameToClassMap").get(this);
+					Map<?, ?> a2 = (Map<?, ?>) ReflectionUtils.getField(TileEntity.class, "classToNameMap").get(this);				
+					if (a1 != null) {
+						if (nameToClassMap_Ex == null) {
+							nameToClassMap_Ex = a1;
+						}
+						if (nameToClassMap_Ex != null) {
+							if (nameToClassMap_Ex.size() != a1.size()) {
+								nameToClassMap_Ex = a1;
+							}					
+						}
+					}
+					if (a2 != null) {
+						if (classToNameMap_Ex == null) {
+							classToNameMap_Ex = a2;			
+						}
+						if (classToNameMap_Ex != null) {
+							if (classToNameMap_Ex.size() != a2.size()) {
+								classToNameMap_Ex = a2;
+							}			
+						}
+						if (nameToClassMap_Ex != null && classToNameMap_Ex != null) {
+							//Logger.INFO("nameToClassMap_Ex has a size of "+nameToClassMap_Ex.size()+".");
+							//Logger.INFO("a1 has a size of "+a1.size()+".");
+							//Logger.INFO("classToNameMap_Ex has a size of "+classToNameMap_Ex.size()+".");
+							//Logger.INFO("a2 has a size of "+a2.size()+".");
+							isReady = true;
+							return true;
+						}
+					}				
+
+					/*Field mInternalLogicField = ReflectionUtils.getField(getClass(), "field_145882_a");
+				if (mInternalLogicField != null) {
+					MobSpawnerBaseLogic a = (MobSpawnerBaseLogic) mInternalLogicField.get(this);
+					if (a != null) {
+						ReflectionUtils.setField(this, "field_145882_a", getLogic());
+						if (a.equals(getLogic())) {
+							isReady = true;
+							return true;
+						}
+					}
+				}*/
+				} catch (IllegalArgumentException | IllegalAccessException e) {
+				}
+			}
+			return false;
+		}
+	}
+
+	/**
+	 * Called when a client event is received with the event number and argument,
+	 * see World.sendClientEvent
+	 */
+	@Override
+	public boolean receiveClientEvent(int p_145842_1_, int p_145842_2_) {
+		return this.spawnerLogic.setDelayToMin(p_145842_1_) ? true : super.receiveClientEvent(p_145842_1_, p_145842_2_);
+	}
+
+	@Override
+	public MobSpawnerBaseLogic func_145881_a() {
+		return this.spawnerLogic;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerAboriginal.java b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerAboriginal.java
new file mode 100644
index 0000000000..3baca10792
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerAboriginal.java
@@ -0,0 +1,161 @@
+package gtPlusPlus.plugin.villagers.trade;
+
+import static java.util.Collections.shuffle;
+
+import java.util.Collections;
+import java.util.Random;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+
+public class TradeHandlerAboriginal extends TradeHandlerBase {
+
+	private final static AutoMap<ItemStack> mInputs = new AutoMap<ItemStack>();
+	private final static AutoMap<ItemStack> mOutputs = new AutoMap<ItemStack>();
+	private static boolean initialised = false;
+
+	public static void init() {
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.anvil, 1));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.bookshelf, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.cactus, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.dirt, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.cobblestone, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.mossy_cobblestone, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.pumpkin, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.hardened_clay, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.log, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.obsidian, 8));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.wheat, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.gravel, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Blocks.sand, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.apple, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.emerald, 1));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.diamond, 1));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.baked_potato, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.beef, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.bone, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.bread, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.carrot, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.potato, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.poisonous_potato, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.chicken, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.porkchop, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.cooked_beef, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.cooked_chicken, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.cooked_porkchop, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.fish, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.cooked_fished, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.feather, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.egg, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.gold_nugget, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.leather, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.melon_seeds, 0));
+		mOutputs.put(ItemUtils.getSimpleStack(Items.reeds, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.wooden_door));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.log));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.log2));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.planks));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.sapling));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.sandstone));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.nether_brick));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.bookshelf));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.crafting_table));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.gravel));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.hardened_clay));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.cactus));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.quartz_block));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.stone));
+		mInputs.put(ItemUtils.getSimpleStack(Blocks.mossy_cobblestone));
+		mInputs.put(ItemUtils.getSimpleStack(Items.apple, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.emerald, 1));
+		mInputs.put(ItemUtils.getSimpleStack(Items.diamond, 1));
+		mInputs.put(ItemUtils.getSimpleStack(Items.baked_potato, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.beef, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.bone, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.bread, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.carrot, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.potato, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.poisonous_potato, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.chicken, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.porkchop, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.cooked_beef, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.cooked_chicken, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.cooked_porkchop, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.fish, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.cooked_fished, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.feather, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.egg, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.gold_nugget, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.leather, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.melon_seeds, 0));
+		mInputs.put(ItemUtils.getSimpleStack(Items.reeds, 0));		
+		initialised = true;
+	}
+
+
+	public TradeHandlerAboriginal() {
+		Logger.INFO("Created Trade Manager for 'Trader' villager profession type.");
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random) {		
+		if (!initialised) {
+			init();
+		}	
+		if (initialised) {
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			recipeList.add(new MerchantRecipe(getInput(), getInput(), getOutput()));
+			shuffle(recipeList);
+		}
+	}
+
+	private ItemStack getInput() {
+		ItemStack input = mInputs.get(MathUtils.randInt(0, mInputs.size()-1));
+		int outputSize = (input.stackSize == 0 ? (Math.max(MathUtils.randInt(1, 64), MathUtils.randInt(1, 32))) : input.stackSize);
+		return ItemUtils.getSimpleStack(input, outputSize);
+	}
+	
+	final static int MID_BOUND = 24;	
+	private ItemStack getOutput() {
+		ItemStack output = mOutputs.get(MathUtils.randInt(0, mOutputs.size()-1));
+		int outputSize = (output.stackSize == 0 ? (Math.min(MathUtils.randInt(MathUtils.randInt(1, MID_BOUND), MathUtils.randInt(MID_BOUND, 32)), MathUtils.randInt(MathUtils.randInt(12, MID_BOUND), MathUtils.randInt(MID_BOUND, 48)))) : output.stackSize);
+		return ItemUtils.getSimpleStack(output, outputSize);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerBanker.java b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerBanker.java
new file mode 100644
index 0000000000..215dc0683b
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerBanker.java
@@ -0,0 +1,27 @@
+package gtPlusPlus.plugin.villagers.trade;
+
+import java.util.Collections;
+import java.util.Random;
+
+import gtPlusPlus.core.recipe.common.CI;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+
+public class TradeHandlerBanker extends TradeHandlerBase {
+
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random) {
+		//if (villager.getProfession() == 7735) {
+			recipeList.add(new MerchantRecipe(CI.electricMotor_LV, CI.electricPiston_LV, CI.robotArm_LV));
+			recipeList.add(new MerchantRecipe(CI.electricMotor_MV, CI.electricPiston_MV, CI.robotArm_MV));
+			recipeList.add(new MerchantRecipe(CI.electricMotor_HV, CI.electricPiston_HV, CI.robotArm_HV));
+			recipeList.add(new MerchantRecipe(CI.electricMotor_EV, CI.electricPiston_EV, CI.robotArm_EV));
+			recipeList.add(new MerchantRecipe(CI.electricMotor_IV, CI.electricPiston_IV, CI.robotArm_IV));
+			//Collections.shuffle(recipeList);
+		//}			
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerBase.java b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerBase.java
new file mode 100644
index 0000000000..b726ebefff
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerBase.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2014 SirSengir.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v3
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl-3.0.txt
+ *
+ * Various Contributors including, but not limited to:
+ * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
+ ******************************************************************************/
+package gtPlusPlus.plugin.villagers.trade;
+
+import java.util.Random;
+
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.village.MerchantRecipeList;
+import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
+
+public abstract class TradeHandlerBase implements IVillageTradeHandler {
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public abstract void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random);
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerTechnician.java b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerTechnician.java
new file mode 100644
index 0000000000..922316b136
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerTechnician.java
@@ -0,0 +1,27 @@
+package gtPlusPlus.plugin.villagers.trade;
+
+import java.util.Collections;
+import java.util.Random;
+
+import gtPlusPlus.core.recipe.common.CI;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+
+public class TradeHandlerTechnician extends TradeHandlerBase {
+
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random) {
+		//if (villager.getProfession() == 7737) {
+			recipeList.add(new MerchantRecipe(CI.machineHull_LV, CI.electricMotor_LV, CI.machineHull_LV));
+			recipeList.add(new MerchantRecipe(CI.machineHull_MV, CI.electricMotor_MV, CI.machineHull_MV));
+			recipeList.add(new MerchantRecipe(CI.machineHull_HV, CI.electricMotor_HV, CI.machineHull_HV));
+			recipeList.add(new MerchantRecipe(CI.machineHull_EV, CI.electricMotor_EV, CI.machineHull_EV));
+			recipeList.add(new MerchantRecipe(CI.machineHull_IV, CI.electricMotor_IV, CI.machineHull_IV));
+			//Collections.shuffle(recipeList);	
+		//}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerTrader.java b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerTrader.java
new file mode 100644
index 0000000000..0025c054bd
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/villagers/trade/TradeHandlerTrader.java
@@ -0,0 +1,45 @@
+package gtPlusPlus.plugin.villagers.trade;
+
+import java.util.Collections;
+import java.util.Random;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.village.MerchantRecipe;
+import net.minecraft.village.MerchantRecipeList;
+
+public class TradeHandlerTrader extends TradeHandlerBase {
+
+	public TradeHandlerTrader() {
+		Logger.INFO("Created Trade Manager for 'Trader' villager profession type.");
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public void manipulateTradesForVillager(EntityVillager villager, MerchantRecipeList recipeList, Random random) {
+		ItemStack Ore1 = null, Ore2 = null;
+		if (Ore1 == null) {
+			Ore1 = ELEMENT.getInstance().SILICON.getOre(1);
+		}
+		if (Ore2 == null) {
+			Ore2 = ELEMENT.getInstance().ALUMINIUM.getOre(1);
+		}
+		if (Ore1 == null) {
+			Ore1 = ELEMENT.getInstance().GOLD.getOre(1);
+		}
+		if (Ore2 == null) {
+			Ore2 = ELEMENT.getInstance().LEAD.getOre(1);
+		}		
+		recipeList.add(new MerchantRecipe(ItemUtils.getItemStackOfAmountFromOreDict("logWood", 32), ELEMENT.getInstance().IRON.getOre(1)));
+		recipeList.add(new MerchantRecipe(ItemUtils.getItemStackOfAmountFromOreDict("dustMeatRaw", 32), ELEMENT.getInstance().COPPER.getOre(1)));
+		recipeList.add(new MerchantRecipe(ItemUtils.getSimpleStack(Blocks.obsidian, 6), ELEMENT.getInstance().TIN.getOre(1)));
+		recipeList.add(new MerchantRecipe(ItemUtils.getSimpleStack(Blocks.glowstone, 32), Ore1));
+		recipeList.add(new MerchantRecipe(ItemUtils.getSimpleStack(Blocks.piston, 32), Ore2));
+		Collections.shuffle(recipeList);	
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/plugin/waila/Core_WailaPlugin.java b/src/main/java/gtPlusPlus/plugin/waila/Core_WailaPlugin.java
new file mode 100644
index 0000000000..3317ef6a11
--- /dev/null
+++ b/src/main/java/gtPlusPlus/plugin/waila/Core_WailaPlugin.java
@@ -0,0 +1,59 @@
+package gtPlusPlus.plugin.waila;
+
+import gtPlusPlus.api.interfaces.IPlugin;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.plugin.manager.Core_Manager;
+
+public class Core_WailaPlugin implements IPlugin {
+
+	final static Core_WailaPlugin mInstance;
+	static boolean mActive = false;
+
+	static {
+		mInstance = new Core_WailaPlugin();
+		mInstance.log("Preparing "+mInstance.getPluginName()+" for use.");
+	}
+	
+	Core_WailaPlugin() {
+		Core_Manager.registerPlugin(this);
+	}
+	
+	@Override
+	public boolean preInit() {
+		if (LoadedMods.Waila) {
+			mActive = true;
+		}		
+		return mActive;
+	}
+
+	@Override
+	public boolean init() {
+		return mActive;
+	}
+
+	@Override
+	public boolean postInit() {
+		return mActive;
+	}
+
+	@Override
+	public boolean serverStart() {
+		return mActive;
+	}
+
+	@Override
+	public boolean serverStop() {
+		return mActive;
+	}
+
+	@Override
+	public String getPluginName() {
+		return "GT++ WAILA module";
+	}
+
+	@Override
+	public String getPluginAbbreviation() {
+		return "Look";
+	}
+
+}