package net.minecraft.world.gen;

import org.json.JSONException;
import org.json.JSONObject;

import net.lax1dude.eaglercraft.v1_8.json.JSONTypeCodec;
import net.lax1dude.eaglercraft.v1_8.json.JSONTypeProvider;
import net.minecraft.world.biome.BiomeGenBase;

/**+
 * This portion of EaglercraftX contains deobfuscated Minecraft 1.8 source code.
 * 
 * Minecraft 1.8.8 bytecode is (c) 2015 Mojang AB. "Do not distribute!"
 * Mod Coder Pack v9.18 deobfuscation configs are (c) Copyright by the MCP Team
 * 
 * EaglercraftX 1.8 patch files (c) 2022-2024 lax1dude, ayunami2000. All Rights Reserved.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 */
public class ChunkProviderSettings {
	public final float coordinateScale;
	public final float heightScale;
	public final float upperLimitScale;
	public final float lowerLimitScale;
	public final float depthNoiseScaleX;
	public final float depthNoiseScaleZ;
	public final float depthNoiseScaleExponent;
	public final float mainNoiseScaleX;
	public final float mainNoiseScaleY;
	public final float mainNoiseScaleZ;
	public final float baseSize;
	public final float stretchY;
	public final float biomeDepthWeight;
	public final float biomeDepthOffSet;
	public final float biomeScaleWeight;
	public final float biomeScaleOffset;
	public final int seaLevel;
	public final boolean useCaves;
	public final boolean useDungeons;
	public final int dungeonChance;
	public final boolean useStrongholds;
	public final boolean useVillages;
	public final boolean useMineShafts;
	public final boolean useTemples;
	public final boolean useMonuments;
	public final boolean useRavines;
	public final boolean useWaterLakes;
	public final int waterLakeChance;
	public final boolean useLavaLakes;
	public final int lavaLakeChance;
	public final boolean useLavaOceans;
	public final int fixedBiome;
	public final int biomeSize;
	public final int riverSize;
	public final int dirtSize;
	public final int dirtCount;
	public final int dirtMinHeight;
	public final int dirtMaxHeight;
	public final int gravelSize;
	public final int gravelCount;
	public final int gravelMinHeight;
	public final int gravelMaxHeight;
	public final int graniteSize;
	public final int graniteCount;
	public final int graniteMinHeight;
	public final int graniteMaxHeight;
	public final int dioriteSize;
	public final int dioriteCount;
	public final int dioriteMinHeight;
	public final int dioriteMaxHeight;
	public final int andesiteSize;
	public final int andesiteCount;
	public final int andesiteMinHeight;
	public final int andesiteMaxHeight;
	public final int coalSize;
	public final int coalCount;
	public final int coalMinHeight;
	public final int coalMaxHeight;
	public final int ironSize;
	public final int ironCount;
	public final int ironMinHeight;
	public final int ironMaxHeight;
	public final int goldSize;
	public final int goldCount;
	public final int goldMinHeight;
	public final int goldMaxHeight;
	public final int redstoneSize;
	public final int redstoneCount;
	public final int redstoneMinHeight;
	public final int redstoneMaxHeight;
	public final int diamondSize;
	public final int diamondCount;
	public final int diamondMinHeight;
	public final int diamondMaxHeight;
	public final int lapisSize;
	public final int lapisCount;
	public final int lapisCenterHeight;
	public final int lapisSpread;

	private ChunkProviderSettings(ChunkProviderSettings.Factory settingsFactory) {
		this.coordinateScale = settingsFactory.coordinateScale;
		this.heightScale = settingsFactory.heightScale;
		this.upperLimitScale = settingsFactory.upperLimitScale;
		this.lowerLimitScale = settingsFactory.lowerLimitScale;
		this.depthNoiseScaleX = settingsFactory.depthNoiseScaleX;
		this.depthNoiseScaleZ = settingsFactory.depthNoiseScaleZ;
		this.depthNoiseScaleExponent = settingsFactory.depthNoiseScaleExponent;
		this.mainNoiseScaleX = settingsFactory.mainNoiseScaleX;
		this.mainNoiseScaleY = settingsFactory.mainNoiseScaleY;
		this.mainNoiseScaleZ = settingsFactory.mainNoiseScaleZ;
		this.baseSize = settingsFactory.baseSize;
		this.stretchY = settingsFactory.stretchY;
		this.biomeDepthWeight = settingsFactory.biomeDepthWeight;
		this.biomeDepthOffSet = settingsFactory.biomeDepthOffset;
		this.biomeScaleWeight = settingsFactory.biomeScaleWeight;
		this.biomeScaleOffset = settingsFactory.biomeScaleOffset;
		this.seaLevel = settingsFactory.seaLevel;
		this.useCaves = settingsFactory.useCaves;
		this.useDungeons = settingsFactory.useDungeons;
		this.dungeonChance = settingsFactory.dungeonChance;
		this.useStrongholds = settingsFactory.useStrongholds;
		this.useVillages = settingsFactory.useVillages;
		this.useMineShafts = settingsFactory.useMineShafts;
		this.useTemples = settingsFactory.useTemples;
		this.useMonuments = settingsFactory.useMonuments;
		this.useRavines = settingsFactory.useRavines;
		this.useWaterLakes = settingsFactory.useWaterLakes;
		this.waterLakeChance = settingsFactory.waterLakeChance;
		this.useLavaLakes = settingsFactory.useLavaLakes;
		this.lavaLakeChance = settingsFactory.lavaLakeChance;
		this.useLavaOceans = settingsFactory.useLavaOceans;
		this.fixedBiome = settingsFactory.fixedBiome;
		this.biomeSize = settingsFactory.biomeSize;
		this.riverSize = settingsFactory.riverSize;
		this.dirtSize = settingsFactory.dirtSize;
		this.dirtCount = settingsFactory.dirtCount;
		this.dirtMinHeight = settingsFactory.dirtMinHeight;
		this.dirtMaxHeight = settingsFactory.dirtMaxHeight;
		this.gravelSize = settingsFactory.gravelSize;
		this.gravelCount = settingsFactory.gravelCount;
		this.gravelMinHeight = settingsFactory.gravelMinHeight;
		this.gravelMaxHeight = settingsFactory.gravelMaxHeight;
		this.graniteSize = settingsFactory.graniteSize;
		this.graniteCount = settingsFactory.graniteCount;
		this.graniteMinHeight = settingsFactory.graniteMinHeight;
		this.graniteMaxHeight = settingsFactory.graniteMaxHeight;
		this.dioriteSize = settingsFactory.dioriteSize;
		this.dioriteCount = settingsFactory.dioriteCount;
		this.dioriteMinHeight = settingsFactory.dioriteMinHeight;
		this.dioriteMaxHeight = settingsFactory.dioriteMaxHeight;
		this.andesiteSize = settingsFactory.andesiteSize;
		this.andesiteCount = settingsFactory.andesiteCount;
		this.andesiteMinHeight = settingsFactory.andesiteMinHeight;
		this.andesiteMaxHeight = settingsFactory.andesiteMaxHeight;
		this.coalSize = settingsFactory.coalSize;
		this.coalCount = settingsFactory.coalCount;
		this.coalMinHeight = settingsFactory.coalMinHeight;
		this.coalMaxHeight = settingsFactory.coalMaxHeight;
		this.ironSize = settingsFactory.ironSize;
		this.ironCount = settingsFactory.ironCount;
		this.ironMinHeight = settingsFactory.ironMinHeight;
		this.ironMaxHeight = settingsFactory.ironMaxHeight;
		this.goldSize = settingsFactory.goldSize;
		this.goldCount = settingsFactory.goldCount;
		this.goldMinHeight = settingsFactory.goldMinHeight;
		this.goldMaxHeight = settingsFactory.goldMaxHeight;
		this.redstoneSize = settingsFactory.redstoneSize;
		this.redstoneCount = settingsFactory.redstoneCount;
		this.redstoneMinHeight = settingsFactory.redstoneMinHeight;
		this.redstoneMaxHeight = settingsFactory.redstoneMaxHeight;
		this.diamondSize = settingsFactory.diamondSize;
		this.diamondCount = settingsFactory.diamondCount;
		this.diamondMinHeight = settingsFactory.diamondMinHeight;
		this.diamondMaxHeight = settingsFactory.diamondMaxHeight;
		this.lapisSize = settingsFactory.lapisSize;
		this.lapisCount = settingsFactory.lapisCount;
		this.lapisCenterHeight = settingsFactory.lapisCenterHeight;
		this.lapisSpread = settingsFactory.lapisSpread;
	}

	public static class Factory {
		public float coordinateScale = 684.412F;
		public float heightScale = 684.412F;
		public float upperLimitScale = 512.0F;
		public float lowerLimitScale = 512.0F;
		public float depthNoiseScaleX = 200.0F;
		public float depthNoiseScaleZ = 200.0F;
		public float depthNoiseScaleExponent = 0.5F;
		public float mainNoiseScaleX = 80.0F;
		public float mainNoiseScaleY = 160.0F;
		public float mainNoiseScaleZ = 80.0F;
		public float baseSize = 8.5F;
		public float stretchY = 12.0F;
		public float biomeDepthWeight = 1.0F;
		public float biomeDepthOffset = 0.0F;
		public float biomeScaleWeight = 1.0F;
		public float biomeScaleOffset = 0.0F;
		public int seaLevel = 63;
		public boolean useCaves = true;
		public boolean useDungeons = true;
		public int dungeonChance = 8;
		public boolean useStrongholds = true;
		public boolean useVillages = true;
		public boolean useMineShafts = true;
		public boolean useTemples = true;
		public boolean useMonuments = true;
		public boolean useRavines = true;
		public boolean useWaterLakes = true;
		public int waterLakeChance = 4;
		public boolean useLavaLakes = true;
		public int lavaLakeChance = 80;
		public boolean useLavaOceans = false;
		public int fixedBiome = -1;
		public int biomeSize = 4;
		public int riverSize = 4;
		public int dirtSize = 33;
		public int dirtCount = 10;
		public int dirtMinHeight = 0;
		public int dirtMaxHeight = 256;
		public int gravelSize = 33;
		public int gravelCount = 8;
		public int gravelMinHeight = 0;
		public int gravelMaxHeight = 256;
		public int graniteSize = 33;
		public int graniteCount = 10;
		public int graniteMinHeight = 0;
		public int graniteMaxHeight = 80;
		public int dioriteSize = 33;
		public int dioriteCount = 10;
		public int dioriteMinHeight = 0;
		public int dioriteMaxHeight = 80;
		public int andesiteSize = 33;
		public int andesiteCount = 10;
		public int andesiteMinHeight = 0;
		public int andesiteMaxHeight = 80;
		public int coalSize = 17;
		public int coalCount = 20;
		public int coalMinHeight = 0;
		public int coalMaxHeight = 128;
		public int ironSize = 9;
		public int ironCount = 20;
		public int ironMinHeight = 0;
		public int ironMaxHeight = 64;
		public int goldSize = 9;
		public int goldCount = 2;
		public int goldMinHeight = 0;
		public int goldMaxHeight = 32;
		public int redstoneSize = 8;
		public int redstoneCount = 8;
		public int redstoneMinHeight = 0;
		public int redstoneMaxHeight = 16;
		public int diamondSize = 8;
		public int diamondCount = 1;
		public int diamondMinHeight = 0;
		public int diamondMaxHeight = 16;
		public int lapisSize = 7;
		public int lapisCount = 1;
		public int lapisCenterHeight = 16;
		public int lapisSpread = 16;

		public static ChunkProviderSettings.Factory jsonToFactory(String parString1) {
			if (parString1.length() == 0) {
				return new ChunkProviderSettings.Factory();
			} else {
				try {
					return JSONTypeProvider.deserialize(parString1, ChunkProviderSettings.Factory.class);
				} catch (Exception var2) {
					return new ChunkProviderSettings.Factory();
				}
			}
		}

		public String toString() {
			return JSONTypeProvider.serialize(this).toString();
		}

		public Factory() {
			this.func_177863_a();
		}

		public void func_177863_a() {
			this.coordinateScale = 684.412F;
			this.heightScale = 684.412F;
			this.upperLimitScale = 512.0F;
			this.lowerLimitScale = 512.0F;
			this.depthNoiseScaleX = 200.0F;
			this.depthNoiseScaleZ = 200.0F;
			this.depthNoiseScaleExponent = 0.5F;
			this.mainNoiseScaleX = 80.0F;
			this.mainNoiseScaleY = 160.0F;
			this.mainNoiseScaleZ = 80.0F;
			this.baseSize = 8.5F;
			this.stretchY = 12.0F;
			this.biomeDepthWeight = 1.0F;
			this.biomeDepthOffset = 0.0F;
			this.biomeScaleWeight = 1.0F;
			this.biomeScaleOffset = 0.0F;
			this.seaLevel = 63;
			this.useCaves = true;
			this.useDungeons = true;
			this.dungeonChance = 8;
			this.useStrongholds = true;
			this.useVillages = true;
			this.useMineShafts = true;
			this.useTemples = true;
			this.useMonuments = true;
			this.useRavines = true;
			this.useWaterLakes = true;
			this.waterLakeChance = 4;
			this.useLavaLakes = true;
			this.lavaLakeChance = 80;
			this.useLavaOceans = false;
			this.fixedBiome = -1;
			this.biomeSize = 4;
			this.riverSize = 4;
			this.dirtSize = 33;
			this.dirtCount = 10;
			this.dirtMinHeight = 0;
			this.dirtMaxHeight = 256;
			this.gravelSize = 33;
			this.gravelCount = 8;
			this.gravelMinHeight = 0;
			this.gravelMaxHeight = 256;
			this.graniteSize = 33;
			this.graniteCount = 10;
			this.graniteMinHeight = 0;
			this.graniteMaxHeight = 80;
			this.dioriteSize = 33;
			this.dioriteCount = 10;
			this.dioriteMinHeight = 0;
			this.dioriteMaxHeight = 80;
			this.andesiteSize = 33;
			this.andesiteCount = 10;
			this.andesiteMinHeight = 0;
			this.andesiteMaxHeight = 80;
			this.coalSize = 17;
			this.coalCount = 20;
			this.coalMinHeight = 0;
			this.coalMaxHeight = 128;
			this.ironSize = 9;
			this.ironCount = 20;
			this.ironMinHeight = 0;
			this.ironMaxHeight = 64;
			this.goldSize = 9;
			this.goldCount = 2;
			this.goldMinHeight = 0;
			this.goldMaxHeight = 32;
			this.redstoneSize = 8;
			this.redstoneCount = 8;
			this.redstoneMinHeight = 0;
			this.redstoneMaxHeight = 16;
			this.diamondSize = 8;
			this.diamondCount = 1;
			this.diamondMinHeight = 0;
			this.diamondMaxHeight = 16;
			this.lapisSize = 7;
			this.lapisCount = 1;
			this.lapisCenterHeight = 16;
			this.lapisSpread = 16;
		}

		public boolean equals(Object object) {
			if (this == object) {
				return true;
			} else if (object != null && this.getClass() == object.getClass()) {
				ChunkProviderSettings.Factory chunkprovidersettings$factory = (ChunkProviderSettings.Factory) object;
				return this.andesiteCount != chunkprovidersettings$factory.andesiteCount ? false
						: (this.andesiteMaxHeight != chunkprovidersettings$factory.andesiteMaxHeight ? false
								: (this.andesiteMinHeight != chunkprovidersettings$factory.andesiteMinHeight ? false
										: (this.andesiteSize != chunkprovidersettings$factory.andesiteSize ? false
												: (Float.compare(chunkprovidersettings$factory.baseSize,
														this.baseSize) != 0 ? false
																: (Float.compare(
																		chunkprovidersettings$factory.biomeDepthOffset,
																		this.biomeDepthOffset) != 0 ? false
																				: (Float.compare(
																						chunkprovidersettings$factory.biomeDepthWeight,
																						this.biomeDepthWeight) != 0
																								? false
																								: (Float.compare(
																										chunkprovidersettings$factory.biomeScaleOffset,
																										this.biomeScaleOffset) != 0
																												? false
																												: (Float.compare(
																														chunkprovidersettings$factory.biomeScaleWeight,
																														this.biomeScaleWeight) != 0
																																? false
																																: (this.biomeSize != chunkprovidersettings$factory.biomeSize
																																		? false
																																		: (this.coalCount != chunkprovidersettings$factory.coalCount
																																				? false
																																				: (this.coalMaxHeight != chunkprovidersettings$factory.coalMaxHeight
																																						? false
																																						: (this.coalMinHeight != chunkprovidersettings$factory.coalMinHeight
																																								? false
																																								: (this.coalSize != chunkprovidersettings$factory.coalSize
																																										? false
																																										: (Float.compare(
																																												chunkprovidersettings$factory.coordinateScale,
																																												this.coordinateScale) != 0
																																														? false
																																														: (Float.compare(
																																																chunkprovidersettings$factory.depthNoiseScaleExponent,
																																																this.depthNoiseScaleExponent) != 0
																																																		? false
																																																		: (Float.compare(
																																																				chunkprovidersettings$factory.depthNoiseScaleX,
																																																				this.depthNoiseScaleX) != 0
																																																						? false
																																																						: (Float.compare(
																																																								chunkprovidersettings$factory.depthNoiseScaleZ,
																																																								this.depthNoiseScaleZ) != 0
																																																										? false
																																																										: (this.diamondCount != chunkprovidersettings$factory.diamondCount
																																																												? false
																																																												: (this.diamondMaxHeight != chunkprovidersettings$factory.diamondMaxHeight
																																																														? false
																																																														: (this.diamondMinHeight != chunkprovidersettings$factory.diamondMinHeight
																																																																? false
																																																																: (this.diamondSize != chunkprovidersettings$factory.diamondSize
																																																																		? false
																																																																		: (this.dioriteCount != chunkprovidersettings$factory.dioriteCount
																																																																				? false
																																																																				: (this.dioriteMaxHeight != chunkprovidersettings$factory.dioriteMaxHeight
																																																																						? false
																																																																						: (this.dioriteMinHeight != chunkprovidersettings$factory.dioriteMinHeight
																																																																								? false
																																																																								: (this.dioriteSize != chunkprovidersettings$factory.dioriteSize
																																																																										? false
																																																																										: (this.dirtCount != chunkprovidersettings$factory.dirtCount
																																																																												? false
																																																																												: (this.dirtMaxHeight != chunkprovidersettings$factory.dirtMaxHeight
																																																																														? false
																																																																														: (this.dirtMinHeight != chunkprovidersettings$factory.dirtMinHeight
																																																																																? false
																																																																																: (this.dirtSize != chunkprovidersettings$factory.dirtSize
																																																																																		? false
																																																																																		: (this.dungeonChance != chunkprovidersettings$factory.dungeonChance
																																																																																				? false
																																																																																				: (this.fixedBiome != chunkprovidersettings$factory.fixedBiome
																																																																																						? false
																																																																																						: (this.goldCount != chunkprovidersettings$factory.goldCount
																																																																																								? false
																																																																																								: (this.goldMaxHeight != chunkprovidersettings$factory.goldMaxHeight
																																																																																										? false
																																																																																										: (this.goldMinHeight != chunkprovidersettings$factory.goldMinHeight
																																																																																												? false
																																																																																												: (this.goldSize != chunkprovidersettings$factory.goldSize
																																																																																														? false
																																																																																														: (this.graniteCount != chunkprovidersettings$factory.graniteCount
																																																																																																? false
																																																																																																: (this.graniteMaxHeight != chunkprovidersettings$factory.graniteMaxHeight
																																																																																																		? false
																																																																																																		: (this.graniteMinHeight != chunkprovidersettings$factory.graniteMinHeight
																																																																																																				? false
																																																																																																				: (this.graniteSize != chunkprovidersettings$factory.graniteSize
																																																																																																						? false
																																																																																																						: (this.gravelCount != chunkprovidersettings$factory.gravelCount
																																																																																																								? false
																																																																																																								: (this.gravelMaxHeight != chunkprovidersettings$factory.gravelMaxHeight
																																																																																																										? false
																																																																																																										: (this.gravelMinHeight != chunkprovidersettings$factory.gravelMinHeight
																																																																																																												? false
																																																																																																												: (this.gravelSize != chunkprovidersettings$factory.gravelSize
																																																																																																														? false
																																																																																																														: (Float.compare(
																																																																																																																chunkprovidersettings$factory.heightScale,
																																																																																																																this.heightScale) != 0
																																																																																																																		? false
																																																																																																																		: (this.ironCount != chunkprovidersettings$factory.ironCount
																																																																																																																				? false
																																																																																																																				: (this.ironMaxHeight != chunkprovidersettings$factory.ironMaxHeight
																																																																																																																						? false
																																																																																																																						: (this.ironMinHeight != chunkprovidersettings$factory.ironMinHeight
																																																																																																																								? false
																																																																																																																								: (this.ironSize != chunkprovidersettings$factory.ironSize
																																																																																																																										? false
																																																																																																																										: (this.lapisCenterHeight != chunkprovidersettings$factory.lapisCenterHeight
																																																																																																																												? false
																																																																																																																												: (this.lapisCount != chunkprovidersettings$factory.lapisCount
																																																																																																																														? false
																																																																																																																														: (this.lapisSize != chunkprovidersettings$factory.lapisSize
																																																																																																																																? false
																																																																																																																																: (this.lapisSpread != chunkprovidersettings$factory.lapisSpread
																																																																																																																																		? false
																																																																																																																																		: (this.lavaLakeChance != chunkprovidersettings$factory.lavaLakeChance
																																																																																																																																				? false
																																																																																																																																				: (Float.compare(
																																																																																																																																						chunkprovidersettings$factory.lowerLimitScale,
																																																																																																																																						this.lowerLimitScale) != 0
																																																																																																																																								? false
																																																																																																																																								: (Float.compare(
																																																																																																																																										chunkprovidersettings$factory.mainNoiseScaleX,
																																																																																																																																										this.mainNoiseScaleX) != 0
																																																																																																																																												? false
																																																																																																																																												: (Float.compare(
																																																																																																																																														chunkprovidersettings$factory.mainNoiseScaleY,
																																																																																																																																														this.mainNoiseScaleY) != 0
																																																																																																																																																? false
																																																																																																																																																: (Float.compare(
																																																																																																																																																		chunkprovidersettings$factory.mainNoiseScaleZ,
																																																																																																																																																		this.mainNoiseScaleZ) != 0
																																																																																																																																																				? false
																																																																																																																																																				: (this.redstoneCount != chunkprovidersettings$factory.redstoneCount
																																																																																																																																																						? false
																																																																																																																																																						: (this.redstoneMaxHeight != chunkprovidersettings$factory.redstoneMaxHeight
																																																																																																																																																								? false
																																																																																																																																																								: (this.redstoneMinHeight != chunkprovidersettings$factory.redstoneMinHeight
																																																																																																																																																										? false
																																																																																																																																																										: (this.redstoneSize != chunkprovidersettings$factory.redstoneSize
																																																																																																																																																												? false
																																																																																																																																																												: (this.riverSize != chunkprovidersettings$factory.riverSize
																																																																																																																																																														? false
																																																																																																																																																														: (this.seaLevel != chunkprovidersettings$factory.seaLevel
																																																																																																																																																																? false
																																																																																																																																																																: (Float.compare(
																																																																																																																																																																		chunkprovidersettings$factory.stretchY,
																																																																																																																																																																		this.stretchY) != 0
																																																																																																																																																																				? false
																																																																																																																																																																				: (Float.compare(
																																																																																																																																																																						chunkprovidersettings$factory.upperLimitScale,
																																																																																																																																																																						this.upperLimitScale) != 0
																																																																																																																																																																								? false
																																																																																																																																																																								: (this.useCaves != chunkprovidersettings$factory.useCaves
																																																																																																																																																																										? false
																																																																																																																																																																										: (this.useDungeons != chunkprovidersettings$factory.useDungeons
																																																																																																																																																																												? false
																																																																																																																																																																												: (this.useLavaLakes != chunkprovidersettings$factory.useLavaLakes
																																																																																																																																																																														? false
																																																																																																																																																																														: (this.useLavaOceans != chunkprovidersettings$factory.useLavaOceans
																																																																																																																																																																																? false
																																																																																																																																																																																: (this.useMineShafts != chunkprovidersettings$factory.useMineShafts
																																																																																																																																																																																		? false
																																																																																																																																																																																		: (this.useRavines != chunkprovidersettings$factory.useRavines
																																																																																																																																																																																				? false
																																																																																																																																																																																				: (this.useStrongholds != chunkprovidersettings$factory.useStrongholds
																																																																																																																																																																																						? false
																																																																																																																																																																																						: (this.useTemples != chunkprovidersettings$factory.useTemples
																																																																																																																																																																																								? false
																																																																																																																																																																																								: (this.useMonuments != chunkprovidersettings$factory.useMonuments
																																																																																																																																																																																										? false
																																																																																																																																																																																										: (this.useVillages != chunkprovidersettings$factory.useVillages
																																																																																																																																																																																												? false
																																																																																																																																																																																												: (this.useWaterLakes != chunkprovidersettings$factory.useWaterLakes
																																																																																																																																																																																														? false
																																																																																																																																																																																														: this.waterLakeChance == chunkprovidersettings$factory.waterLakeChance))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))));
			} else {
				return false;
			}
		}

		public int hashCode() {
			int i = this.coordinateScale != 0.0F ? Float.floatToIntBits(this.coordinateScale) : 0;
			i = 31 * i + (this.heightScale != 0.0F ? Float.floatToIntBits(this.heightScale) : 0);
			i = 31 * i + (this.upperLimitScale != 0.0F ? Float.floatToIntBits(this.upperLimitScale) : 0);
			i = 31 * i + (this.lowerLimitScale != 0.0F ? Float.floatToIntBits(this.lowerLimitScale) : 0);
			i = 31 * i + (this.depthNoiseScaleX != 0.0F ? Float.floatToIntBits(this.depthNoiseScaleX) : 0);
			i = 31 * i + (this.depthNoiseScaleZ != 0.0F ? Float.floatToIntBits(this.depthNoiseScaleZ) : 0);
			i = 31 * i
					+ (this.depthNoiseScaleExponent != 0.0F ? Float.floatToIntBits(this.depthNoiseScaleExponent) : 0);
			i = 31 * i + (this.mainNoiseScaleX != 0.0F ? Float.floatToIntBits(this.mainNoiseScaleX) : 0);
			i = 31 * i + (this.mainNoiseScaleY != 0.0F ? Float.floatToIntBits(this.mainNoiseScaleY) : 0);
			i = 31 * i + (this.mainNoiseScaleZ != 0.0F ? Float.floatToIntBits(this.mainNoiseScaleZ) : 0);
			i = 31 * i + (this.baseSize != 0.0F ? Float.floatToIntBits(this.baseSize) : 0);
			i = 31 * i + (this.stretchY != 0.0F ? Float.floatToIntBits(this.stretchY) : 0);
			i = 31 * i + (this.biomeDepthWeight != 0.0F ? Float.floatToIntBits(this.biomeDepthWeight) : 0);
			i = 31 * i + (this.biomeDepthOffset != 0.0F ? Float.floatToIntBits(this.biomeDepthOffset) : 0);
			i = 31 * i + (this.biomeScaleWeight != 0.0F ? Float.floatToIntBits(this.biomeScaleWeight) : 0);
			i = 31 * i + (this.biomeScaleOffset != 0.0F ? Float.floatToIntBits(this.biomeScaleOffset) : 0);
			i = 31 * i + this.seaLevel;
			i = 31 * i + (this.useCaves ? 1 : 0);
			i = 31 * i + (this.useDungeons ? 1 : 0);
			i = 31 * i + this.dungeonChance;
			i = 31 * i + (this.useStrongholds ? 1 : 0);
			i = 31 * i + (this.useVillages ? 1 : 0);
			i = 31 * i + (this.useMineShafts ? 1 : 0);
			i = 31 * i + (this.useTemples ? 1 : 0);
			i = 31 * i + (this.useMonuments ? 1 : 0);
			i = 31 * i + (this.useRavines ? 1 : 0);
			i = 31 * i + (this.useWaterLakes ? 1 : 0);
			i = 31 * i + this.waterLakeChance;
			i = 31 * i + (this.useLavaLakes ? 1 : 0);
			i = 31 * i + this.lavaLakeChance;
			i = 31 * i + (this.useLavaOceans ? 1 : 0);
			i = 31 * i + this.fixedBiome;
			i = 31 * i + this.biomeSize;
			i = 31 * i + this.riverSize;
			i = 31 * i + this.dirtSize;
			i = 31 * i + this.dirtCount;
			i = 31 * i + this.dirtMinHeight;
			i = 31 * i + this.dirtMaxHeight;
			i = 31 * i + this.gravelSize;
			i = 31 * i + this.gravelCount;
			i = 31 * i + this.gravelMinHeight;
			i = 31 * i + this.gravelMaxHeight;
			i = 31 * i + this.graniteSize;
			i = 31 * i + this.graniteCount;
			i = 31 * i + this.graniteMinHeight;
			i = 31 * i + this.graniteMaxHeight;
			i = 31 * i + this.dioriteSize;
			i = 31 * i + this.dioriteCount;
			i = 31 * i + this.dioriteMinHeight;
			i = 31 * i + this.dioriteMaxHeight;
			i = 31 * i + this.andesiteSize;
			i = 31 * i + this.andesiteCount;
			i = 31 * i + this.andesiteMinHeight;
			i = 31 * i + this.andesiteMaxHeight;
			i = 31 * i + this.coalSize;
			i = 31 * i + this.coalCount;
			i = 31 * i + this.coalMinHeight;
			i = 31 * i + this.coalMaxHeight;
			i = 31 * i + this.ironSize;
			i = 31 * i + this.ironCount;
			i = 31 * i + this.ironMinHeight;
			i = 31 * i + this.ironMaxHeight;
			i = 31 * i + this.goldSize;
			i = 31 * i + this.goldCount;
			i = 31 * i + this.goldMinHeight;
			i = 31 * i + this.goldMaxHeight;
			i = 31 * i + this.redstoneSize;
			i = 31 * i + this.redstoneCount;
			i = 31 * i + this.redstoneMinHeight;
			i = 31 * i + this.redstoneMaxHeight;
			i = 31 * i + this.diamondSize;
			i = 31 * i + this.diamondCount;
			i = 31 * i + this.diamondMinHeight;
			i = 31 * i + this.diamondMaxHeight;
			i = 31 * i + this.lapisSize;
			i = 31 * i + this.lapisCount;
			i = 31 * i + this.lapisCenterHeight;
			i = 31 * i + this.lapisSpread;
			return i;
		}

		public ChunkProviderSettings func_177864_b() {
			return new ChunkProviderSettings(this);
		}
	}

	public static class Serializer implements JSONTypeCodec<ChunkProviderSettings.Factory, JSONObject> {
		public ChunkProviderSettings.Factory deserialize(JSONObject jsonobject) throws JSONException {
			ChunkProviderSettings.Factory chunkprovidersettings$factory = new ChunkProviderSettings.Factory();

			try {
				chunkprovidersettings$factory.coordinateScale = jsonobject.optFloat("coordinateScale",
						chunkprovidersettings$factory.coordinateScale);
				chunkprovidersettings$factory.heightScale = jsonobject.optFloat("heightScale",
						chunkprovidersettings$factory.heightScale);
				chunkprovidersettings$factory.lowerLimitScale = jsonobject.optFloat("lowerLimitScale",
						chunkprovidersettings$factory.lowerLimitScale);
				chunkprovidersettings$factory.upperLimitScale = jsonobject.optFloat("upperLimitScale",
						chunkprovidersettings$factory.upperLimitScale);
				chunkprovidersettings$factory.depthNoiseScaleX = jsonobject.optFloat("depthNoiseScaleX",
						chunkprovidersettings$factory.depthNoiseScaleX);
				chunkprovidersettings$factory.depthNoiseScaleZ = jsonobject.optFloat("depthNoiseScaleZ",
						chunkprovidersettings$factory.depthNoiseScaleZ);
				chunkprovidersettings$factory.depthNoiseScaleExponent = jsonobject.optFloat("depthNoiseScaleExponent",
						chunkprovidersettings$factory.depthNoiseScaleExponent);
				chunkprovidersettings$factory.mainNoiseScaleX = jsonobject.optFloat("mainNoiseScaleX",
						chunkprovidersettings$factory.mainNoiseScaleX);
				chunkprovidersettings$factory.mainNoiseScaleY = jsonobject.optFloat("mainNoiseScaleY",
						chunkprovidersettings$factory.mainNoiseScaleY);
				chunkprovidersettings$factory.mainNoiseScaleZ = jsonobject.optFloat("mainNoiseScaleZ",
						chunkprovidersettings$factory.mainNoiseScaleZ);
				chunkprovidersettings$factory.baseSize = jsonobject.optFloat("baseSize",
						chunkprovidersettings$factory.baseSize);
				chunkprovidersettings$factory.stretchY = jsonobject.optFloat("stretchY",
						chunkprovidersettings$factory.stretchY);
				chunkprovidersettings$factory.biomeDepthWeight = jsonobject.optFloat("biomeDepthWeight",
						chunkprovidersettings$factory.biomeDepthWeight);
				chunkprovidersettings$factory.biomeDepthOffset = jsonobject.optFloat("biomeDepthOffset",
						chunkprovidersettings$factory.biomeDepthOffset);
				chunkprovidersettings$factory.biomeScaleWeight = jsonobject.optFloat("biomeScaleWeight",
						chunkprovidersettings$factory.biomeScaleWeight);
				chunkprovidersettings$factory.biomeScaleOffset = jsonobject.optFloat("biomeScaleOffset",
						chunkprovidersettings$factory.biomeScaleOffset);
				chunkprovidersettings$factory.seaLevel = jsonobject.optInt("seaLevel",
						chunkprovidersettings$factory.seaLevel);
				chunkprovidersettings$factory.useCaves = jsonobject.optBoolean("useCaves",
						chunkprovidersettings$factory.useCaves);
				chunkprovidersettings$factory.useDungeons = jsonobject.optBoolean("useDungeons",
						chunkprovidersettings$factory.useDungeons);
				chunkprovidersettings$factory.dungeonChance = jsonobject.optInt("dungeonChance",
						chunkprovidersettings$factory.dungeonChance);
				chunkprovidersettings$factory.useStrongholds = jsonobject.optBoolean("useStrongholds",
						chunkprovidersettings$factory.useStrongholds);
				chunkprovidersettings$factory.useVillages = jsonobject.optBoolean("useVillages",
						chunkprovidersettings$factory.useVillages);
				chunkprovidersettings$factory.useMineShafts = jsonobject.optBoolean("useMineShafts",
						chunkprovidersettings$factory.useMineShafts);
				chunkprovidersettings$factory.useTemples = jsonobject.optBoolean("useTemples",
						chunkprovidersettings$factory.useTemples);
				chunkprovidersettings$factory.useMonuments = jsonobject.optBoolean("useMonuments",
						chunkprovidersettings$factory.useMonuments);
				chunkprovidersettings$factory.useRavines = jsonobject.optBoolean("useRavines",
						chunkprovidersettings$factory.useRavines);
				chunkprovidersettings$factory.useWaterLakes = jsonobject.optBoolean("useWaterLakes",
						chunkprovidersettings$factory.useWaterLakes);
				chunkprovidersettings$factory.waterLakeChance = jsonobject.optInt("waterLakeChance",
						chunkprovidersettings$factory.waterLakeChance);
				chunkprovidersettings$factory.useLavaLakes = jsonobject.optBoolean("useLavaLakes",
						chunkprovidersettings$factory.useLavaLakes);
				chunkprovidersettings$factory.lavaLakeChance = jsonobject.optInt("lavaLakeChance",
						chunkprovidersettings$factory.lavaLakeChance);
				chunkprovidersettings$factory.useLavaOceans = jsonobject.optBoolean("useLavaOceans",
						chunkprovidersettings$factory.useLavaOceans);
				chunkprovidersettings$factory.fixedBiome = jsonobject.optInt("fixedBiome",
						chunkprovidersettings$factory.fixedBiome);
				if (chunkprovidersettings$factory.fixedBiome < 38 && chunkprovidersettings$factory.fixedBiome >= -1) {
					if (chunkprovidersettings$factory.fixedBiome >= BiomeGenBase.hell.biomeID) {
						chunkprovidersettings$factory.fixedBiome += 2;
					}
				} else {
					chunkprovidersettings$factory.fixedBiome = -1;
				}

				chunkprovidersettings$factory.biomeSize = jsonobject.optInt("biomeSize",
						chunkprovidersettings$factory.biomeSize);
				chunkprovidersettings$factory.riverSize = jsonobject.optInt("riverSize",
						chunkprovidersettings$factory.riverSize);
				chunkprovidersettings$factory.dirtSize = jsonobject.optInt("dirtSize",
						chunkprovidersettings$factory.dirtSize);
				chunkprovidersettings$factory.dirtCount = jsonobject.optInt("dirtCount",
						chunkprovidersettings$factory.dirtCount);
				chunkprovidersettings$factory.dirtMinHeight = jsonobject.optInt("dirtMinHeight",
						chunkprovidersettings$factory.dirtMinHeight);
				chunkprovidersettings$factory.dirtMaxHeight = jsonobject.optInt("dirtMaxHeight",
						chunkprovidersettings$factory.dirtMaxHeight);
				chunkprovidersettings$factory.gravelSize = jsonobject.optInt("gravelSize",
						chunkprovidersettings$factory.gravelSize);
				chunkprovidersettings$factory.gravelCount = jsonobject.optInt("gravelCount",
						chunkprovidersettings$factory.gravelCount);
				chunkprovidersettings$factory.gravelMinHeight = jsonobject.optInt("gravelMinHeight",
						chunkprovidersettings$factory.gravelMinHeight);
				chunkprovidersettings$factory.gravelMaxHeight = jsonobject.optInt("gravelMaxHeight",
						chunkprovidersettings$factory.gravelMaxHeight);
				chunkprovidersettings$factory.graniteSize = jsonobject.optInt("graniteSize",
						chunkprovidersettings$factory.graniteSize);
				chunkprovidersettings$factory.graniteCount = jsonobject.optInt("graniteCount",
						chunkprovidersettings$factory.graniteCount);
				chunkprovidersettings$factory.graniteMinHeight = jsonobject.optInt("graniteMinHeight",
						chunkprovidersettings$factory.graniteMinHeight);
				chunkprovidersettings$factory.graniteMaxHeight = jsonobject.optInt("graniteMaxHeight",
						chunkprovidersettings$factory.graniteMaxHeight);
				chunkprovidersettings$factory.dioriteSize = jsonobject.optInt("dioriteSize",
						chunkprovidersettings$factory.dioriteSize);
				chunkprovidersettings$factory.dioriteCount = jsonobject.optInt("dioriteCount",
						chunkprovidersettings$factory.dioriteCount);
				chunkprovidersettings$factory.dioriteMinHeight = jsonobject.optInt("dioriteMinHeight",
						chunkprovidersettings$factory.dioriteMinHeight);
				chunkprovidersettings$factory.dioriteMaxHeight = jsonobject.optInt("dioriteMaxHeight",
						chunkprovidersettings$factory.dioriteMaxHeight);
				chunkprovidersettings$factory.andesiteSize = jsonobject.optInt("andesiteSize",
						chunkprovidersettings$factory.andesiteSize);
				chunkprovidersettings$factory.andesiteCount = jsonobject.optInt("andesiteCount",
						chunkprovidersettings$factory.andesiteCount);
				chunkprovidersettings$factory.andesiteMinHeight = jsonobject.optInt("andesiteMinHeight",
						chunkprovidersettings$factory.andesiteMinHeight);
				chunkprovidersettings$factory.andesiteMaxHeight = jsonobject.optInt("andesiteMaxHeight",
						chunkprovidersettings$factory.andesiteMaxHeight);
				chunkprovidersettings$factory.coalSize = jsonobject.optInt("coalSize",
						chunkprovidersettings$factory.coalSize);
				chunkprovidersettings$factory.coalCount = jsonobject.optInt("coalCount",
						chunkprovidersettings$factory.coalCount);
				chunkprovidersettings$factory.coalMinHeight = jsonobject.optInt("coalMinHeight",
						chunkprovidersettings$factory.coalMinHeight);
				chunkprovidersettings$factory.coalMaxHeight = jsonobject.optInt("coalMaxHeight",
						chunkprovidersettings$factory.coalMaxHeight);
				chunkprovidersettings$factory.ironSize = jsonobject.optInt("ironSize",
						chunkprovidersettings$factory.ironSize);
				chunkprovidersettings$factory.ironCount = jsonobject.optInt("ironCount",
						chunkprovidersettings$factory.ironCount);
				chunkprovidersettings$factory.ironMinHeight = jsonobject.optInt("ironMinHeight",
						chunkprovidersettings$factory.ironMinHeight);
				chunkprovidersettings$factory.ironMaxHeight = jsonobject.optInt("ironMaxHeight",
						chunkprovidersettings$factory.ironMaxHeight);
				chunkprovidersettings$factory.goldSize = jsonobject.optInt("goldSize",
						chunkprovidersettings$factory.goldSize);
				chunkprovidersettings$factory.goldCount = jsonobject.optInt("goldCount",
						chunkprovidersettings$factory.goldCount);
				chunkprovidersettings$factory.goldMinHeight = jsonobject.optInt("goldMinHeight",
						chunkprovidersettings$factory.goldMinHeight);
				chunkprovidersettings$factory.goldMaxHeight = jsonobject.optInt("goldMaxHeight",
						chunkprovidersettings$factory.goldMaxHeight);
				chunkprovidersettings$factory.redstoneSize = jsonobject.optInt("redstoneSize",
						chunkprovidersettings$factory.redstoneSize);
				chunkprovidersettings$factory.redstoneCount = jsonobject.optInt("redstoneCount",
						chunkprovidersettings$factory.redstoneCount);
				chunkprovidersettings$factory.redstoneMinHeight = jsonobject.optInt("redstoneMinHeight",
						chunkprovidersettings$factory.redstoneMinHeight);
				chunkprovidersettings$factory.redstoneMaxHeight = jsonobject.optInt("redstoneMaxHeight",
						chunkprovidersettings$factory.redstoneMaxHeight);
				chunkprovidersettings$factory.diamondSize = jsonobject.optInt("diamondSize",
						chunkprovidersettings$factory.diamondSize);
				chunkprovidersettings$factory.diamondCount = jsonobject.optInt("diamondCount",
						chunkprovidersettings$factory.diamondCount);
				chunkprovidersettings$factory.diamondMinHeight = jsonobject.optInt("diamondMinHeight",
						chunkprovidersettings$factory.diamondMinHeight);
				chunkprovidersettings$factory.diamondMaxHeight = jsonobject.optInt("diamondMaxHeight",
						chunkprovidersettings$factory.diamondMaxHeight);
				chunkprovidersettings$factory.lapisSize = jsonobject.optInt("lapisSize",
						chunkprovidersettings$factory.lapisSize);
				chunkprovidersettings$factory.lapisCount = jsonobject.optInt("lapisCount",
						chunkprovidersettings$factory.lapisCount);
				chunkprovidersettings$factory.lapisCenterHeight = jsonobject.optInt("lapisCenterHeight",
						chunkprovidersettings$factory.lapisCenterHeight);
				chunkprovidersettings$factory.lapisSpread = jsonobject.optInt("lapisSpread",
						chunkprovidersettings$factory.lapisSpread);
			} catch (Exception var7) {
				;
			}

			return chunkprovidersettings$factory;
		}

		public JSONObject serialize(ChunkProviderSettings.Factory parFactory) throws JSONException {
			JSONObject jsonobject = new JSONObject();
			jsonobject.put("coordinateScale", Float.valueOf(parFactory.coordinateScale));
			jsonobject.put("heightScale", Float.valueOf(parFactory.heightScale));
			jsonobject.put("lowerLimitScale", Float.valueOf(parFactory.lowerLimitScale));
			jsonobject.put("upperLimitScale", Float.valueOf(parFactory.upperLimitScale));
			jsonobject.put("depthNoiseScaleX", Float.valueOf(parFactory.depthNoiseScaleX));
			jsonobject.put("depthNoiseScaleZ", Float.valueOf(parFactory.depthNoiseScaleZ));
			jsonobject.put("depthNoiseScaleExponent", Float.valueOf(parFactory.depthNoiseScaleExponent));
			jsonobject.put("mainNoiseScaleX", Float.valueOf(parFactory.mainNoiseScaleX));
			jsonobject.put("mainNoiseScaleY", Float.valueOf(parFactory.mainNoiseScaleY));
			jsonobject.put("mainNoiseScaleZ", Float.valueOf(parFactory.mainNoiseScaleZ));
			jsonobject.put("baseSize", Float.valueOf(parFactory.baseSize));
			jsonobject.put("stretchY", Float.valueOf(parFactory.stretchY));
			jsonobject.put("biomeDepthWeight", Float.valueOf(parFactory.biomeDepthWeight));
			jsonobject.put("biomeDepthOffset", Float.valueOf(parFactory.biomeDepthOffset));
			jsonobject.put("biomeScaleWeight", Float.valueOf(parFactory.biomeScaleWeight));
			jsonobject.put("biomeScaleOffset", Float.valueOf(parFactory.biomeScaleOffset));
			jsonobject.put("seaLevel", Integer.valueOf(parFactory.seaLevel));
			jsonobject.put("useCaves", Boolean.valueOf(parFactory.useCaves));
			jsonobject.put("useDungeons", Boolean.valueOf(parFactory.useDungeons));
			jsonobject.put("dungeonChance", Integer.valueOf(parFactory.dungeonChance));
			jsonobject.put("useStrongholds", Boolean.valueOf(parFactory.useStrongholds));
			jsonobject.put("useVillages", Boolean.valueOf(parFactory.useVillages));
			jsonobject.put("useMineShafts", Boolean.valueOf(parFactory.useMineShafts));
			jsonobject.put("useTemples", Boolean.valueOf(parFactory.useTemples));
			jsonobject.put("useMonuments", Boolean.valueOf(parFactory.useMonuments));
			jsonobject.put("useRavines", Boolean.valueOf(parFactory.useRavines));
			jsonobject.put("useWaterLakes", Boolean.valueOf(parFactory.useWaterLakes));
			jsonobject.put("waterLakeChance", Integer.valueOf(parFactory.waterLakeChance));
			jsonobject.put("useLavaLakes", Boolean.valueOf(parFactory.useLavaLakes));
			jsonobject.put("lavaLakeChance", Integer.valueOf(parFactory.lavaLakeChance));
			jsonobject.put("useLavaOceans", Boolean.valueOf(parFactory.useLavaOceans));
			jsonobject.put("fixedBiome", Integer.valueOf(parFactory.fixedBiome));
			jsonobject.put("biomeSize", Integer.valueOf(parFactory.biomeSize));
			jsonobject.put("riverSize", Integer.valueOf(parFactory.riverSize));
			jsonobject.put("dirtSize", Integer.valueOf(parFactory.dirtSize));
			jsonobject.put("dirtCount", Integer.valueOf(parFactory.dirtCount));
			jsonobject.put("dirtMinHeight", Integer.valueOf(parFactory.dirtMinHeight));
			jsonobject.put("dirtMaxHeight", Integer.valueOf(parFactory.dirtMaxHeight));
			jsonobject.put("gravelSize", Integer.valueOf(parFactory.gravelSize));
			jsonobject.put("gravelCount", Integer.valueOf(parFactory.gravelCount));
			jsonobject.put("gravelMinHeight", Integer.valueOf(parFactory.gravelMinHeight));
			jsonobject.put("gravelMaxHeight", Integer.valueOf(parFactory.gravelMaxHeight));
			jsonobject.put("graniteSize", Integer.valueOf(parFactory.graniteSize));
			jsonobject.put("graniteCount", Integer.valueOf(parFactory.graniteCount));
			jsonobject.put("graniteMinHeight", Integer.valueOf(parFactory.graniteMinHeight));
			jsonobject.put("graniteMaxHeight", Integer.valueOf(parFactory.graniteMaxHeight));
			jsonobject.put("dioriteSize", Integer.valueOf(parFactory.dioriteSize));
			jsonobject.put("dioriteCount", Integer.valueOf(parFactory.dioriteCount));
			jsonobject.put("dioriteMinHeight", Integer.valueOf(parFactory.dioriteMinHeight));
			jsonobject.put("dioriteMaxHeight", Integer.valueOf(parFactory.dioriteMaxHeight));
			jsonobject.put("andesiteSize", Integer.valueOf(parFactory.andesiteSize));
			jsonobject.put("andesiteCount", Integer.valueOf(parFactory.andesiteCount));
			jsonobject.put("andesiteMinHeight", Integer.valueOf(parFactory.andesiteMinHeight));
			jsonobject.put("andesiteMaxHeight", Integer.valueOf(parFactory.andesiteMaxHeight));
			jsonobject.put("coalSize", Integer.valueOf(parFactory.coalSize));
			jsonobject.put("coalCount", Integer.valueOf(parFactory.coalCount));
			jsonobject.put("coalMinHeight", Integer.valueOf(parFactory.coalMinHeight));
			jsonobject.put("coalMaxHeight", Integer.valueOf(parFactory.coalMaxHeight));
			jsonobject.put("ironSize", Integer.valueOf(parFactory.ironSize));
			jsonobject.put("ironCount", Integer.valueOf(parFactory.ironCount));
			jsonobject.put("ironMinHeight", Integer.valueOf(parFactory.ironMinHeight));
			jsonobject.put("ironMaxHeight", Integer.valueOf(parFactory.ironMaxHeight));
			jsonobject.put("goldSize", Integer.valueOf(parFactory.goldSize));
			jsonobject.put("goldCount", Integer.valueOf(parFactory.goldCount));
			jsonobject.put("goldMinHeight", Integer.valueOf(parFactory.goldMinHeight));
			jsonobject.put("goldMaxHeight", Integer.valueOf(parFactory.goldMaxHeight));
			jsonobject.put("redstoneSize", Integer.valueOf(parFactory.redstoneSize));
			jsonobject.put("redstoneCount", Integer.valueOf(parFactory.redstoneCount));
			jsonobject.put("redstoneMinHeight", Integer.valueOf(parFactory.redstoneMinHeight));
			jsonobject.put("redstoneMaxHeight", Integer.valueOf(parFactory.redstoneMaxHeight));
			jsonobject.put("diamondSize", Integer.valueOf(parFactory.diamondSize));
			jsonobject.put("diamondCount", Integer.valueOf(parFactory.diamondCount));
			jsonobject.put("diamondMinHeight", Integer.valueOf(parFactory.diamondMinHeight));
			jsonobject.put("diamondMaxHeight", Integer.valueOf(parFactory.diamondMaxHeight));
			jsonobject.put("lapisSize", Integer.valueOf(parFactory.lapisSize));
			jsonobject.put("lapisCount", Integer.valueOf(parFactory.lapisCount));
			jsonobject.put("lapisCenterHeight", Integer.valueOf(parFactory.lapisCenterHeight));
			jsonobject.put("lapisSpread", Integer.valueOf(parFactory.lapisSpread));
			return jsonobject;
		}
	}
}