using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using HarmonyLib;
using LitJson2;
using UnityEngine;
using UpgradeWorld;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BalrondTreesNDecor")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BalrondTreesNDecor")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("cde312a0-cf19-4264-8616-e1c74774beed")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public static class BalrondHashCompat
{
	private static readonly MethodInfo _getStableHashCodeStringBool;

	private static readonly MethodInfo _getStableHashCodeString;

	private static readonly bool _initialized;

	static BalrondHashCompat()
	{
		try
		{
			Type typeFromHandle = typeof(StringExtensionMethods);
			_getStableHashCodeStringBool = typeFromHandle.GetMethod("GetStableHashCode", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(bool)
			}, null);
			_getStableHashCodeString = typeFromHandle.GetMethod("GetStableHashCode", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
			_initialized = true;
		}
		catch
		{
			_initialized = false;
		}
	}

	public static int StableHash(string value)
	{
		if (value == null)
		{
			return 0;
		}
		try
		{
			if (_getStableHashCodeStringBool != null)
			{
				return (int)_getStableHashCodeStringBool.Invoke(null, new object[2] { value, false });
			}
			if (_getStableHashCodeString != null)
			{
				return (int)_getStableHashCodeString.Invoke(null, new object[1] { value });
			}
		}
		catch
		{
		}
		return FallbackStableHash(value);
	}

	private static int FallbackStableHash(string value)
	{
		int num = 5381;
		int num2 = num;
		for (int i = 0; i < value.Length; i += 2)
		{
			num = ((num << 5) + num) ^ value[i];
			if (i == value.Length - 1)
			{
				break;
			}
			num2 = ((num2 << 5) + num2) ^ value[i + 1];
		}
		return num + num2 * 1566083941;
	}
}
internal static class Compatibility
{
	private const string AlienID = "ZenDragon.ZenWorldSettings";

	private static bool _isLoaded;

	private static bool _Check;

	public static bool IsLoaded()
	{
		if (!_Check)
		{
			_isLoaded = Chainloader.PluginInfos.ContainsKey("ZenDragon.ZenWorldSettings");
			if (_isLoaded)
			{
				Debug.Log((object)"Amazing Nature: Using ZenWorldSettings, Disabled Crypt Key consume");
			}
			_Check = true;
		}
		return _isLoaded;
	}
}
internal static class Compatibility2
{
	public const string AlienID = "ZenDragon.ZenCombat";

	private static bool _isLoaded;

	private static bool _Check;

	public static bool IsLoaded()
	{
		if (!_Check)
		{
			_isLoaded = Chainloader.PluginInfos.ContainsKey("ZenDragon.ZenCombat");
			if (_isLoaded)
			{
				Debug.Log((object)"Amazing Nature: Using ZenDragon.ZenCombat, Disabled Parry/Block changes");
			}
			_Check = true;
		}
		return _isLoaded;
	}
}
namespace UpgradeWorld
{
	public class CommandRegistration
	{
		public string name = "";

		public string description = "";

		public string[] commands = new string[0];

		public void AddCommand()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand(name, description, (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				string[] array = commands;
				foreach (string text in array)
				{
					args.Context.TryRunCommand(text, false, false);
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	[HarmonyPatch(typeof(Terminal), "InitTerminal")]
	public static class Upgrade
	{
		private static List<CommandRegistration> registrations = new List<CommandRegistration>();

		public const string GUID = "upgrade_world";

		public static void Register(string name, string description, params string[] commands)
		{
			if (Chainloader.PluginInfos.ContainsKey("upgrade_world"))
			{
				registrations.Add(new CommandRegistration
				{
					name = name,
					description = description,
					commands = commands
				});
			}
		}

		private static void Postfix()
		{
			foreach (CommandRegistration registration in registrations)
			{
				registration.AddCommand();
			}
		}
	}
}
namespace BalrondTreesNDecor
{
	public class BalrondTranslator
	{
		public static Dictionary<string, Dictionary<string, string>> translations = new Dictionary<string, Dictionary<string, string>>();

		public static Dictionary<string, string> getLanguage(string language)
		{
			if (string.IsNullOrEmpty(language))
			{
				return null;
			}
			if (translations.TryGetValue(language, out var value))
			{
				return value;
			}
			return null;
		}
	}
	internal class VfxList
	{
		public static readonly string[] vfx = new string[19]
		{
			"ElderMushroomCap_bal", "ElderMushroomLog_bal", "Acai_log_bal", "IcedTree_log_bal", "ElderTreeLog_bal", "ElderTreeLogHalf_bal", "Acai_log_half_bal", "Wet_log_bal", "Wet_log_half_bal", "Cypress_log_bal",
			"Willow_log_bal", "Maple_log_bal", "Oak2_log_bal", "Oak2_log_half_bal", "Poplar_log_bal", "YewTreeLog_bal", "bigyggashoot_log_bal", "bigyggashoot_log_half_bal", "bigyggashoot_log_quarter_bal"
		};
	}
	internal class ClutterList
	{
		public static string[] clutter = new string[0];
	}
	public class ConversionChanges
	{
		private enum ConversionType
		{
			smelter,
			fermenter,
			cooking,
			balrondConverter
		}

		private List<GameObject> buildPieces = new List<GameObject>();

		private List<GameObject> items = new List<GameObject>();

		public static List<TutorialText> m_texts = new List<TutorialText>();

		public static List<BalrondConverter.ItemConversion> sawmillConverions = new List<BalrondConverter.ItemConversion>();

		public static List<BalrondConverter.ItemConversion> stonekilnConverions = new List<BalrondConverter.ItemConversion>();

		public static List<BalrondConverter.ItemConversion> tanneryConverions = new List<BalrondConverter.ItemConversion>();

		public static List<ItemConversion> kilnConverions = new List<ItemConversion>();

		public static List<ItemConversion> smelterConverions = new List<ItemConversion>();

		public static List<ItemConversion> furnaceConverions = new List<ItemConversion>();

		private static readonly string[] buildPieceNames = new string[18]
		{
			"portal_wood", "piece_workbench", "forge", "blackforge", "piece_magetable", "piece_artisanstation", "piece_stonecutter", "piece_banner01", "piece_banner02", "piece_banner03",
			"piece_banner04", "piece_banner05", "piece_banner06", "piece_banner07", "piece_banner08", "piece_banner09", "piece_banner10", "piece_banner11"
		};

		private string[] convertToBits = new string[41]
		{
			"WillowSeeds_bal", "WillowBark_bal", "YewBark_bal", "WoodNails_bal", "WaterLilySeeds_bal", "SwampTreeSeeds_bal", "Straw_bal", "StrawSeeds_bal", "Snowleaf_bal", "StrawThread_bal",
			"RedwoodSeeds_bal", "Plantain_bal", "PoplarSeeds_bal", "Peningar_bal", "Sage_bal", "Lavender_bal", "Mint_bal", "OilBase_bal", "Oil_bal", "Nettle_bal",
			"Moss_bal", "Mugwort_bal", "MushroomIcecap_bal", "MushroomInkcap_bal", "Iceberry_bal", "Ignicap_bal", "GarlicSeeds_bal", "Garlic_bal", "CypressSeeds_bal", "CabbageLeaf_bal",
			"CabbageSeeds_bal", "Cabbage_bal", "BirdFeed_bal", "Blackberries_bal", "AppleSeeds_bal", "BasicSeed_bal", "AcaiSeeds_bal", "MapleSeeds_bal", "WaterLily_bal", "Yarrow_bal",
			"MeatScrap_bal"
		};

		private string[] convertToCoal = new string[194]
		{
			"ClayBrickMold_bal", "AcidSludge_bal", "AncientRelic_bal", "AppleVinegar_bal", "Apple_bal", "BatWingCooked_bal", "BatWing_bal", "BeltForester_bal", "BeltMountaineer_bal", "BeltSailor_bal",
			"BlackMetalCultivator_bal", "BlackMetalHoe_bal", "BlackSkin_bal", "BlackTissue_bal", "Bloodfruit_bal", "Bloodshard_bal", "BoarHide_bal", "BoraxCrystal_bal", "BundleHut_bal", "CarvedCarcass_bal",
			"CarvedDeerSkull_bal", "CeramicMold_bal", "Cheese_bal", "CabbageSoup_bal", "ClamMeat_bal", "ClayBrick_bal", "ClayPot_bal", "Clay_bal", "CoalPowder_bal", "CookedCrowMeat_bal",
			"CookedDragonRibs_bal", "CorruptedEitr_bal", "CrabLegsCooked_bal", "CrabLegs_bal", "CrystalWood_bal", "CultInsignia_bal", "CursedBone_bal", "Darkbul_bal", "DeadEgo_bal", "DragonSoul_bal",
			"DrakeMeatCooked_bal", "DrakeMeat_bal", "DrakeSkin_bal", "DyeKit_bal", "EmberWood_bal", "EnrichedEitr_bal", "EnrichedSoil_bal", "FenringInsygnia_bal", "FenringMeatCooked_bal", "FenringMeat_bal",
			"FireGland_bal", "FishWrapsUncooked_bal", "ForsakenHeart_bal", "FoxFur_bal", "CarvedWood_bal", "WispCore_bal", "GoatMeatCooked_bal", "GoatMeat_bal", "GrayMushroom_bal", "GrilledCheese_bal",
			"HammerBlackmetal_bal", "HammerDverger_bal", "HammerIron_bal", "HammerMythic_bal", "HardWood_bal", "HelmetCrown_bal", "InfusedCarapace_bal", "JotunFinger_bal", "JuteThread_bal", "KingMug_bal",
			"MagmaStone_bal", "MeadBase_bal", "MedPack_bal", "MincedMeat_bal", "NeckSkin_bal", "NorthernFur_bal", "NumbMeal_bal", "PickaxeFlametal_bal", "RawCrowMeat_bal", "RawDragonRibs_bal",
			"RawSilkScrap_bal", "RawSilk_bal", "RawSteak_bal", "RedKelp_bal", "RefinedOil_bal", "Sapphire_bal", "SawBlade_bal", "Seaberries_bal", "SeekerBrain_bal", "SerpentEgg_bal",
			"SharkMeatCooked_bal", "SharkMeat_bal", "SilkReinforcedThread_bal", "SmallBloodSack_bal", "SoulCore_bal", "SpiceSet_bal", "SpiritShard_bal", "SteakCooked_bal", "StormScale_bal", "TarBase_bal",
			"ThornHeart_bal", "ThunderGland_bal", "TormentedSoul_bal", "TrollMeatCooked_bal", "TrollMeat_bal", "WatcherHeart_bal", "SurtlingCoreCasing_bal", "ApplePieUncooked_bal", "ApplePie_bal", "AshlandCurry_bal",
			"BlackBerryJuice_bal", "BloodfruitSoup_bal", "BloodyBearJerky_bal", "BloodyCreamPie_bal", "BloodyVial_bal", "BlueberryPieUncooked_bal", "BlueberryPie_bal", "Breakfast_bal", "Burger_bal", "ChickenMarsala_bal",
			"ChickenNuggets_bal", "DragonfireBarbecue_bal", "FishSkewer_bal", "FruitPunch_bal", "FruitSalad_bal", "GrilledShrooms_bal", "HappyMeal_bal", "HoneyGlazedApple_bal", "IceBerryPancake_bal", "KingsJam_bal",
			"Liverwurst_bal", "MagmaCoctail_bal", "MeadBaseWhiteCheese_bal", "SeaFoodPlatter_bal", "SpicyBurger_bal", "SpiecedDrakeChop_bal", "SurstrommingBase_bal", "Surstromming_bal", "SwampSkause_bal", "VegetablePuree_bal",
			"VegetableSoup_bal", "WhiteCheese_bal", "WinterStew_bal", "CarrotFries_bal", "PowderedSalt_bal", "PowderedPepper_bal", "BundlePortal_bal", "BundlePortalStone_bal", "HelmetLeatherCap_bal", "HelmetBronzeHorned_bal",
			"BlackBerryJuiceBase_bal", "MagmaCoctailBase_bal", "FruitPunchBase_bal", "VineBerryJuice_bal", "VineBerryJuiceBase_bal", "RostedTrollBits_bal", "RoastedFish_bal", "CabbageWrapDrake_bal", "Cotlet_bal", "RedStew_bal",
			"GoatStew_bal", "CrustedMeat_bal", "MeatBalls_bal", "MeatRoll_bal", "MagnaTarta_bal", "ShrededMeat_bal", "MincedFenringStew_bal", "CarrotCrowSalad_bal", "Bulion_bal", "CookedMeatScrap_bal",
			"WoodBucket_bal", "BeltVidar_bal", "BeltAssasin_bal", "TrophyBattleHog_bal", "TrophyGoat_bal", "TrophyNeckBrute_bal", "TrophyObsidianCrab_bal", "TrophyShark_bal", "TrophySouling_bal", "TrophyCorpseCollector_bal",
			"TrophyForsaken_bal", "TrophyGreywatcher_bal", "TrophyHaugbui_bal", "TrophySpectre_bal", "TrophyStormdrake_bal", "TrophyTrollAshlands_bal", "TrophyTrollSkeleton_bal", "TrophyStag_bal", "TrophyLeechPrimal_bal", "TrophyStagGhost_bal",
			"Larva_bal", "WaterJugEmpty_bal", "SwordFakeSilver_Bal", "MaceFakeSilver_bal"
		};

		private string[] arrowsNbolts = new string[10] { "BoltBlunt_bal", "BoltChitin_bal", "BoltFire_bal", "BoltSilver_bal", "BoltThunder_bal", "ArrowBlizzard_bal", "ArrowBlunt_bal", "ArrowBone_bal", "ArrowChitin_bal", "ArrowFlametal_bal" };

		public void editBuidlPieces(List<GameObject> allPrefabs)
		{
			buildPieces = allPrefabs;
			items = allPrefabs;
			editKiln();
			editFurnace();
		}

		private void EditRecipes()
		{
			string[] array = buildPieceNames;
			foreach (string name in array)
			{
				GameObject val = FindBuildPiece(name);
				if ((Object)(object)val != (Object)null)
				{
					ModifyBuildPiece(val);
				}
			}
		}

		private void ModifyBuildPiece(GameObject piece)
		{
			string name = ((Object)piece).name;
			string text = name;
			switch (text)
			{
			case "forge":
			case "piece_workbench":
			case "blackforge":
			case "piece_magetable":
			case "piece_artisanstation":
			case "piece_stonecutter":
				SetCraftingStationRequiresRoof(piece, requireRoof: false);
				return;
			}
			if (text.StartsWith("piece_banner"))
			{
				SetBannerRecipe(piece);
			}
		}

		private void SetCraftingStationRequiresRoof(GameObject piece, bool requireRoof)
		{
			CraftingStation component = piece.GetComponent<CraftingStation>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_craftRequireRoof = requireRoof;
			}
		}

		private void SetBannerRecipe(GameObject piece)
		{
			Piece component = piece.GetComponent<Piece>();
			component.m_resources = (Requirement[])(object)new Requirement[4]
			{
				CreateRequirement("DyeKit_bal", 1),
				CreateRequirement("FineWood", 2),
				CreateRequirement("LeatherScraps", 3),
				CreateRequirement("StrawThread_bal", 3)
			};
		}

		private Requirement CreateRequirement(string itemName, int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			return new Requirement
			{
				m_resItem = FindItem(itemName).GetComponent<ItemDrop>(),
				m_amount = amount,
				m_amountPerLevel = 0,
				m_recover = true
			};
		}

		private GameObject FindBuildPiece(string name)
		{
			return ((IEnumerable<GameObject>)buildPieces).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == name));
		}

		private GameObject FindItem(string name)
		{
			if (items == null)
			{
				items = ZNetScene.instance.m_prefabs;
			}
			GameObject val = items.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
			return items.Find((GameObject x) => ((Object)x).name == "Wood");
		}

		private void removeConversionFromSmelter(string fromItem, List<ItemConversion> list)
		{
			if (list != null && list.Count != 0)
			{
				list.RemoveAll((ItemConversion x) => x == null || (Object)(object)x.m_from == (Object)null || x.m_from.m_itemData == null || (Object)(object)x.m_from.m_itemData.m_dropPrefab == (Object)null || ((Object)x.m_from.m_itemData.m_dropPrefab).name == fromItem);
			}
		}

		private Requirement createReq(string name, int amount, int amountPerLevel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Requirement val = new Requirement();
			val.m_recover = true;
			ItemDrop component = FindItem(name).GetComponent<ItemDrop>();
			val.m_resItem = component;
			val.m_amount = amount;
			val.m_amountPerLevel = amountPerLevel;
			return val;
		}

		public void editLeatherRack(BalrondConverter leatherRack = null)
		{
			if (buildPieces != null && (Object)(object)leatherRack == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_leatherRack_bal");
				leatherRack = val.GetComponent<BalrondConverter>();
			}
			if (tanneryConverions.Count > 0)
			{
				leatherRack.m_conversion = tanneryConverions;
				return;
			}
			leatherRack.m_conversion = new List<BalrondConverter.ItemConversion>();
			addConversion(((Component)leatherRack).gameObject, "NeckSkin_bal", "NeckSkin_bal", ConversionType.balrondConverter, 0, 2);
			addConversion(((Component)leatherRack).gameObject, "DeerHide", "DeerHide", ConversionType.balrondConverter, 0, 2, 2);
			addConversion(((Component)leatherRack).gameObject, "BoarHide_bal", "BoarHide_bal", ConversionType.balrondConverter, 0, 2, 2);
			addConversion(((Component)leatherRack).gameObject, "BjornHide", "BjornHide", ConversionType.balrondConverter, 0, 2, 3);
			addConversion(((Component)leatherRack).gameObject, "TrollHide", "TrollHide", ConversionType.balrondConverter, 0, 2, 3);
			addConversion(((Component)leatherRack).gameObject, "DrakeSkin_bal", "DrakeSkin_bal", ConversionType.balrondConverter, 0, 2, 4);
			addConversion(((Component)leatherRack).gameObject, "WolfPelt", "WolfPelt", ConversionType.balrondConverter, 0, 2, 4);
			addConversion(((Component)leatherRack).gameObject, "LoxPelt", "LoxPelt", ConversionType.balrondConverter, 0, 2, 5);
			addConversion(((Component)leatherRack).gameObject, "AskHide", "AskHide", ConversionType.balrondConverter, 0, 2, 5);
		}

		public void editRefinery(Smelter refinery = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)refinery == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "eitrrefinery");
				refinery = val.GetComponent<Smelter>();
			}
			if (refinery.m_maxFuel == 20)
			{
				refinery.m_maxFuel = 60;
			}
			if (refinery.m_maxOre == 20)
			{
				refinery.m_maxOre = 60;
			}
			if (refinery.m_secPerProduct == 40f)
			{
				refinery.m_secPerProduct = 60f;
			}
			text += addConversion(((Component)refinery).gameObject, "Oil_bal", "RefinedOil_bal", ConversionType.smelter);
			text += addConversion(((Component)refinery).gameObject, "BlackTissue_bal", "CorruptedEitr_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)refinery).gameObject, text);
		}

		public void editComposter(Smelter composter = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)composter == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "composter_bal");
				composter = val.GetComponent<Smelter>();
			}
			if (composter.m_conversion == null)
			{
				composter.m_conversion = new List<ItemConversion>();
			}
			addConversion(((Component)composter).gameObject, "TrophyFox_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHabrok_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHabrokBirb_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCrow_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreywatcher_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySouling_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCorpseCollector_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBjorn", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBjornUndead", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyForsaken_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoat_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHaugbui_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyNeckBrute_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyObsidianCrab_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySpectre_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyStormdrake_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyShark_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyAbomination", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBlob", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBoar", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBonemass", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCultist", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDeathsquito", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDeer", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDragonQueen", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDraugr", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDraugrElite", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDvergr", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyEikthyr", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyFenring", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyFrostTroll", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGjall", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblin", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinKing", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinShaman", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreydwarf", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreydwarfBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGreydwarfShaman", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGrowth", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHare", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyHatchling", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyLeech", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyLox", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyNeck", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySeeker", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySeekerBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySeekerQueen", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySerpent", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySGolem", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySkeleton", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySkeletonPoison", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySurtling", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTheElder", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTick", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyUlv", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyWolf", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyWraith", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTrollSkeleton_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyTrollAshlands_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyStag_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBattleHog_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBear_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyForestTroll_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyPolarBear_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyLeechPrimal_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyStagGhost_bal", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyBonemawSerpent", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCharredArcher", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCharredMage", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCharredMelee", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyCultist_Hildir", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyDraugrFem", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyFader", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyFallenValkyrie", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGhost", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinBruteBrosBrute", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyGoblinBruteBrosShaman", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyKvastur", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyMorgen", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophySkeletonHildir", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyVolture", "EnrichedSoil_bal", ConversionType.smelter);
			addConversion(((Component)composter).gameObject, "TrophyAsksvin", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "RottenMeat", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "RottenVegetable_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Pukeberries", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "StrawBundle_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Cabbage_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Turnip", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Carrot", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Onion", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Garlic_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "BirdFeed_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "Apple_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "PoisonApple_bal", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "BoneFragments", "EnrichedSoil_bal", ConversionType.smelter);
			text += addConversion(((Component)composter).gameObject, "FishRaw", "EnrichedSoil_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)composter).gameObject, text);
		}

		public void editSmelter(Smelter smelter = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)smelter == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "smelter");
				smelter = val.GetComponent<Smelter>();
			}
			if (smelter.m_maxFuel == 20)
			{
				smelter.m_maxFuel = 45;
			}
			if (smelter.m_maxOre == 10)
			{
				smelter.m_maxOre = 15;
			}
			if (smelter.m_secPerProduct == 30f)
			{
				smelter.m_secPerProduct = 40f;
			}
			if (smelter.m_fuelPerProduct == 2)
			{
				smelter.m_fuelPerProduct = 3;
			}
			if (smelterConverions.Count > 0)
			{
				smelter.m_conversion = smelterConverions;
				return;
			}
			if (smelter.m_conversion == null)
			{
				smelter.m_conversion = new List<ItemConversion>();
			}
			removeConversionFromSmelter("IronScrap", smelter.m_conversion);
			removeConversionFromSmelter("CopperScrap", smelter.m_conversion);
			removeConversionFromSmelter("BronzeScrap", smelter.m_conversion);
			text += "\n Scrap does not go into Furnace/Smelter.  Can be only converted in Smeltworks station";
			text += addConversion(((Component)smelter).gameObject, "SurtlingCoreCasing_bal", "SurtlingCore", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "ZincOre_bal", "Zinc_bal", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "CopperOre", "Copper", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "LeadOre_bal", "Lead_bal", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "TinOre", "Tin", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "NickelOre_bal", "Nickel_bal", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "IronOre", "Iron", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "SilverOre", "Silver", ConversionType.smelter);
			text += addConversion(((Component)smelter).gameObject, "GoldOre_bal", "GoldBar_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)smelter).gameObject, text, "smelter");
			smelterConverions = smelter.m_conversion;
		}

		public void editFurnace(Smelter furnace = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)furnace == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "blastfurnace");
				furnace = val.GetComponent<Smelter>();
			}
			if (furnaceConverions.Count > 0)
			{
				furnace.m_conversion = furnaceConverions;
				return;
			}
			if (furnace.m_conversion == null)
			{
				furnace.m_conversion = new List<ItemConversion>();
			}
			text += addConversion(((Component)furnace).gameObject, "CopperOre", "Copper", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "TinOre", "Tin", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "IronOre", "Iron", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "SilverOre", "Silver", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "BlackMetalOre_bal", "BlackMetal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "FlametalOre", "Flametal", ConversionType.smelter);
			text += addConversion(((Component)furnace).gameObject, "FlametalOreNew", "FlametalNew", ConversionType.smelter);
			furnaceConverions = furnace.m_conversion;
		}

		public void editSawMill(BalrondConverter sawmill = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)sawmill == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_sawmill_bal");
				sawmill = val.GetComponent<BalrondConverter>();
			}
			if (sawmillConverions.Count > 0)
			{
				sawmill.m_conversion = sawmillConverions;
				return;
			}
			sawmill.m_conversion.Clear();
			sawmill.m_conversion = new List<BalrondConverter.ItemConversion>();
			text += addConversion(((Component)sawmill).gameObject, "RoundLog", "Wood", ConversionType.balrondConverter, 0, 3);
			text += addConversion(((Component)sawmill).gameObject, "FineWood", "Wood", ConversionType.balrondConverter, 0, 4);
			text += addConversion(((Component)sawmill).gameObject, "ElderBark", "Wood", ConversionType.balrondConverter, 0, 2);
			text += addConversion(((Component)sawmill).gameObject, "YewBark_bal", "Wood", ConversionType.balrondConverter, 0, 2);
			text += addConversion(((Component)sawmill).gameObject, "WillowBark_bal", "Wood", ConversionType.balrondConverter, 0, 2);
			text += addConversion(((Component)sawmill).gameObject, "HardWood_bal", "FineWood", ConversionType.balrondConverter, 0, 3, 2);
			text += addConversion(((Component)sawmill).gameObject, "YggdrasilWood", "FineWood", ConversionType.balrondConverter, 0, 3);
			text += addConversion(((Component)sawmill).gameObject, "Blackwood", "FineWood", ConversionType.balrondConverter, 0, 4, 2);
			text += addConversion(((Component)sawmill).gameObject, "EmberWood_bal", "FineWood", ConversionType.balrondConverter, 0, 2, 2);
			text += addConversion(((Component)sawmill).gameObject, "CrystalWood_bal", "HardWood_bal", ConversionType.balrondConverter, 0, 2, 3);
			buildConversionStationTutorialTag(((Component)sawmill).gameObject, text);
			sawmillConverions = sawmill.m_conversion;
		}

		public void editStoneboundKiln(BalrondConverter kiln = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "StoneboundKiln_bal");
				kiln = val.GetComponent<BalrondConverter>();
			}
			kiln.m_addOreTooltip = "$piece_smelter_add";
			if (stonekilnConverions.Count > 0)
			{
				kiln.m_conversion = stonekilnConverions;
				return;
			}
			text += "\n Stonebound Kiln accepts all items that Kiln does but requires fuel";
			text += addConversion(((Component)kiln).gameObject, "WoodBundle_bal", "Coal", ConversionType.balrondConverter, 60, 10, 2);
			text += addConversion(((Component)kiln).gameObject, "ClayMoldBundle_bal", "ClayBrick_bal", ConversionType.balrondConverter, 60, 10, 2);
			text += addConversion(((Component)kiln).gameObject, "CeramicMoldBundle_bal", "CeramicPlate", ConversionType.balrondConverter, 60, 40, 2);
			text += addConversion(((Component)kiln).gameObject, "Wood", "Coal", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "FineWood", "Coal", ConversionType.balrondConverter, 10, 1);
			text += addConversion(((Component)kiln).gameObject, "RoundLog", "Coal", ConversionType.balrondConverter, 10, 1);
			text += addConversion(((Component)kiln).gameObject, "TarBase_bal", "Tar", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "Moss_bal", "CoalPowder_bal", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "ElderBark", "CoalPowder_bal", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "YewBark_bal", "CoalPowder_bal", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "WillowBark_bal", "CoalPowder_bal", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "HardWood_bal", "Coal", ConversionType.balrondConverter, 10, 2);
			text += addConversion(((Component)kiln).gameObject, "YggdrasilWood", "Coal", ConversionType.balrondConverter, 10, 2);
			text += addConversion(((Component)kiln).gameObject, "Blackwood", "Coal", ConversionType.balrondConverter, 10, 2);
			text += addConversion(((Component)kiln).gameObject, "ClayBrickMold_bal", "ClayBrick_bal", ConversionType.balrondConverter, 5, 1);
			text += addConversion(((Component)kiln).gameObject, "CeramicMold_bal", "CeramicPlate", ConversionType.balrondConverter, 5, 1);
			buildConversionStationTutorialTag(((Component)kiln).gameObject, text);
			stonekilnConverions = kiln.m_conversion;
		}

		public void editFermenter(Fermenter fermenter = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)fermenter == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "fermenter");
				fermenter = val.GetComponent<Fermenter>();
			}
			fermenter.m_fermentationDuration = 2000f;
			text += addConversion(((Component)fermenter).gameObject, "MeadBaseWhiteCheese_bal", "WhiteCheese_bal", ConversionType.fermenter, 2);
			text += addConversion(((Component)fermenter).gameObject, "SurstrommingBase_bal", "Surstromming_bal", ConversionType.fermenter, 2);
			buildConversionStationTutorialTag(((Component)fermenter).gameObject, text);
		}

		public void editOven(CookingStation oven = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)oven == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_oven");
				oven = val.GetComponent<CookingStation>();
			}
			if (oven.m_conversion == null)
			{
				oven.m_conversion = new List<ItemConversion>();
			}
			text += addConversion(((Component)oven).gameObject, "FishWrapsUncooked_bal", "FishWraps", ConversionType.cooking, 50);
			text += addConversion(((Component)oven).gameObject, "ApplePieUncooked_bal", "ApplePie_bal", ConversionType.cooking, 50);
			text += addConversion(((Component)oven).gameObject, "BlueberryPieUncooked_bal", "BlueberryPie_bal", ConversionType.cooking, 50);
			buildConversionStationTutorialTag(((Component)oven).gameObject, text);
		}

		public void editCooking(CookingStation cookingStation = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)cookingStation == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_cookingstation");
				cookingStation = val.GetComponent<CookingStation>();
			}
			text += addConversion(((Component)cookingStation).gameObject, "BatWing_bal", "BatWingCooked_bal", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "GoatMeat_bal", "GoatMeatCooked_bal", ConversionType.cooking, 40);
			text += addConversion(((Component)cookingStation).gameObject, "RawCrowMeat_bal", "CookedCrowMeat_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "RawSteak_bal", "SteakCooked_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "SharkMeat_bal", "SharkMeatCooked_bal", ConversionType.cooking, 35);
			text += addConversion(((Component)cookingStation).gameObject, "CrabLegs_bal", "CrabLegsCooked_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "TrollMeat_bal", "TrollMeatCooked_bal", ConversionType.cooking, 60);
			buildConversionStationTutorialTag(((Component)cookingStation).gameObject, text);
		}

		public void editIronCooking(CookingStation cookingStation = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)cookingStation == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_cookingstation_iron");
				cookingStation = val.GetComponent<CookingStation>();
			}
			text += addConversion(((Component)cookingStation).gameObject, "CrabLegs_bal", "CrabLegsCooked_bal", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "SharkMeat_bal", "SharkMeatCooked_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "FenringMeat_bal", "FenringMeatCooked_bal", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "RawCrowMeat_bal", "CookedCrowMeat_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "RawSteak_bal", "SteakCooked_bal", ConversionType.cooking, 20);
			text += addConversion(((Component)cookingStation).gameObject, "BatWing_bal", "BatWingCooked_bal", ConversionType.cooking, 20);
			text += addConversion(((Component)cookingStation).gameObject, "GoatMeat_bal", "GoatMeatCooked_bal", ConversionType.cooking, 35);
			text += addConversion(((Component)cookingStation).gameObject, "DrakeMeat_bal", "DrakeMeatCooked_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "TrollMeat_bal", "TrollMeatCooked_bal", ConversionType.cooking, 60);
			buildConversionStationTutorialTag(((Component)cookingStation).gameObject, text);
		}

		public void editSmallIronCooking(CookingStation cookingStation = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)cookingStation == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_singleIronRack_bal");
				cookingStation = val.GetComponent<CookingStation>();
			}
			text += addConversion(((Component)cookingStation).gameObject, "RawMeat", "CookedMeat", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "NeckTail", "CookedNeckTail", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "FishRaw", "FishCooked", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "SerpentMeat", "SerpentMeatCooked", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "LoxMeat", "LoxMeatCooked", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "HareMeat", "HareMeatCooked", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "ChickenMeat", "ChickenCooked", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "AskvinMeat", "AskvinMeatCooked", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "VultureMeat", "VultureMeatCooked", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "CrabLegs_bal", "CrabLegsCooked_bal", ConversionType.cooking, 25);
			text += addConversion(((Component)cookingStation).gameObject, "SharkMeat_bal", "SharkMeatCooked_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "FenringMeat_bal", "FenringMeatCooked_bal", ConversionType.cooking, 60);
			text += addConversion(((Component)cookingStation).gameObject, "RawCrowMeat_bal", "CookedCrowMeat_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "RawSteak_bal", "SteakCooked_bal", ConversionType.cooking, 20);
			text += addConversion(((Component)cookingStation).gameObject, "BatWing_bal", "BatWingCooked_bal", ConversionType.cooking, 20);
			text += addConversion(((Component)cookingStation).gameObject, "GoatMeat_bal", "GoatMeatCooked_bal", ConversionType.cooking, 35);
			text += addConversion(((Component)cookingStation).gameObject, "DrakeMeat_bal", "DrakeMeatCooked_bal", ConversionType.cooking, 30);
			text += addConversion(((Component)cookingStation).gameObject, "TrollMeat_bal", "TrollMeatCooked_bal", ConversionType.cooking, 60);
			buildConversionStationTutorialTag(((Component)cookingStation).gameObject, text);
		}

		public void editWHeel(Smelter wheel = null)
		{
			string text = "";
			if (buildPieces != null && (Object)(object)wheel == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_spinningwheel");
				wheel = val.GetComponent<Smelter>();
			}
			if (wheel.m_maxOre == 40)
			{
				wheel.m_maxOre = 80;
			}
			if (wheel.m_secPerProduct == 30f)
			{
				wheel.m_secPerProduct = 25f;
			}
			text += addConversion(((Component)wheel).gameObject, "Straw_bal", "StrawThread_bal", ConversionType.smelter);
			text += addConversion(((Component)wheel).gameObject, "RawSilk_bal", "SilkReinforcedThread_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)wheel).gameObject, text);
		}

		public void editSap(SapCollector sap = null)
		{
			if (buildPieces != null && (Object)(object)sap == (Object)null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_sapcollector");
				sap = val.GetComponent<SapCollector>();
			}
			if (sap.m_secPerUnit == 60f)
			{
				sap.m_secPerUnit = 90f;
			}
			if (sap.m_maxLevel == 10)
			{
				sap.m_maxLevel = 30;
			}
		}

		public void editWIndMIll(Smelter windmill = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "windmill");
				windmill = val.GetComponent<Smelter>();
			}
			if (windmill.m_maxOre == 50)
			{
				windmill.m_maxOre = 60;
			}
			if (windmill.m_secPerProduct == 10f)
			{
				windmill.m_secPerProduct = 15f;
			}
		}

		public void editKiln(Smelter kiln = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "charcoal_kiln");
				kiln = val.GetComponent<Smelter>();
			}
			kiln.m_addOreTooltip = "$piece_smelter_add";
			if (kilnConverions.Count > 0)
			{
				kiln.m_conversion = kilnConverions;
				return;
			}
			text += addConversion(((Component)kiln).gameObject, "StrawBundle_bal", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "FineWood", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "RoundLog", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "ElderBark", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "YggdrasilWood", "Coal", ConversionType.smelter);
			text += addConversion(((Component)kiln).gameObject, "Blackwood", "Coal", ConversionType.smelter);
			kilnConverions = kiln.m_conversion;
		}

		public void editPress(Smelter press = null)
		{
			string text = "";
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "oilpress_bal");
				press = val.GetComponent<Smelter>();
			}
			text += addConversion(((Component)press).gameObject, "OilBase_bal", "Oil_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "BlackBerryJuiceBase_bal", "BlackBerryJuice_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "FruitPunchBase_bal", "FruitPunch_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "VineBerryJuiceBase_bal", "VineBerryJuice_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "MagmaCoctailBase_bal", "MagmaCoctail_bal", ConversionType.smelter);
			text += addConversion(((Component)press).gameObject, "PaintBucket_bal", "DyeKit_bal", ConversionType.smelter);
			buildConversionStationTutorialTag(((Component)press).gameObject, text);
		}

		private void editBeehive()
		{
			GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_beehive");
			Beehive component = val.GetComponent<Beehive>();
			component.m_maxHoney = 20;
		}

		private void editIncinerator(Incinerator incinerator = null)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			if (buildPieces != null)
			{
				GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "incinerator");
				incinerator = val.GetComponent<Incinerator>();
			}
			IncineratorConversion val2 = new IncineratorConversion();
			val2.m_requireOnlyOneIngredient = true;
			val2.m_priority = 2;
			val2.m_requirements = new List<Requirement>();
			string[] array = convertToBits;
			foreach (string name in array)
			{
				val2.m_requirements.Add(new Requirement
				{
					m_amount = 1,
					m_resItem = FindItem(name).GetComponent<ItemDrop>()
				});
			}
			val2.m_result = FindItem("CoalPowder_bal").GetComponent<ItemDrop>();
			incinerator.m_conversions.Add(val2);
			IncineratorConversion val3 = new IncineratorConversion();
			val3.m_requireOnlyOneIngredient = true;
			val3.m_requirements = new List<Requirement>();
			string[] array2 = convertToCoal;
			foreach (string name2 in array2)
			{
				val3.m_requirements.Add(new Requirement
				{
					m_amount = 1,
					m_resItem = FindItem(name2).GetComponent<ItemDrop>()
				});
			}
			val3.m_result = FindItem("Coal").GetComponent<ItemDrop>();
			incinerator.m_conversions.Add(val3);
			IncineratorConversion val4 = new IncineratorConversion();
			val4.m_requireOnlyOneIngredient = true;
			val4.m_priority = 1;
			val4.m_requirements = new List<Requirement>();
			string[] array3 = arrowsNbolts;
			foreach (string name3 in array3)
			{
				val4.m_requirements.Add(new Requirement
				{
					m_amount = 20,
					m_resItem = FindItem(name3).GetComponent<ItemDrop>()
				});
			}
			val4.m_result = FindItem("Coal").GetComponent<ItemDrop>();
			incinerator.m_conversions.Add(val4);
		}

		private string addConversion(GameObject source, string nameIn, string nameOut, ConversionType type, int time = 0, int amount = 5, int cost = 1)
		{
			string result = "";
			switch (type)
			{
			case ConversionType.smelter:
				result = SmelterConversion(source, nameIn, nameOut);
				break;
			case ConversionType.fermenter:
				result = FermenterConversion(source, nameIn, nameOut, amount);
				break;
			case ConversionType.cooking:
				result = CookingConversion(source, nameIn, nameOut, time);
				break;
			case ConversionType.balrondConverter:
				result = BalrondConversion(source, nameIn, nameOut, amount, cost, time);
				break;
			}
			return result;
		}

		private void buildConversionStationTutorialTag(GameObject gameObject, string tutorialExtra, string tag = "workbench")
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			string text = "\n  <color=orange>BALROND AMAZING NATURE: </color>";
			TutorialText val = new TutorialText();
			val.m_name = "BAN conversions:" + ((Object)gameObject).name;
			val.m_globalKeyTrigger = "AmazingNature" + ((Object)gameObject).name;
			val.m_tutorialTrigger = tag;
			val.m_topic = "BAN-" + ((Object)gameObject).name;
			val.m_label = "BAN-" + ((Object)gameObject).name;
			val.m_isMunin = true;
			val.m_text = text + tutorialExtra;
			m_texts.Add(val);
		}

		private string createConversionSingleLine(ItemDrop m_from, ItemDrop m_to, int time = 0, int amount = 0)
		{
			string text = "\n $tag_convers_bal ";
			if (time > 0 && amount == 0)
			{
				return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + m_to.m_itemData.m_shared.m_name + " $tag_in_bal " + time + " $tag_seconds_bal";
			}
			if (time == 0 && amount > 0)
			{
				return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + amount + " " + m_to.m_itemData.m_shared.m_name;
			}
			if (time > 0 && amount > 0)
			{
				return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + amount + " " + m_to.m_itemData.m_shared.m_name + " $tag_in_bal " + time + " $tag_seconds_bal";
			}
			return text + m_from.m_itemData.m_shared.m_name + " $tag_to_bal " + m_to.m_itemData.m_shared.m_name;
		}

		private string BalrondConversion(GameObject source, string nameIn, string nameOut, int amount = 1, int cost = 1, int time = 0, List<GameObject> list = null)
		{
			BalrondConverter component = source.GetComponent<BalrondConverter>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<BalrondConverter.ItemConversion>();
			}
			bool flag = false;
			foreach (BalrondConverter.ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				BalrondConverter.ItemConversion item = new BalrondConverter.ItemConversion
				{
					m_from = component2,
					m_to = component3,
					m_count = amount,
					m_fuelCost = cost,
					m_secPerProduct = time
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3, 0, amount);
			}
			return "";
		}

		private string SmelterConversion(GameObject source, string nameIn, string nameOut)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			Smelter component = source.GetComponent<Smelter>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<ItemConversion>();
			}
			bool flag = false;
			foreach (ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				ItemConversion item = new ItemConversion
				{
					m_from = component2,
					m_to = component3
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3);
			}
			return "";
		}

		private string FermenterConversion(GameObject source, string nameIn, string nameOut, int amount = 1)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			Fermenter component = source.GetComponent<Fermenter>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<ItemConversion>();
			}
			bool flag = false;
			foreach (ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				ItemConversion item = new ItemConversion
				{
					m_from = component2,
					m_to = component3,
					m_producedItems = amount
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3, 0, amount);
			}
			return "";
		}

		private string CookingConversion(GameObject source, string nameIn, string nameOut, int time = 25)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			CookingStation component = source.GetComponent<CookingStation>();
			if ((Object)(object)component == (Object)null)
			{
				return "";
			}
			if (component.m_conversion == null)
			{
				component.m_conversion = new List<ItemConversion>();
			}
			bool flag = false;
			foreach (ItemConversion item2 in component.m_conversion)
			{
				if (item2 != null && (Object)(object)item2.m_from != (Object)null && item2.m_from.m_itemData != null && (Object)(object)item2.m_from.m_itemData.m_dropPrefab != (Object)null && ((Object)item2.m_from.m_itemData.m_dropPrefab).name == nameIn)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				ItemDrop component2 = FindItem(nameIn).GetComponent<ItemDrop>();
				ItemDrop component3 = FindItem(nameOut).GetComponent<ItemDrop>();
				ItemConversion item = new ItemConversion
				{
					m_from = component2,
					m_to = component3,
					m_cookTime = time
				};
				component.m_conversion.Add(item);
				return createConversionSingleLine(component2, component3, time);
			}
			return "";
		}
	}
	[Serializable]
	public class BalrondConverter : MonoBehaviour
	{
		[Serializable]
		public class ItemConversion
		{
			public ItemDrop m_from;

			public ItemDrop m_to;

			[Tooltip("How many of m_to to produce per 1 input")]
			public int m_count = 1;

			[Tooltip("Fuel units consumed per 1 input processed. Sawmill: 1. Tanning: bundles needed per hide.")]
			public int m_fuelCost = 1;

			[Tooltip("Seconds per product for THIS conversion. If 0, station uses m_defaultSecPerProduct (default 60).")]
			public float m_secPerProduct = 0f;
		}

		public string m_name = "BalrondConverter";

		public string prefabName = null;

		public string m_addOreTooltip = "$tag_sawmill_addWood";

		public string m_emptyOreTooltip = "$tag_sawmill_pickupWood";

		public Switch m_addWoodSwitch;

		public Switch m_addOreSwitch;

		public Switch m_emptyOreSwitch;

		public Transform m_outputPoint;

		public Transform m_roofCheckPoint;

		public GameObject m_enabledObject;

		public GameObject m_disabledObject;

		public GameObject m_haveFuelObject;

		public GameObject m_haveOreObject;

		public GameObject m_noOreObject;

		public Animator[] m_animators;

		[Header("Fuel")]
		public ItemDrop m_fuelItem;

		public int m_maxFuel = 1;

		public int m_usesPerBlade = 100;

		[Header("Input")]
		public int m_maxOre = 1;

		[Header("Timing")]
		public float m_defaultSecPerProduct = 60f;

		[Header("Output")]
		public bool m_spawnStack = true;

		public bool m_requiresRoof = false;

		public Windmill m_windmill;

		public SmokeSpawner m_smokeSpawner;

		public float m_addOreAnimationDuration;

		public List<ItemConversion> m_conversion = new List<ItemConversion>();

		public EffectList m_oreAddedEffects = new EffectList();

		public EffectList m_fuelAddedEffects = new EffectList();

		public EffectList m_produceEffects = new EffectList();

		private ZNetView m_nview;

		private float m_addedOreTime = -1000f;

		private readonly StringBuilder m_sb = new StringBuilder();

		private static readonly int s_fuelUnitsHash = BalrondHashCompat.StableHash("balrond_fuelUnits");

		private static readonly int s_currentOreHash = BalrondHashCompat.StableHash("balrond_currentOre");

		private static readonly int s_currentAmountHash = BalrondHashCompat.StableHash("balrond_currentAmount");

		private static readonly int s_jobOreHash = BalrondHashCompat.StableHash("balrond_jobOre");

		private static readonly int s_reservedFuelHash = BalrondHashCompat.StableHash("balrond_reservedFuel");

		private static readonly int s_startTimeHash = ZDOVars.s_startTime;

		private static readonly int s_accTimeHash = ZDOVars.s_accTime;

		private static readonly int s_bakeTimerHash = ZDOVars.s_bakeTimer;

		private static readonly int s_queuedHash = ZDOVars.s_queued;

		private void Awake()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			m_nview = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)m_nview == (Object)null)
			{
				m_nview = ((Component)this).GetComponentInParent<ZNetView>();
			}
			if (!((Object)(object)m_nview == (Object)null) && m_nview.IsValid())
			{
				if (Object.op_Implicit((Object)(object)m_addOreSwitch))
				{
					Switch addOreSwitch = m_addOreSwitch;
					addOreSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)addOreSwitch.m_onUse, (Delegate?)new Callback(OnAddOre));
					m_addOreSwitch.m_onHover = new TooltipCallback(OnHoverAddOre);
				}
				if (Object.op_Implicit((Object)(object)m_addWoodSwitch))
				{
					Switch addWoodSwitch = m_addWoodSwitch;
					addWoodSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)addWoodSwitch.m_onUse, (Delegate?)new Callback(OnAddFuel));
					m_addWoodSwitch.m_onHover = new TooltipCallback(OnHoverAddFuel);
				}
				if (Object.op_Implicit((Object)(object)m_emptyOreSwitch))
				{
					Switch emptyOreSwitch = m_emptyOreSwitch;
					emptyOreSwitch.m_onUse = (Callback)Delegate.Combine((Delegate?)(object)emptyOreSwitch.m_onUse, (Delegate?)new Callback(OnEmpty));
					Switch emptyOreSwitch2 = m_emptyOreSwitch;
					emptyOreSwitch2.m_onHover = (TooltipCallback)Delegate.Combine((Delegate?)(object)emptyOreSwitch2.m_onHover, (Delegate?)new TooltipCallback(OnHoverEmptyOre));
				}
				m_nview.Register<string>("AddOre", (Action<long, string>)RPC_AddOre);
				m_nview.Register("AddFuel", (Action<long>)RPC_AddFuel);
				m_nview.Register("ConverterEmptyProcessed", (Action<long>)RPC_ConverterEmptyProcessed);
				WearNTear component = ((Component)this).GetComponent<WearNTear>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.m_onDestroyed = (Action)Delegate.Combine(component.m_onDestroyed, new Action(OnDestroyed));
				}
				((MonoBehaviour)this).InvokeRepeating("UpdateBalrondConverter", 1f, 1f);
			}
		}

		private void EnsureConversionsLoaded()
		{
			if (m_conversion == null || m_conversion.Count <= 0)
			{
				if (prefabName == "piece_leatherRack_bal")
				{
					m_conversion = ConversionChanges.tanneryConverions;
				}
				else if (prefabName == "piece_sawmill_bal")
				{
					m_conversion = ConversionChanges.sawmillConverions;
				}
				else if (prefabName == "StoneboundKiln_bal")
				{
					m_conversion = ConversionChanges.stonekilnConverions;
				}
				if (m_conversion == null)
				{
					m_conversion = new List<ItemConversion>();
				}
			}
		}

		private int GetFuelUnits()
		{
			return (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid()) ? m_nview.GetZDO().GetInt(s_fuelUnitsHash, 0) : 0;
		}

		private void SetFuelUnits(int units)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				if (units < 0)
				{
					units = 0;
				}
				m_nview.GetZDO().Set(s_fuelUnitsHash, units, false);
			}
		}

		private int GetReservedFuelUnits()
		{
			return (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid()) ? m_nview.GetZDO().GetInt(s_reservedFuelHash, 0) : 0;
		}

		private void SetReservedFuelUnits(int units)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				if (units < 0)
				{
					units = 0;
				}
				m_nview.GetZDO().Set(s_reservedFuelHash, units, false);
			}
		}

		private int GetFuelUnitsCapacity()
		{
			int num = Mathf.Max(0, m_maxFuel);
			int num2 = Mathf.Max(1, m_usesPerBlade);
			return num * num2;
		}

		private bool HasAnyFuel()
		{
			return m_maxFuel == 0 || GetFuelUnits() > 0;
		}

		private string GetJobOre()
		{
			return (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid()) ? "" : m_nview.GetZDO().GetString(s_jobOreHash, "");
		}

		private void SetJobOre(string ore)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				m_nview.GetZDO().Set(s_jobOreHash, ore ?? "");
			}
		}

		private bool HasActiveJob()
		{
			return !string.IsNullOrEmpty(GetJobOre());
		}

		private int GetFuelCostForOre(string orePrefabName)
		{
			ItemConversion itemConversion = GetItemConversion(orePrefabName);
			if (itemConversion == null)
			{
				return 1;
			}
			return Mathf.Max(1, itemConversion.m_fuelCost);
		}

		private bool TryStartJobIfPossible()
		{
			if (HasActiveJob())
			{
				return true;
			}
			string queuedOre = GetQueuedOre();
			if (string.IsNullOrEmpty(queuedOre))
			{
				return false;
			}
			ItemConversion itemConversion = GetItemConversion(queuedOre);
			if (itemConversion == null)
			{
				ZLog.LogWarning((object)("[BalrondConverter] Missing conversion for '" + queuedOre + "', dropping it from queue."));
				RemoveOneOre();
				return false;
			}
			int num = Mathf.Max(1, itemConversion.m_fuelCost);
			if (m_maxFuel > 0 && GetFuelUnits() < num)
			{
				return false;
			}
			RemoveOneOre();
			SetJobOre(queuedOre);
			SetBakeTimer(0f);
			if (m_maxFuel > 0)
			{
				int fuelUnits = GetFuelUnits();
				SetFuelUnits(fuelUnits - num);
				SetReservedFuelUnits(GetReservedFuelUnits() + num);
			}
			return true;
		}

		private void CompleteJobAndSpawnOutput()
		{
			string jobOre = GetJobOre();
			if (!string.IsNullOrEmpty(jobOre))
			{
				SetReservedFuelUnits(0);
				QueueProcessed(jobOre);
				SetJobOre("");
				SetBakeTimer(0f);
			}
		}

		private int GetQueueSize()
		{
			return (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid()) ? m_nview.GetZDO().GetInt(s_queuedHash, 0) : 0;
		}

		private float GetBakeTimer()
		{
			return (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid()) ? 0f : m_nview.GetZDO().GetFloat(s_bakeTimerHash, 0f);
		}

		private void SetBakeTimer(float t)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				m_nview.GetZDO().Set(s_bakeTimerHash, t);
			}
		}

		private float GetAccumulator()
		{
			return (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid()) ? 0f : m_nview.GetZDO().GetFloat(s_accTimeHash, 0f);
		}

		private void SetAccumulator(float t)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				m_nview.GetZDO().Set(s_accTimeHash, t);
			}
		}

		private void QueueOre(string prefabName)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				int queueSize = GetQueueSize();
				m_nview.GetZDO().Set("item" + queueSize, prefabName);
				m_nview.GetZDO().Set(s_queuedHash, queueSize + 1, false);
			}
		}

		private string GetQueuedOre()
		{
			return (GetQueueSize() == 0 || !Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid()) ? "" : m_nview.GetZDO().GetString(ZDOVars.s_item0, "");
		}

		private string GetQueuedOreAt(int index)
		{
			if (index < 0 || !Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return "";
			}
			return m_nview.GetZDO().GetString("item" + index, "");
		}

		private void RemoveOneOre()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return;
			}
			int queueSize = GetQueueSize();
			if (queueSize > 0)
			{
				for (int i = 0; i < queueSize; i++)
				{
					string @string = m_nview.GetZDO().GetString("item" + (i + 1), "");
					m_nview.GetZDO().Set("item" + i, @string);
				}
				m_nview.GetZDO().Set(s_queuedHash, queueSize - 1, false);
			}
		}

		private int GetProcessedQueueSize()
		{
			return (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid()) ? m_nview.GetZDO().GetInt(s_currentAmountHash, 0) : 0;
		}

		private void QueueProcessed(string fromOrePrefab)
		{
			ItemConversion itemConversion = GetItemConversion(fromOrePrefab);
			if (itemConversion == null)
			{
				ZLog.LogWarning((object)("[BalrondConverter] Missing conversion for '" + fromOrePrefab + "'"));
			}
			else if (!m_spawnStack)
			{
				Spawn(fromOrePrefab, itemConversion.m_count);
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
				{
					return;
				}
				string @string = m_nview.GetZDO().GetString(s_currentOreHash, "");
				int @int = m_nview.GetZDO().GetInt(s_currentAmountHash, 0);
				if (!string.IsNullOrEmpty(@string))
				{
					if (@string != fromOrePrefab)
					{
						SpawnProcessed();
						m_nview.GetZDO().Set(s_currentOreHash, fromOrePrefab);
						m_nview.GetZDO().Set(s_currentAmountHash, itemConversion.m_count, false);
						return;
					}
					int num = @int + itemConversion.m_count;
					int num2 = itemConversion.m_to?.m_itemData?.m_shared?.m_maxStackSize ?? 1;
					if (num >= num2)
					{
						Spawn(fromOrePrefab, @int);
						Spawn(fromOrePrefab, itemConversion.m_count);
						m_nview.GetZDO().Set(s_currentOreHash, "");
						m_nview.GetZDO().Set(s_currentAmountHash, 0, false);
					}
					else
					{
						m_nview.GetZDO().Set(s_currentAmountHash, num, false);
					}
				}
				else
				{
					m_nview.GetZDO().Set(s_currentOreHash, fromOrePrefab);
					m_nview.GetZDO().Set(s_currentAmountHash, itemConversion.m_count, false);
				}
			}
		}

		private void SpawnProcessed()
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid())
			{
				int @int = m_nview.GetZDO().GetInt(s_currentAmountHash, 0);
				if (@int > 0)
				{
					string @string = m_nview.GetZDO().GetString(s_currentOreHash, "");
					Spawn(@string, @int);
					m_nview.GetZDO().Set(s_currentOreHash, "");
					m_nview.GetZDO().Set(s_currentAmountHash, 0, false);
				}
			}
		}

		private void Spawn(string orePrefab, int stack)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			ItemConversion itemConversion = GetItemConversion(orePrefab);
			if (itemConversion != null && !((Object)(object)itemConversion.m_to == (Object)null))
			{
				m_produceEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				GameObject val = Object.Instantiate<GameObject>(((Component)itemConversion.m_to).gameObject, m_outputPoint.position, m_outputPoint.rotation);
				ItemDrop component = val.GetComponent<ItemDrop>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_itemData.m_stack = Mathf.Max(1, stack);
				}
			}
		}

		private bool IsItemAllowed(ItemData item)
		{
			return item != null && IsItemAllowed(((Object)item.m_dropPrefab).name);
		}

		private bool IsItemAllowed(string itemPrefabName)
		{
			foreach (ItemConversion item in m_conversion)
			{
				if ((Object)(object)item?.m_from != (Object)null && ((Object)((Component)item.m_from).gameObject).name == itemPrefabName)
				{
					return true;
				}
			}
			return false;
		}

		private ItemData FindProcessableItem(Inventory inventory)
		{
			foreach (ItemConversion item2 in m_conversion)
			{
				if (!((Object)(object)item2?.m_from == (Object)null))
				{
					ItemData item = inventory.GetItem(item2.m_from.m_itemData.m_shared.m_name, -1, false);
					if (item != null)
					{
						return item;
					}
				}
			}
			return null;
		}

		private ItemConversion GetItemConversion(string fromPrefabName)
		{
			foreach (ItemConversion item in m_conversion)
			{
				if ((Object)(object)item?.m_from != (Object)null && ((Object)((Component)item.m_from).gameObject).name == fromPrefabName)
				{
					return item;
				}
			}
			return null;
		}

		private float GetSecondsForConversion(string fromPrefabName)
		{
			float num = GetItemConversion(fromPrefabName)?.m_secPerProduct ?? 0f;
			if (num <= 0f)
			{
				num = m_defaultSecPerProduct;
			}
			if (num <= 0f)
			{
				num = 60f;
			}
			return num;
		}

		private bool OnAddOre(Switch sw, Humanoid user, ItemData item)
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return false;
			}
			if (GetQueueSize() >= m_maxOre)
			{
				((Character)user).Message((MessageType)2, "$msg_itsfull", 0, (Sprite)null);
				return false;
			}
			if (item != null && !IsItemAllowed(item))
			{
				((Character)user).Message((MessageType)2, "$msg_wontwork", 0, (Sprite)null);
				return false;
			}
			if (item == null)
			{
				item = FindProcessableItem(user.GetInventory());
				if (item == null)
				{
					((Character)user).Message((MessageType)2, "$msg_noprocessableitems", 0, (Sprite)null);
					return false;
				}
			}
			((Character)user).Message((MessageType)2, "$msg_added " + item.m_shared.m_name, 0, (Sprite)null);
			user.GetInventory().RemoveItem(item, 1);
			m_nview.InvokeRPC("AddOre", new object[1] { ((Object)item.m_dropPrefab).name });
			m_addedOreTime = Time.time;
			if (m_addOreAnimationDuration > 0f)
			{
				SetAnimation(active: true);
			}
			return true;
		}

		private void RPC_AddOre(long sender, string prefabNameToQueue)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid() && m_nview.IsOwner())
			{
				if (!IsItemAllowed(prefabNameToQueue))
				{
					ZLog.LogWarning((object)("[BalrondConverter] Item not allowed '" + prefabNameToQueue + "'"));
					return;
				}
				QueueOre(prefabNameToQueue);
				m_oreAddedEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
			}
		}

		private bool OnAddFuel(Switch sw, Humanoid user, ItemData item)
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return false;
			}
			if (m_maxFuel == 0)
			{
				return false;
			}
			if ((Object)(object)m_fuelItem == (Object)null)
			{
				return false;
			}
			string name = ((Object)((Component)m_fuelItem).gameObject).name;
			string name2 = m_fuelItem.m_itemData.m_shared.m_name;
			if (item != null && ((Object)item.m_dropPrefab).name != name)
			{
				((Character)user).Message((MessageType)2, "$msg_wrongitem", 0, (Sprite)null);
				return false;
			}
			int fuelUnitsCapacity = GetFuelUnitsCapacity();
			int fuelUnits = GetFuelUnits();
			int num = Mathf.Max(1, m_usesPerBlade);
			if (fuelUnits > fuelUnitsCapacity - num)
			{
				((Character)user).Message((MessageType)2, "$msg_itsfull", 0, (Sprite)null);
				return false;
			}
			if (!user.GetInventory().HaveItem(name2, true))
			{
				((Character)user).Message((MessageType)2, "$msg_donthaveany " + m_fuelItem.m_itemData.m_shared.m_name, 0, (Sprite)null);
				return false;
			}
			((Character)user).Message((MessageType)2, "$msg_added " + m_fuelItem.m_itemData.m_shared.m_name, 0, (Sprite)null);
			user.GetInventory().RemoveItem(name2, 1, -1, true);
			m_nview.InvokeRPC("AddFuel", Array.Empty<object>());
			return true;
		}

		private void RPC_AddFuel(long sender)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid() && m_nview.IsOwner())
			{
				int num = Mathf.Max(1, m_usesPerBlade);
				int fuelUnitsCapacity = GetFuelUnitsCapacity();
				int fuelUnits = GetFuelUnits();
				fuelUnits = Mathf.Min(fuelUnitsCapacity, fuelUnits + num);
				SetFuelUnits(fuelUnits);
				m_fuelAddedEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform, 1f, -1);
			}
		}

		private bool OnEmpty(Switch sw, Humanoid user, ItemData item)
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return false;
			}
			if (GetProcessedQueueSize() <= 0)
			{
				return false;
			}
			m_nview.InvokeRPC("ConverterEmptyProcessed", Array.Empty<object>());
			return true;
		}

		private void RPC_ConverterEmptyProcessed(long sender)
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid() && m_nview.IsOwner())
			{
				SpawnProcessed();
			}
		}

		private double GetDeltaTime()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid() || (Object)(object)ZNet.instance == (Object)null)
			{
				return 0.0;
			}
			DateTime time = ZNet.instance.GetTime();
			DateTime dateTime = new DateTime(m_nview.GetZDO().GetLong(s_startTimeHash, time.Ticks));
			double totalSeconds = (time - dateTime).TotalSeconds;
			m_nview.GetZDO().Set(s_startTimeHash, time.Ticks);
			return totalSeconds;
		}

		private void UpdateBalrondConverter()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return;
			}
			UpdateState();
			if (!m_nview.IsOwner())
			{
				return;
			}
			double deltaTime = GetDeltaTime();
			float num = GetAccumulator() + (float)deltaTime;
			if (num > 3600f)
			{
				num = 3600f;
			}
			float num2 = (Object.op_Implicit((Object)(object)m_windmill) ? m_windmill.GetPowerOutput() : 1f);
			if (num2 <= 0f)
			{
				num2 = 0f;
			}
			while (num >= 1f)
			{
				num -= 1f;
				if (!HasActiveJob())
				{
					TryStartJobIfPossible();
				}
				string jobOre = GetJobOre();
				if (string.IsNullOrEmpty(jobOre))
				{
					continue;
				}
				float secondsForConversion = GetSecondsForConversion(jobOre);
				if (!(secondsForConversion <= 0f))
				{
					float num3 = 1f * num2;
					float num4 = GetBakeTimer() + num3;
					if (num4 < secondsForConversion)
					{
						SetBakeTimer(num4);
					}
					else
					{
						CompleteJobAndSpawnOutput();
					}
				}
			}
			if (GetQueuedOre() == "" && !HasActiveJob())
			{
				SpawnProcessed();
			}
			SetAccumulator(num);
		}

		private void UpdateState()
		{
			bool flag = IsActive();
			if (Object.op_Implicit((Object)(object)m_enabledObject))
			{
				m_enabledObject.SetActive(flag);
			}
			if (Object.op_Implicit((Object)(object)m_disabledObject))
			{
				m_disabledObject.SetActive(!flag);
			}
			if (Object.op_Implicit((Object)(object)m_haveFuelObject))
			{
				m_haveFuelObject.SetActive(HasAnyFuel() && !flag);
			}
			if (Object.op_Implicit((Object)(object)m_haveOreObject))
			{
				m_haveOreObject.SetActive(GetQueueSize() > 0 || HasActiveJob());
			}
			if (Object.op_Implicit((Object)(object)m_noOreObject))
			{
				m_noOreObject.SetActive(GetQueueSize() == 0 && !HasActiveJob());
			}
			if (m_addOreAnimationDuration > 0f && Time.time - m_addedOreTime < m_addOreAnimationDuration)
			{
				flag = true;
			}
			SetAnimation(flag);
		}

		private void SetAnimation(bool active)
		{
			if (m_animators == null)
			{
				return;
			}
			Animator[] animators = m_animators;
			foreach (Animator val in animators)
			{
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy)
				{
					val.SetBool("active", active);
					val.SetFloat("activef", active ? 1f : 0f);
				}
			}
		}

		public bool IsActive()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return false;
			}
			if (!HasActiveJob() && GetQueueSize() <= 0)
			{
				return false;
			}
			if (HasActiveJob())
			{
				return true;
			}
			if (m_maxFuel == 0)
			{
				return true;
			}
			string queuedOre = GetQueuedOre();
			if (string.IsNullOrEmpty(queuedOre))
			{
				return false;
			}
			int fuelCostForOre = GetFuelCostForOre(queuedOre);
			return GetFuelUnits() >= fuelCostForOre;
		}

		private string OnHoverAddFuel()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return Localization.instance.Localize(m_name);
			}
			string text = (Object.op_Implicit((Object)(object)m_fuelItem) ? m_fuelItem.m_itemData.m_shared.m_name : "Fuel");
			int perFuelItemUnits = GetPerFuelItemUnits();
			int fuelUnits = GetFuelUnits();
			int fuelUnitsCapacity = GetFuelUnitsCapacity();
			int queueSize = GetQueueSize();
			m_sb.Clear();
			m_sb.Append(m_name + "\n");
			m_sb.Append($"Fuel: {fuelUnits}/{fuelUnitsCapacity} units (+{perFuelItemUnits} per {text})");
			string queuedOre = GetQueuedOre();
			if (!string.IsNullOrEmpty(queuedOre))
			{
				string arg = GetItemConversion(queuedOre)?.m_from?.m_itemData?.m_shared?.m_name ?? queuedOre;
				int fuelCostForOre = GetFuelCostForOre(queuedOre);
				m_sb.Append($"\nNext: {arg} (cost {fuelCostForOre} units)");
				if (m_maxFuel > 0 && fuelUnits < fuelCostForOre)
				{
					m_sb.Append($"\nNeed {fuelCostForOre - fuelUnits} more units to start");
				}
				else if (queueSize > 0)
				{
					m_sb.Append("\nReady to start");
				}
			}
			else if (HasActiveJob())
			{
				string jobOre = GetJobOre();
				string text2 = GetItemConversion(jobOre)?.m_from?.m_itemData?.m_shared?.m_name ?? jobOre;
				m_sb.Append("\nProcessing: " + text2);
			}
			else if (prefabName == "piece_leatherRack_bal")
			{
				m_sb.Append("\nAdd a hide to see cost");
			}
			m_sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] Add " + text);
			return Localization.instance.Localize(m_sb.ToString());
		}

		private string OnHoverEmptyOre()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return Localization.instance.Localize(m_name);
			}
			return Localization.instance.Localize($"{m_name} ({GetProcessedQueueSize()} Ready)\n" + "[<color=yellow><b>$KEY_Use</b></color>] " + m_emptyOreTooltip);
		}

		private string OnHoverAddOre()
		{
			if (!Object.op_Implicit((Object)(object)m_nview) || !m_nview.IsValid())
			{
				return Localization.instance.Localize(m_name);
			}
			int fuelUnits = GetFuelUnits();
			int fuelUnitsCapacity = GetFuelUnitsCapacity();
			int queueSize = GetQueueSize();
			m_sb.Clear();
			m_sb.Append($"{m_name} (Queue {queueSize}/{m_maxOre})");
			if (m_maxFuel > 0)
			{
				m_sb.Append($"\nFuel: {fuelUnits}/{fuelUnitsCapacity} units");
			}
			if (HasActiveJob())
			{
				string jobOre = GetJobOre();
				string arg = GetItemConversion(jobOre)?.m_from?.m_itemData?.m_shared?.m_name ?? jobOre;
				float secondsForConversion = GetSecondsForConversion(jobOre);
				m_sb.Append($"\nProcessing: {arg} ({Mathf.CeilToInt(secondsForConversion)}s)");
			}
			else
			{
				string queuedOre = GetQueuedOre();
				if (!string.IsNullOrEmpty(queuedOre))
				{
					string arg2 = GetItemConversion(queuedOre)?.m_from?.m_itemData?.m_shared?.m_name ?? queuedOre;
					int fuelCostForOre = GetFuelCostForOre(queuedOre);
					float secondsForConversion2 = GetSecondsForConversion(queuedOre);
					m_sb.Append($"\nNext: {arg2} (cost {fuelCostForOre} units, {Mathf.CeilToInt(secondsForConversion2)}s)");
					if (m_maxFuel > 0 && fuelUnits < fuelCostForOre)
					{
						m_sb.Append($"\nStatus: Need {fuelCostForOre - fuelUnits} more units");
					}
					else
					{
						m_sb.Append("\nStatus: Ready");
					}
				}
				else
				{
					m_sb.Append("\nStatus: " + m_addOreTooltip);
				}
			}
			m_sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] ");
			m_sb.Append(m_addOreTooltip);
			return Localization.instance.Localize(m_sb.ToString());
		}

		private int GetPerFuelItemUnits()
		{
			return Mathf.Max(1, m_usesPerBlade);
		}

		private void OnDestroyed()
		{
			if (Object.op_Implicit((Object)(object)m_nview) && m_nview.IsValid() && m_nview.IsOwner())
			{
				DropAllItems();
			}
		}

		private void DropAllItems()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			SpawnProcessed();
			string jobOre = GetJobOre();
			if (!string.IsNullOrEmpty(jobOre))
			{
				ItemConversion itemConversion = GetItemConversion(jobOre);
				if ((Object)(object)itemConversion?.m_from != (Object)null)
				{
					Vector3 val = ((Component)this).transform.position + Vector3.up + Random.insideUnitSphere * 0.3f;
					Quaternion val2 = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
					Object.Instantiate<GameObject>(((Component)itemConversion.m_from).gameObject, val, val2);
				}
				SetJobOre("");
				SetBakeTimer(0f);
			}
			if ((Object)(object)m_fuelItem != (Object)null && m_maxFuel > 0)
			{
				int num = GetFuelUnits() + GetReservedFuelUnits();
				SetFuelUnits(0);
				SetReservedFuelUnits(0);
				int num2 = Mathf.Max(1, m_usesPerBlade);
				int num3 = num / num2;
				for (int i = 0; i < num3; i++)
				{
					Vector3 val3 = ((Component)this).transform.position + Vector3.up + Random.insideUnitSphere * 0.3f;
					Quaternion val4 = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
					Object.Instantiate<GameObject>(((Component)m_fuelItem).gameObject, val3, val4);
				}
			}
			else
			{
				SetFuelUnits(0);
				SetReservedFuelUnits(0);
			}
			while (GetQueueSize() > 0)
			{
				string queuedOre = GetQueuedOre();
				RemoveOneOre();
				ItemConversion itemConversion2 = GetItemConversion(queuedOre);
				if ((Object)(object)itemConversion2?.m_from != (Object)null)
				{
					Vector3 val5 = ((Component)this).transform.position + Vector3.up + Random.insideUnitSphere * 0.3f;
					Quaternion val6 = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
					Object.Instantiate<GameObject>(((Component)itemConversion2.m_from).gameObject, val5, val6);
				}
			}
		}
	}
	public static class BalrondConverterInstaller
	{
		public const string SAWMILL_PREFAB = "piece_sawmill_bal";

		public const string TANNING_PREFAB = "piece_leatherRack_bal";

		public const string STONEKILN_PREFAB = "StoneboundKiln_bal";

		public const string SAWMILL_FUEL_PREFAB = "SawBlade_bal";

		public const string TANNING_FUEL_PREFAB = "PatchworkBundle_bal";

		public const string STONEKILN_FUEL_PREFAB = "SurtlingCore";

		public const string STONEKILN_WOOD_PREFAB = "WoodBundle_bal";

		public const string STONEKILN_CLAY_PREFAB = "ClayBundle_bal";

		private const int SAWMILL_MAX_FUEL_ITEMS = 1;

		private const int SAWMILL_USES_PER_FUEL_ITEM = 100;

		private const int SAWMILL_MAX_ORE = 10;

		private const float SAWMILL_DEFAULT_SECONDS = 60f;

		private const int STONEKILN_MAX_FUEL_ITEMS = 0;

		private const int STONEKILN_USES_PER_FUEL_ITEM = 100;

		private const int STONEKILN_MAX_ORE = 40;

		private const float STONEKILN_DEFAULT_SECONDS = 60f;

		private const int TANNING_MAX_FUEL_ITEMS = 25;

		private const int TANNING_USES_PER_FUEL_ITEM = 1;

		private const int TANNING_MAX_ORE = 5;

		private const float TANNING_DEFAULT_SECONDS = 60f;

		public static void SetBalrondConverter(ZNetScene zNetScene)
		{
			if ((Object)(object)zNetScene == (Object)null || zNetScene.m_prefabs == null)
			{
				Debug.LogWarning((object)"[Balrond] ZNetScene or prefabs list is null; cannot set up converters.");
				return;
			}
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "SawBlade_bal");
			GameObject val2 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "PatchworkBundle_bal");
			Dictionary<string, GameObject> prefabsByName = BuildPrefabMap(zNetScene.m_prefabs);
			SetupOneConverter(prefabsByName, zNetScene, "piece_sawmill_bal", ApplySawmillDefaults);
			SetupOneConverter(prefabsByName, zNetScene, "piece_leatherRack_bal", ApplyTanningDefaults);
			SetupOneConverter(prefabsByName, zNetScene, "StoneboundKiln_bal", ApplyStoneboudnKilnlDefaults);
		}

		private static Dictionary<string, GameObject> BuildPrefabMap(List<GameObject> prefabs)
		{
			Dictionary<string, GameObject> dictionary = new Dictionary<string, GameObject>(StringComparer.Ordinal);
			for (int i = 0; i < prefabs.Count; i++)
			{
				GameObject val = prefabs[i];
				if (!((Object)(object)val == (Object)null) && !dictionary.ContainsKey(((Object)val).name))
				{
					dictionary.Add(((Object)val).name, val);
				}
			}
			return dictionary;
		}

		private static void SetupOneConverter(Dictionary<string, GameObject> prefabsByName, ZNetScene zNetScene, string stationPrefabName, Action<BalrondConverter, Dictionary<string, GameObject>> applyDefaults)
		{
			if (!prefabsByName.TryGetValue(stationPrefabName, out var value) || (Object)(object)value == (Object)null)
			{
				Debug.LogWarning((object)("[Balrond] Station prefab '" + stationPrefabName + "' not found in ZNetScene.m_prefabs."));
				return;
			}
			if ((Object)(object)value.GetComponent<BalrondConverter>() != (Object)null)
			{
				Debug.Log((object)("[Balrond] BalrondConverter already present on '" + stationPrefabName + "', skipping."));
				return;
			}
			Smelter component = value.GetComponent<Smelter>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("[Balrond] Station prefab '" + stationPrefabName + "' has no Smelter component to transfer from."));
				return;
			}
			Debug.Log((object)("[Balrond] Installing BalrondConverter on '" + stationPrefabName + "'"));
			TransferSmelterToBalrondConverter(value, component, prefabsByName, stationPrefabName, zNetScene, applyDefaults);
		}

		private static void TransferSmelterToBalrondConverter(GameObject stationPrefab, Smelter smelter, Dictionary<string, GameObject> prefabsByName, string stationPrefabName, ZNetScene zNetScene, Action<BalrondConverter, Dictionary<string, GameObject>> applyDefaults)
		{
			BalrondConverter balrondConverter = stationPrefab.AddComponent<BalrondConverter>();
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "SawBlade_bal");
			GameObject val2 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "SurtlingCore");
			GameObject val3 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "PatchworkBundle_bal");
			if (stationPrefabName == "piece_leatherRack_bal")
			{
				balrondConverter.m_fuelItem = val3.GetComponent<ItemDrop>();
			}
			if (stationPrefabName == "piece_sawmill_bal")
			{
				balrondConverter.m_fuelItem = val.GetComponent<ItemDrop>();
			}
			if (stationPrefabName == "StoneboundKiln_bal")
			{
				balrondConverter.m_fuelItem = val2.GetComponent<ItemDrop>();
			}
			balrondConverter.m_addOreAnimationDuration = 0f;
			balrondConverter.m_addOreSwitch = smelter.m_addOreSwitch;
			balrondConverter.m_addOreTooltip = smelter.m_addOreTooltip;
			balrondConverter.m_addWoodSwitch = smelter.m_addWoodSwitch;
			balrondConverter.m_emptyOreSwitch = smelter.m_emptyOreSwitch;
			balrondConverter.m_emptyOreTooltip = smelter.m_emptyOreTooltip;
			balrondConverter.m_animators = smelter.m_animators;
			balrondConverter.m_enabledObject = smelter.m_enabledObject;
			balrondConverter.m_disabledObject = smelter.m_disabledObject;
			balrondConverter.m_haveFuelObject = smelter.m_haveFuelObject;
			balrondConverter.m_haveOreObject = smelter.m_haveOreObject;
			balrondConverter.m_noOreObject = smelter.m_noOreObject;
			balrondConverter.m_outputPoint = smelter.m_outputPoint;
			balrondConverter.m_roofCheckPoint = smelter.m_roofCheckPoint;
			balrondConverter.m_requiresRoof = smelter.m_requiresRoof;
			balrondConverter.m_windmill = smelter.m_windmill;
			balrondConverter.m_smokeSpawner = smelter.m_smokeSpawner;
			balrondConverter.m_spawnStack = smelter.m_spawnStack;
			balrondConverter.m_oreAddedEffects = smelter.m_oreAddedEffects;
			balrondConverter.m_fuelAddedEffects = smelter.m_fuelAddedEffects;
			balrondConverter.m_produceEffects = smelter.m_produceEffects;
			balrondConverter.m_name = smelter.m_name;
			balrondConverter.m_defaultSecPerProduct = ((smelter.m_secPerProduct > 0f) ? smelter.m_secPerProduct : 60f);
			Object.DestroyImmediate((Object)(object)smelter);
			applyDefaults?.Invoke(balrondConverter, prefabsByName);
			balrondConverter.prefabName = stationPrefabName;
		}

		private static void DebugFuel(BalrondConverter conv, string fuelItem)
		{
			if (conv.m_maxFuel > 0 && (Object)(object)conv.m_fuelItem == (Object)null)
			{
				Debug.LogWarning((object)("[Balrond] " + fuelItem + " fuel item not found." + conv.m_name + " will not accept fuel."));
			}
		}

		private static void ApplySawmillDefaults(BalrondConverter conv, Dictionary<string, GameObject> prefabsByName)
		{
			conv.m_maxFuel = 1;
			conv.m_usesPerBlade = 100;
			conv.m_maxOre = 10;
			conv.m_defaultSecPerProduct = 60f;
			conv.m_addOreTooltip = "$tag_sawmill_addWood";
			conv.m_emptyOreTooltip = "$tag_sawmill_pickupWood";
			DebugFuel(conv, "SawBlade_bal");
		}

		private static void ApplyStoneboudnKilnlDefaults(BalrondConverter conv, Dictionary<string, GameObject> prefabsByName)
		{
			conv.m_maxFuel = 0;
			conv.m_usesPerBlade = 100;
			conv.m_maxOre = 40;
			conv.m_defaultSecPerProduct = 60f;
			DebugFuel(conv, "SurtlingCore");
		}

		private static void ApplyTanningDefaults(BalrondConverter conv, Dictionary<string, GameObject> prefabsByName)
		{
			conv.m_maxFuel = 25;
			conv.m_usesPerBlade = 1;
			conv.m_maxOre = 5;
			conv.m_defaultSecPerProduct = 60f;
			conv.m_addOreTooltip = "$tag_leatherrack_addLeather";
			conv.m_emptyOreTooltip = "$tag_leatherrack_pickupLeather";
			DebugFuel(conv, "PatchworkBundle_bal");
		}
	}
	public class DatabaseAddMethods
	{
		public void AddItems(List<GameObject> items)
		{
			foreach (GameObject item in items)
			{
				AddItem(item);
			}
		}

		public void AddRecipes(List<Recipe> recipes)
		{
			foreach (Recipe recipe in recipes)
			{
				AddRecipe(recipe);
			}
		}

		public void AddStatuseffects(List<StatusEffect> statusEffects)
		{
			foreach (StatusEffect statusEffect in statusEffects)
			{
				AddStatus(statusEffect);
			}
		}

		private bool IsObjectDBValid()
		{
			return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
		}

		private void AddStatus(StatusEffect status)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			if ((Object)(object)status != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetStatusEffect(status.m_nameHash) == (Object)null)
				{
					ObjectDB.instance.m_StatusEffects.Add(status);
				}
			}
			else
			{
				Debug.LogError((object)(Launch.projectName + ":  " + ((Object)status).name + " - Status not found"));
			}
		}

		private void AddRecipe(Recipe recipe)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			if ((Object)(object)recipe != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.m_recipes.Find((Recipe x) => ((Object)x).name == ((Object)recipe).name) == (Object)null && (Object)(object)recipe.m_item != (Object)null)
				{
					ObjectDB.instance.m_recipes.Add(recipe);
				}
			}
			else
			{
				Debug.LogError((object)(Launch.projectName + ":  " + ((Object)recipe).name + " - Recipe not found"));
			}
		}

		private void AddItem(GameObject newPrefab)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			ItemDrop component = newPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetItemPrefab(((Object)newPrefab).name) == (Object)null)
				{
					ObjectDB.instance.m_items.Add(newPrefab);
					Dictionary<int, GameObject> dictionary = (Dictionary<int, GameObject>)typeof(ObjectDB).GetField("m_itemByHash", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(ObjectDB.instance);
					dictionary[((Object)newPrefab).name.GetHashCode()] = newPrefab;
				}
			}
			else
			{
				Debug.LogError((object)(Launch.projectName + ": " + ((Object)newPrefab).name + " - ItemDrop not found on prefab"));
			}
		}
	}
	public class FxReplacment
	{
		public void ReplaceOnObject(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			SpawnArea component = gameObject.GetComponent<SpawnArea>();
			if ((Object)(object)component != (Object)null)
			{
				EffectList spawnEffects = component.m_spawnEffects;
				if (spawnEffects != null)
				{
					findEffectsAndChange(spawnEffects.m_effectPrefabs, zNetScene);
				}
			}
			Destructible component2 = gameObject.GetComponent<Destructible>();
			if ((Object)(object)component2 != (Object)null)
			{
				EffectList hitEffect = component2.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
				}
				EffectList destroyedEffect = component2.m_destroyedEffect;
				if (destroyedEffect != null)
				{
					findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
				}
			}
			Projectile component3 = gameObject.GetComponent<Projectile>();
			if ((Object)(object)component3 != (Object)null)
			{
				EffectList hitEffects = component3.m_hitEffects;
				if (hitEffects != null)
				{
					findEffectsAndChange(hitEffects.m_effectPrefabs, zNetScene);
				}
				EffectList hitWaterEffects = component3.m_hitWaterEffects;
				if (hitWaterEffects != null)
				{
					findEffectsAndChange(hitWaterEffects.m_effectPrefabs, zNetScene);
				}
				EffectList spawnOnHitEffects = component3.m_spawnOnHitEffects;
				if (spawnOnHitEffects != null)
				{
					findEffectsAndChange(spawnOnHitEffects.m_effectPrefabs, zNetScene);
				}
			}
		}

		public void ReplaceOnVegetation(GameObject gameObject, ZNetScene zNetScene)
		{
			Pickable component = gameObject.GetComponent<Pickable>();
			if ((Object)(object)component != (Object)null)
			{
				fixPlant(component, zNetScene);
			}
			Destructible component2 = gameObject.GetComponent<Destructible>();
			if ((Object)(object)component2 != (Object)null)
			{
				fixPDestructable(component2, zNetScene);
			}
			MineRock5 component3 = gameObject.GetComponent<MineRock5>();
			if ((Object)(object)component3 != (Object)null)
			{
				fixMineRock5(component3, zNetScene);
			}
			MineRock component4 = gameObject.GetComponent<MineRock>();
			if ((Object)(object)component4 != (Object)null)
			{
				fixMineRock(component4, zNetScene);
			}
		}

		private void fixPlant(Pickable pickable, ZNetScene zNetScene)
		{
			EffectList pickEffector = pickable.m_pickEffector;
			if (pickEffector != null)
			{
				findEffectsAndChange(pickEffector.m_effectPrefabs, zNetScene);
			}
		}

		private void fixPDestructable(Destructible minerock5, ZNetScene zNetScene)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
			}
		}

		private void fixMineRock5(MineRock5 minerock5, ZNetScene zNetScene)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
			}
		}

		private void fixMineRock(MineRock minerock5, ZNetScene zNetScene)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs, zNetScene);
			}
		}

		public void ReplaceOnMonster(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Debug.LogWarning((object)(Launch.projectName + ":: GameObject not found"));
				return;
			}
			Humanoid component = gameObject.GetComponent<Humanoid>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)(Launch.projectName + ":: GameObject not found"));
				return;
			}
			EffectList dropEffects = component.m_dropEffects;
			if (dropEffects != null)
			{
				findEffectsAndChange(dropEffects.m_effectPrefabs, zNetScene);
			}
			EffectList backstabHitEffects = ((Character)component).m_backstabHitEffects;
			if (backstabHitEffects != null)
			{
				findEffectsAndChange(backstabHitEffects.m_effectPrefabs, zNetScene);
			}
			EffectList consumeItemEffects = component.m_consumeItemEffects;
			if (consumeItemEffects != null)
			{
				findEffectsAndChange(consumeItemEffects.m_effectPrefabs, zNetScene);
			}
			EffectList critHitEffects = ((Character)component).m_critHitEffects;
			if (critHitEffects != null)
			{
				findEffectsAndChange(critHitEffects.m_effectPrefabs, zNetScene);
			}
			EffectList deathEffects = ((Character)component).m_deathEffects;
			if (deathEffects != null)
			{
				findEffectsAndChange(deathEffects.m_effectPrefabs, zNetScene);
			}
			EffectList hitEffects = ((Character)component).m_hitEffects;
			if (hitEffects != null)
			{
				findEffectsAndChange(hitEffects.m_effectPrefabs, zNetScene);
			}
			EffectList jumpEffects = ((Character)component).m_jumpEffects;
			if (jumpEffects != null)
			{
				findEffectsAndChange(jumpEffects.m_effectPrefabs, zNetScene);
			}
			EffectList perfectBlockEffect = component.m_perfectBlockEffect;
			if (perfectBlockEffect != null)
			{
				findEffectsAndChange(perfectBlockEffect.m_effectPrefabs, zNetScene);
			}
			EffectList pickupEffects = component.m_pickupEffects;
			if (pickupEffects != null)
			{
				findEffectsAndChange(pickupEffects.m_effectPrefabs, zNetScene);
			}
			EffectList slideEffects = ((Character)component).m_slideEffects;
			if (slideEffects != null)
			{
				findEffectsAndChange(slideEffects.m_effectPrefabs, zNetScene);
			}
			EffectList tarEffects = ((Character)component).m_tarEffects;
			if (tarEffects != null)
			{
				findEffectsAndChange(tarEffects.m_effectPrefabs, zNetScene);
			}
			EffectList waterEffects = ((Character)component).m_waterEffects;
			if (waterEffects != null)
			{
				findEffectsAndChange(waterEffects.m_effectPrefabs, zNetScene);
			}
			FootStep component2 = gameObject.GetComponent<FootStep>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return;
			}
			List<StepEffect> effects = component2.m_effects;
			foreach (StepEffect item in effects)
			{
				GameObject[] effectPrefabs = item.m_effectPrefabs;
				List<GameObject> list = new List<GameObject>();
				list.AddRange(effectPrefabs);
				for (int i = 0; i < list.Count; i++)
				{
					if ((Object)(object)list[i] != (Object)null)
					{
						string name = ((Object)list[i]).name;
						GameObject val = ZNetScene.instance.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
						if (!((Object)(object)val == (Object)null))
						{
							list[i] = val;
						}
					}
				}
			}
		}

		public void ReplaceOnItem(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			if (!((Object)(object)component == (Object)null))
			{
				EffectList hitEffect = component.m_itemData.m_shared.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
				}
				EffectList hitTerrainEffect = component.m_itemData.m_shared.m_hitTerrainEffect;
				if (hitTerrainEffect != null)
				{
					findEffectsAndChange(hitTerrainEffect.m_effectPrefabs, zNetScene);
				}
				EffectList holdStartEffect = component.m_itemData.m_shared.m_holdStartEffect;
				if (holdStartEffect != null)
				{
					findEffectsAndChange(holdStartEffect.m_effectPrefabs, zNetScene);
				}
				EffectList trailStartEffect = component.m_itemData.m_shared.m_trailStartEffect;
				if (trailStartEffect != null)
				{
					findEffectsAndChange(trailStartEffect.m_effectPrefabs, zNetScene);
				}
				EffectList blockEffect = component.m_itemData.m_shared.m_blockEffect;
				if (blockEffect != null)
				{
					findEffectsAndChange(blockEffect.m_effectPrefabs, zNetScene);
				}
			}
		}

		public void ReplaceFxOnPiece(GameObject gameObject, ZNetScene zNetScene)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Piece component = gameObject.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				EffectList placeEffect = component.m_placeEffect;
				if (placeEffect != null)
				{
					findEffectsAndChange(placeEffect.m_effectPrefabs, zNetScene);
				}
			}
			WearNTear component2 = gameObject.GetComponent<WearNTear>();
			if ((Object)(object)component2 != (Object)null)
			{
				EffectList hitEffect = component2.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs, zNetScene);
				}
			}
		}

		private void findEffectsAndChange(EffectData[] effects, ZNetScene zNetScene)
		{
			if (effects == null || effects.Length == 0)
			{
				return;
			}
			foreach (EffectData val in effects)
			{
				if ((Object)(object)val.m_prefab != (Object)null)
				{
					string name = ((Object)val.m_prefab).name;
					GameObject val2 = zNetScene.m_prefabs.Find((GameObject x) => (Object)(object)x != (Object)null && ((Object)x).name == name);
					if ((Object)(object)val2 != (Object)null)
					{
						val.m_prefab = val2;
					}
					else
					{
						Debug.LogWarning((object)("Coulnt not find in Znet fx name:" + name));
					}
				}
			}
		}
	}
	public class ModResourceLoader
	{
		public AssetBundle assetBundle;

		public List<GameObject> buildPrefabs = new List<GameObject>();

		public List<GameObject> plantPrefabs = new List<GameObject>();

		public List<GameObject> itemPrefabs = new List<GameObject>();

		public List<GameObject> monsterPrefabs = new List<GameObject>();

		public List<GameObject> vegetationPrefabs = new List<GameObject>();

		public List<GameObject> clutterPrefabs = new List<GameObject>();

		public List<GameObject> locationPrefabs = new List<GameObject>();

		public List<GameObject> roomPrefabs = new List<GameObject>();

		public List<GameObject> vfxPrefabs = new List<GameObject>();

		public List<Sprite> backgrounds = new List<Sprite>();

		public List<Sprite> minimapIcons = new List<Sprite>();

		public FxReplacment fxReplacment = new FxReplacment();

		public List<Recipe> recipes = new List<Recipe>();

		public List<StatusEffect> statusEffects = new List<StatusEffect>();

		public VegetationDropFix vegetationDropFix = new VegetationDropFix();

		public ShaderReplacment shaderReplacment = new ShaderReplacment();

		public void loadAssets()
		{
			assetBundle = GetAssetBundleFromResources("papayonrepacktrees");
			string text = "Assets/Custom/Comission/BalrondTreesNDecor/";
			string text2 = ".png";
			string text3 = text + "icons/";
			loadPieces(text);
			loadPlants(text);
			loadItems(text);
			loadVegetation(text);
			loadLocations(text);
			loadOther(text);
		}

		public void AddPrefabsToZnetScene(ZNetScene zNetScene)
		{
			List<List<GameObject>> list = new List<List<GameObject>> { itemPrefabs, plantPrefabs, vfxPrefabs, buildPrefabs, locationPrefabs, vegetationPrefabs, clutterPrefabs, monsterPrefabs };
			foreach (List<GameObject> item in list)
			{
				validateAddedPrefabs(item, zNetScene);
			}
			zNetScene.m_prefabs.RemoveAll((GameObject x) => (Object)(object)x == (Object)null);
		}

		public void setSpawnStatusOnItem(GameObject gameObject, StatusEffect statusEffect)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Debug.LogWarning((object)"Item Not Found on list!");
			}
			else
			{
				gameObject.GetComponent<ItemDrop>().m_itemData.m_shared.m_consumeStatusEffect = statusEffect;
			}
		}

		private void validateAddedPrefabs(List<GameObject> list, ZNetScene zNetScene)
		{
			foreach (GameObject item in list)
			{
				if (zNetScene.m_namedPrefabs.ContainsKey(BalrondHashCompat.StableHash(((Object)item).name)))
				{
					Debug.LogWarning((object)("DUPLICATE: " + ((Object)item).name));
				}
				else
				{
					zNetScene.m_prefabs.Add(item);
				}
			}
		}

		private void loadBackground(string mainPath)
		{
			string[] array = new string[5] { "ashlands1.jpg", "ashlands2.png", "blackforest.png", "mistlands.jpg", "meadows.png" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				Sprite val = assetBundle.LoadAsset<Sprite>(mainPath + "screens/" + text);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find background with name: " + text));
				}
				else
				{
					backgrounds.Add(val);
				}
			}
		}

		private GameObject FindPrefabInZnet(string name, ZNetScene zNetScene)
		{
			GameObject value = null;
			zNetScene.m_namedPrefabs.TryGetValue(BalrondHashCompat.StableHash(name), out value);
			if ((Object)(object)value == (Object)null)
			{
				value = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
			}
			return value;
		}

		public void setupBuildPiecesList(ZNetScene zNetScene)
		{
			string[] array = new string[5] { "Hammer", "HammerIron_bal", "HammerDverger_bal", "HammerBlackmetal_bal", "HammerMythic_bal" };
			GameObject val = FindPrefabInZnet("Hammer", zNetScene);
			PieceTable buildPieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			string[] array2 = array;
			foreach (string name in array2)
			{
				addTableToTool(name, buildPieces, zNetScene);
			}
			List<GameObject> pieces = buildPieces.m_pieces;
			foreach (GameObject buildPrefab in buildPrefabs)
			{
				setupRavenGuide(buildPrefab, zNetScene);
				AddToBuildList(buildPrefab, pieces);
			}
			GameObject val2 = FindPrefabInZnet("Hoe", zNetScene);
			PieceTable buildPieces2 = val2.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			addTableToTool("BlackMetalHoe_bal", buildPieces2, zNetScene);
			GameObject val3 = FindPrefabInZnet("Cultivator", zNetScene);
			PieceTable buildPieces3 = val3.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			addTableToTool("BlackMetalCultivator_bal", buildPieces3, zNetScene);
		}

		private void addTableToTool(string name, PieceTable pieceTable, ZNetScene zNetScene)
		{
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
			if (!((Object)(object)val == (Object)null))
			{
				val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces = pieceTable;
			}
		}

		private GameObject getRavenGuidePrefab(ZNetScene zNetScene)
		{
			GameObject val = FindPrefabInZnet("Ravens", zNetScene);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			GameObject val2 = FindPrefabInZnet("piece_workbench", zNetScene);
			if ((Object)(object)val2 != (Object)null)
			{
				Transform val3 = val2.transform.Find("GuidePoint");
				if ((Object)(object)val3 != (Object)null)
				{
					GuidePoint component = ((Component)val3).GetComponent<GuidePoint>();
					if ((Object)(object)component != (Object)null)
					{
						return component.m_ravenPrefab;
					}
				}
			}
			return null;
		}

		public void setupRavenGuide(GameObject gameObject, ZNetScene zNetScene)
		{
			Transform val = gameObject.transform.Find("GuidePoint");
			if (!((Object)(object)val == (Object)null))
			{
				GameObject ravenGuidePrefab = getRavenGuidePrefab(zNetScene);
				if ((Object)(object)ravenGuidePrefab == (Object)null)
				{
					Debug.LogWarning((object)"Ravens not found");
				}
				else
				{
					((Component)val).GetComponent<GuidePoint>().m_ravenPrefab = ravenGuidePrefab;
				}
			}
		}

		public void setupBuildPiecesListDB()
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Hammer");
			List<GameObject> pieces = itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
			foreach (GameObject buildPrefab in buildPrefabs)
			{
				AddToBuildList(buildPrefab, pieces);
			}
		}

		private void AddToBuildList(GameObject prefab, List<GameObject> buildPieces)
		{
			if ((Object)(object)buildPieces.Find((GameObject x) => ((Object)x).name == ((Object)prefab).name) == (Object)null)
			{
				buildPieces.Add(prefab);
			}
		}

		public void addPlantstoCultivator(ZNetScene zNetScene)
		{
			GameObject val = FindPrefabInZnet("Cultivator", zNetScene);
			PieceTable buildPieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
			List<GameObject> pieces = buildPieces.m_pieces;
			foreach (GameObject gameObject in plantPrefabs)
			{
				if ((Object)(object)pieces.Find((GameObject x) => ((Object)x).name == ((Object)gameObject).name) == (Object)null)
				{
					pieces.Add(gameObject);
				}
			}
		}

		private AssetBundle GetAssetBundleFromResources(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = null;
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (text2.EndsWith(filename))
				{
					text = text2;
					break;
				}
			}
			if (text == null)
			{
				return null;
			}
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			return AssetBundle.LoadFromStream(stream);
		}

		private void addNewPrefabToCollection(string[] nameList, string mainPath, List<GameObject> prefabList, string typeName)
		{
			foreach (string text in nameList)
			{
				GameObject val = assetBundle.LoadAsset<GameObject>(mainPath + text + ".prefab");
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find " + typeName + " with name: " + text));
				}
				else if (Object.op_Implicit((Object)(object)val.GetComponent<ZNetView>()) || typeName == "clutter")
				{
					ShaderReplacment.Replace(val);
					prefabList.Add(val);
				}
				else
				{
					Debug.LogWarning((object)("Prefab with name has no ZNetView could not been removed: " + text));
				}
			}
		}

		private void loadPlants(string basePath)
		{
			string mainPath = basePath + "Plants/";
			string[] nameList = new string[28]
			{
				"sapling_Straw_bal", "sapling_Ygg_bal", "sapling_Swamp_bal", "sapling_Willow_bal", "sapling_BirchAtumn_bal", "sapling_Poplar_bal", "sapling_Maple_bal", "sapling_Cypress_bal", "sapling_AcaiTree_bal", "sapling_bush_blackberry_bal",
				"sapling_Bloodvine_bal", "sapling_bush_lingonberry_bal", "sapling_darkbul_bal", "sapling_DeadAcaiTree_bal", "sapling_eldermushroom_bal", "sapling_eldertree_bal", "sapling_Iced_bal", "sapling_ignicap_bal", "sapling_Kelp_bal", "sapling_Lavender_bal",
				"sapling_Oak2_bal", "sapling_oak3_bal", "sapling_Snowleaf_bal", "sapling_twisted_bal", "sapling_wettree_bal", "sapling_Yew_bal", "sapling_Ashtree1_bal", "sapling_Ashtree2_bal"
			};
			addNewPrefabToCollection(nameList, mainPath, plantPrefabs, "plant");
		}

		private void loadPieces(string basePath)
		{
			string mainPath = basePath + "Pieces/";
			string[] buildPieces = BuildPieceList.buildPieces;
			addNewPrefabToCollection(buildPieces, mainPath, buildPrefabs, "piece");
		}

		private void loadItems(string basePath)
		{
			string mainPath = basePath + "Items/";
			string[] items = ItemList.items;
			addNewPrefabToCollection(items, mainPath, itemPrefabs, "item");
		}

		private void loadVegetation(string basePath)
		{
			string mainPath = basePath + "Vegetation/";
			string[] vegetation = VegetationList.vegetation;
			addNewPrefabToCollection(vegetation, mainPath, vegetationPrefabs, "vegetation");
		}

		private void loadClutter(string basePath)
		{
			string mainPath = basePath + "Clutter/";
			string[] clutter = ClutterList.clutter;
			addNewPrefabToCollection(clutter, mainPath, clutterPrefabs, "clutter");
		}

		private void loadLocations(string basePath)
		{
			string text = basePath + "Location/";
			string[] array = new string[0];
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				GameObject val = assetBundle.LoadAsset<GameObject>(text + text2 + ".prefab");
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find location with name: " + text2));
					continue;
				}
				ShaderReplacment.Replace(val);
				locationPrefabs.Add(val);
			}
		}

		private void loadOther(string basePath)
		{
			string mainPath = basePath + "Other/";
			string[] vfx = VfxList.vfx;
			addNewPrefabToCollection(vfx, mainPath, vfxPrefabs, "vfx");
		}
	}
	public class ShaderReplacment
	{
		public static List<GameObject> prefabsToReplaceShader = new List<GameObject>();

		public static List<Material> materialsInPrefabs = new List<Material>();

		public static List<Shader> shaders = new List<Shader>();

		private static readonly HashSet<Shader> CachedShaders = new HashSet<Shader>();

		public static bool debug = true;

		public static Shader GetShaderByName(string name)
		{
			return shaders.Find((Shader s) => (Object)(object)s != (Object)null && ((Object)s).name.Trim() == name.Trim());
		}

		public static void Replace(GameObject gameObject)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (!new ZNet().IsDedicated())
			{
				prefabsToReplaceShader.Add(gameObject);
				CollectMaterialsFromPrefab(gameObject);
			}
		}

		private static void CollectMaterialsFromPrefab(GameObject gameObject)
		{
			Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null && !materialsInPrefabs.Contains(val2))
					{
						materialsInPrefabs.Add(val2);
					}
				}
			}
		}

		public static void LoadShadersFromBundles()
		{
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			AssetBundle[] array2 = array;
			foreach (AssetBundle val in array2)
			{
				try
				{
					Shader[] array3 = (val.isStreamedSceneAssetBundle ? (from s in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
						where (Object)(object)s != (Object)null
						select s).ToArray() : val.LoadAllAssets<Shader>());
					Shader[] array4 = array3;
					foreach (Shader item in array4)
					{
						CachedShaders.Add(item);
					}
				}
				catch
				{
				}
			}
		}

		public static void RunMaterialFix()
		{
			LoadShadersFromBundles();
			shaders.AddRange(CachedShaders);
			foreach (Material materialsInPrefab in materialsInPrefabs)
			{
				if (!((Object)(object)materialsInPrefab == (Object)null) && !((Object)(object)materialsInPrefab.shader == (Object)null))
				{
					string name = ((Object)materialsInPrefab.shader).name;
					if (!(name == "Standard") && !name.Contains("ScrollingTex") && name.Contains("Balrond"))
					{
						ReplaceShader(materialsInPrefab, name);
					}
				}
			}
		}

		private static void ReplaceShader(Material material, string oldShaderName)
		{
			string name = AdjustShaderName(oldShaderName.Replace("Balrond", "Custom"));
			Shader shaderByName = GetShaderByName(name);
			if (!((Object)(object)shaderByName == (Object)null))
			{
				material.shader = shaderByName;
			}
		}

		private static string AdjustShaderName(string name)
		{
			string result = name;
			if (name.Contains("Tess Bumped") || name.Contains("Bumped"))
			{
				result = name.Replace("Custom", "Lux Lit Particles");
			}
			if (name.Contains("Standard Surface"))
			{
				result = name.Replace("Custom", "Particles");
				result = result.Replace("Standard Surface2", "Standard Surface");
			}
			if (name.Contains("Standard Unlit"))
			{
				result = name.Replace("Custom", "Particles").Replace("Standard Unlit22", "Standard Unlit2").Replace("Standard Unlit", "Standard Unlit2");
			}
			return result;
		}
	}
	[HarmonyPatch]
	internal static class ConversionPatches
	{
		[HarmonyPatch(typeof(BalrondConverter), "Awake")]
		private class Patch_BalrondConverter_Awake
		{
			private static void Postfix(BalrondConverter __instance)
			{
				string prefabName = __instance.prefabName;
				if (prefabName != null)
				{
					if (prefabName.Contains("piece_sawmill_bal") && __instance.m_conversion.Count < 2)
					{
						Launch.conversionEdits.editSawMill(__instance);
					}
					else if (prefabName.Contains("piece_leatherRack_bal") && __instance.m_conversion.Count < 2)
					{
						Launch.conversionEdits.editLeatherRack(__instance);
					}
					else if (prefabName.Contains("StoneboundKiln_bal") && __instance.m_conversion.Count < 2)
					{
						Launch.conversionEdits.editStoneboundKiln(__instance);
					}
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "Awake")]
		private class Patch_CookingStation_Awake
		{
			private static void Postfix(CookingStation __instance)
			{
				if (__instance.m_conversion == null || __instance.m_conversion.Count <= 0)
				{
					string name = ((Object)__instance).name;
					if (name.Contains("piece_oven"))
					{
						Launch.conversionEdits.editOven(__instance);
					}
					else if (name.Contains("piece_cookingstation"))
					{
						Launch.conversionEdits.editCooking(__instance);
					}
					else if (name.Contains("piece_cookingstation_iron"))
					{
						Launch.conversionEdits.editIronCooking(__instance);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Fermenter), "Awake")]
		private class Patch_Fermenter_Awake
		{
			private static void Postfix(Fermenter __instance)
			{
				if (((Object)__instance).name != null && ((Object)__instance).name.Contains("fermenter"))
				{
					Launch.conversionEdits.editFermenter(__instance);
				}
			}
		}
	}
	public class DungeonNameGenList
	{
		public static string[] burialChamberTags = new string[104]
		{
			"$tag_sigurdsson_barrow_bal", "$tag_bjornsson_tomb_bal", "$tag_eiriksson_sepulcher_bal", "$tag_leifrsson_rest_bal", "$tag_ragnvald_vault_bal", "$tag_ulfgrim_mausoleum_bal", "$tag_gunnarrson_grave_bal", "$tag_hakonsen_sanctum_bal", "$tag_svendsen_hold_bal", "$tag_ivarsson_shrine_bal",
			"$tag_olafsson_keep_bal", "$tag_eriksson_chamber_bal", "$tag_magnusson_passage_bal", "$tag_lokison_memorial_bal", "$tag_vidarsson_altar_bal", "$tag_skadison_coffin_bal", "$tag_tyrsson_monument_bal", "$tag_astridsson_burial_bal", "$tag_freyason_relic_bal", "$tag_sigridsson_shroud_bal",
			"$tag_gudrunsson_abyss_bal", "$tag_ingridsson_dome_bal", "$tag_runason_circle_bal", "$tag_bodilsson_spire_bal", "$tag_svenjasson_pillar_bal", "$tag_bjarkison_barrow_bal", "$tag_einarsson_tomb_bal", "$tag_arneson_sepulcher_bal", "$tag_trygveson_rest_bal", "$tag_halvardsson_vault_bal",
			"$tag_gislison_mausoleum_bal", "$tag_ketilsson_grave_bal", "$tag_njordsson_sanctum_bal", "$tag_karisson_hold_bal", "$tag_ulfsson_shrine_bal", "$tag_ragnarsdottir_keep_bal", "$tag_sigridardottir_hall_bal", "$tag_aslaugsson_chamber_bal", "$tag_gudmundsson_passage_bal", "$tag_jarnskeggi_catacomb_bal",
			"$tag_freyjadottir_memorial_bal", "$tag_helmirsdottir_altar_bal", "$tag_thorsdottir_coffin_bal", "$tag_eiriksson_monument_bal", "$tag_hallbjornsson_crypta_bal", "$tag_svanhildr_burial_bal", "$tag_brynhildr_relic_bal", "$tag_vigdis_shroud_bal", "$tag_gunnhildr_abyss_bal", "$tag_hrolfr_dome_bal",
			"$tag_ragnheidr_circle_bal", "$tag_storr_spire_bal", "$tag_haraldsson_pillar_bal", "$tag_eilifsson_cryptic_bal", "$tag_ormsson_barrow_bal", "$tag_erlandsson_sepulcher_bal", "$tag_thorvaldsson_rest_bal", "$tag_gunnvaldsson_vault_bal", "$tag_ingvarsson_mausoleum_bal", "$tag_stigandsson_grave_bal",
			"$tag_ulfhildr_sanctum_bal", "$tag_frodehold_hold_bal", "$tag_ingibjorg_shrine_bal", "$tag_haldorsson_hall_bal", "$tag_bjornhildr_chamber_bal", "$tag_olfsson_passage_bal", "$tag_sverrirsson_catacomb_bal", "$tag_gerd_memorial_bal", "$tag_freyjaskeggi_altar_bal", "$tag_helgi_coffin_bal",
			"$tag_sigurdr_monument_bal", "$tag_hrafn_burial_bal", "$tag_sigrun_relic_bal", "$tag_egil_shroud_bal", "$tag_asgeirr_abyss_bal", "$tag_thord_dome_bal", "$tag_valdis_circle_bal", "$tag_jarl_spire_bal", "$tag_ketill_pillar_bal", "$tag_ulf_cryptic_bal",
			"$tag_einar_barrow_bal", "$tag_rune_crypt_bal", "$tag_olv_tomb_bal", "$tag_arin_sepulcher_bal", "$tag_sten_rest_bal", "$tag_olrik_vault_bal", "$tag_ulfgeirr_mausoleum_bal", "$tag_thorgrim_grave_bal", "$tag_bjornwulf_sanctum_bal", "$tag_ingrid_hold_bal",
			"$tag_jon_shrine_bal", "$tag_helga_keep_bal", "$tag_valdimar_hall_bal", "$tag_karlsdottir_chamber_bal", "$tag_eiriksson_passage_bal", "$tag_gudrun_memorial_bal", "$tag_hagen_tomb_bal", "$tag_jorund_burial_bal", "$tag_kelda_mausoleum_bal", "$tag_loki_spire_bal",
			"$tag_asger_dome_bal", "$tag_eran_altar_bal", "$tag_runa_barrow_bal", "$tag_torvald_keep_bal"
		};

		public static readonly Dictionary<string, string[]> dungeonNameList = new Dictionary<string, string[]>
		{
			{
				"WoodFarm1",
				new string[20]
				{
					"$tag_fjellholt_bal", "$tag_birkheim_bal", "$tag_thorslund_bal", "$tag_eikstad_bal", "$tag_hogdale_bal", "$tag_grovra_bal", "$tag_vangr_bal", "$tag_sjoholt_bal", "$tag_vaestgard_bal", "$tag_rodhaug_bal",
					"$tag_myrheim_bal", "$tag_skogtun_bal", "$tag_havnby_bal", "$tag_rostvik_bal", "$tag_skjoldrud_bal", "$tag_dalenes_bal", "$tag_bjornholt_bal", "$tag_breidvoll_bal", "$tag_kveldrud_bal", "$tag_strandheim_bal"
				}
			},
			{
				"WoodVillage1",
				new string[20]
				{
					"$tag_draugrholt_bal", "$tag_skulldal_bal", "$tag_nattvik_bal", "$tag_morkheim_bal", "$tag_gravfjell_bal", "$tag_svartdal_bal", "$tag_vargstad_bal", "$tag_haellvik_bal", "$tag_dokkhus_bal", "$tag_frostheim_bal",
					"$tag_skuggaborg_bal", "$tag_kuldeholt_bal", "$tag_dokkalund_bal", "$tag_blodheim_bal", "$tag_trollhaugen_bal", "$tag_kaosvik_bal", "$tag_spokestad_bal", "$tag_demonfjord_bal", "$tag_gjallardal_bal", "$tag_niflungstad_bal"
				}
			},
			{
				"GoblinCamp2",
				new string[20]
				{
					"$tag_skarrfang_bal", "$tag_drakthar_bal", "$tag_gorakmar_bal", "$tag_bloodgrot_bal", "$tag_kragtooth_bal", "$tag_narzug_bal", "$tag_razgrin_bal", "$tag_venomclaw_bal", "$tag_darkmire_bal", "$tag_skulkrag_bal",
					"$tag_ghulraz_bal", "$tag_fangrim_bal", "$tag_ravenskull_bal", "$tag_wargfell_bal", "$tag_ironfang_bal", "$tag_doomscar_bal", "$tag_bonegrin_bal", "$tag_morglash_bal", "$tag_ragefen_bal", "$tag_snarltusk_bal"
				}
			},
			{
				"MountainCave02",
				new string[23]
				{
					"$tag_arnulfsson_keep_bal", "$tag_frostvein_bal", "$tag_icecrypt_bal", "$tag_glacierhold_bal", "$tag_winterfang_bal", "$tag_cryoshroud_bal", "$tag_snowmire_bal", "$tag_shardfell_bal", "$tag_chillspire_bal", "$tag_thorvaldsson_hall_bal",
					"$tag_permafrost_bal", "$tag_fenringscar_bal", "$tag_icevein_bal", "$tag_frostbane_bal", "$tag_glacialrift_bal", "$tag_hailreach_bal", "$tag_blizzardhall_bal", "$tag_shiverpeak_bal", "$tag_fenringcrypt_bal", "$tag_sleetgarde_bal",
					"$tag_icebound_bal", "$tag_frozenfang_bal", "$tag_ullr_hall_bal"
				}
			},
			{ "Crypt2", burialChamberTags },
			{ "Crypt3", burialChamberTags },
			{ "Crypt4", burialChamberTags },
			{
				"SunkenCrypt4",
				new string[47]
				{
					"$tag_borg_catacomb_bal", "$tag_drownedhall_bal", "$tag_shademire_bal", "$tag_ghostreef_bal", "$tag_bonewater_bal", "$tag_haraldsson_crypt_bal", "$tag_fathomkeep_bal", "$tag_dreadspire_bal", "$tag_siltgrave_bal", "$tag_wraithhold_bal",
					"$tag_deepshade_bal", "$tag_sigfridsson_crypt_bal", "$tag_bloodmarsh_bal", "$tag_phantomrest_bal", "$tag_tidewrath_bal", "$tag_skullgrove_bal", "$tag_mirelair_bal", "$tag_shadowfen_bal", "$tag_floodspire_bal", "$tag_cryptreach_bal",
					"$tag_fenrirsson_catacomb_bal", "$tag_echograve_bal", "$tag_mistmarsh_bal", "$tag_hollowreef_bal", "$tag_carrionhold_bal", "$tag_torsteinsson_cryptic_bal", "$tag_helgason_crypta_bal", "$tag_gravehollow_bal", "$tag_phasespire_bal", "$tag_sunkenfrost_bal",
					"$tag_blightharbor_bal", "$tag_frostmire_bal", "$tag_hakonsson_crypt_bal", "$tag_seaspire_bal", "$tag_deathfen_bal", "$tag_nightshroud_bal", "$tag_spinecrypt_bal", "$tag_darkwater_bal", "$tag_grimgulf_bal", "$tag_shadowmarsh_bal",
					"$tag_cryptfall_bal", "$tag_fogmoor_bal", "$tag_blightreef_bal", "$tag_harrowdeep_bal", "$tag_deepwraith_bal", "$tag_ashenreef_bal", "$tag_styrbjornsson_crypta_bal"
				}
			}
		};
	}
	[HarmonyPatch]
	internal static class WorldGenPatches
	{
		[HarmonyPatch(typeof(ZoneSystem), "SetupLocations")]
		private class ZoneSystem_SetupLocations
		{
			private static void Prefix(ZoneSystem __instance)
			{
				ChangeSurtlingSpawner(__instance);
				Debug.Log((object)string.Format("{0} Loaded Vegetation: {1}", "BalrondPapayonPack", VegetationBuilder.ZoneVegetations.Count));
				List<ZoneVegetation> vegetation = __instance.m_vegetation;
				foreach (ZoneVegetation veg in VegetationBuilder.ZoneVegetations)
				{
					if (!vegetation.Exists((ZoneVegetation x) => x.m_name == veg.m_name && x.m_biome == veg.m_biome))
					{
						vegetation.Add(veg);
					}
				}
				vegetation.RemoveAll((ZoneVegetation x) => (Object)(object)x.m_prefab == (Object)null);
				__instance.m_locations.AddRange(LocationBuilder.zoneLocations);
				Object.DestroyImmediate((Object)(object)__instance.m_locationProxyPrefab.GetComponent<LocationProxy>());
				__instance.m_locationProxyPrefab.AddComponent<LocationProxy>();
			}

			private static void Postfix(ZoneSystem __instance)
			{
				Launch.locationBuilder.editLocations(__instance.m_locations);
				Launch.vegetationBuilder.editVege(__instance.m_vegetation);
				__instance.m_vegetation.RemoveAll((ZoneVegetation x) => (Object)(object)x.m_prefab == (Object)null);
			}

			private static void ChangeSurtlingSpawner(ZoneSystem __instance)
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				__instance.m_locations.RemoveAll((ZoneLocation x) => x.m_prefabName == "Meteorite");
				ZoneLocation val = __instance.m_locations.Find((ZoneLocation x) => x.m_prefabName == "FireHole");
				if (val != null)
				{
					val.m_biome = (Biome)32;
					val.m_quantity *= 2;
				}
			}
		}

		public static float timer = 500f;

		public static float counter = 1000f;

		public static bool removeTag = false;
	}
	public class CommonItemReferences
	{
		public static GameObject wood;

		public static GameObject fineWood;

		public static GameObject stone;

		public static GameObject flint;

		public static GameObject iron;

		public static GameObject copper;

		public static GameObject coal;

		public static GameObject leatherScraps;
	}
	public class RecipeEdits
	{
		private List<GameObject> items;

		private List<GameObject> buildPieces;

		private readonly Dictionary<string, GameObject> _itemCache = new Dictionary<string, GameObject>();

		private GameObject FindItem(List<GameObject> list, string name)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
			if ((Object)(object)itemPrefab != (Object)null)
			{
				return itemPrefab;
			}
			return FindInDatabase("Wood");
		}

		private GameObject FindItem(string name)
		{
			if (_itemCache.TryGetValue(name, out var value))
			{
				return value;
			}
			GameObject val = FindInDatabase(name);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)(Launch.projectName + ": Item Not Found - " + name + ", Replaced With Wood"));
				val = FindInDatabase("Wood");
			}
			if ((Object)(object)val != (Object)null)
			{
				_itemCache[name] = val;
			}
			return val;
		}

		private GameObject FindInDatabase(string name)
		{
			return ObjectDB.instance.GetItemPrefab(name);
		}

		public void editRecipes(List<Recipe> recipes, List<GameObject> list)
		{
			if (recipes == null || recipes.Count == 0)
			{
				Debug.LogWarning((object)"There are no recipes!");
				return;
			}
			if (list == null || list.Count == 0)
			{
				Debug.LogWarning((object)"There are no items!");
				return;
			}
			items = list;
			buildPieces = ObjectDB.instance.GetItemPrefab("Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
			TableMapper.setupTables(null, buildPieces);
			foreach (Recipe recipe in recipes)
			{
				if (!((Object)(object)recipe.m_item == (Object)null))
				{
					CheckRecipe(recipe);
				}
			}
		}

		private void CheckRecipe(Recipe recipe)
		{
			List<Requirement> list = new List<Requirement>();
			switch (((Object)((Component)recipe.m_item).gameObject).name)
			{
			case "HelmetBerserkerHood":
				recipe.m_amount = 1;
				list.Add(createReq("BjornHide", 4, 2));
				list.Add(createReq("TrophyBjorn", 1, 0));
				list.Add(createReq("StrawThread_bal", 4, 2));
				list.Add(createReq("BoneFragments", 10, 5));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorBerserkerChest":
				recipe.m_amount = 1;
				list.Add(createReq("BjornHide", 6, 3));
				list.Add(createReq("Blueberries", 6, 3));
				list.Add(createReq("StrawThread_bal", 10, 5));
				list.Add(createReq("BjornPaw", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorBerserkerLegs":
				recipe.m_amount = 1;
				list.Add(createReq("BjornHide", 4, 2));
				list.Add(createReq("Blueberries", 6, 3));
				list.Add(createReq("StrawThread_bal", 6, 2));
				list.Add(createReq("LeatherScraps", 8, 4));
				recipe.m_resources = list.ToArray();
				break;
			case "Bronze":
				if (((Object)recipe).name == "Recipe_Bronze")
				{
					recipe.m_amount = 2;
					list.Add(createReq("Tin", 1, 0));
					list.Add(createReq("Copper", 2, 0));
					list.Add(createReq("Coal", 2, 0));
					recipe.m_resources = list.ToArray();
				}
				if (((Object)recipe).name == "Recipe_Bronze5")
				{
					recipe.m_amount = 10;
					list.Add(createReq("Tin", 4, 0));
					list.Add(createReq("Copper", 9, 0));
					list.Add(createReq("Coal", 7, 0));
					recipe.m_resources = list.ToArray();
				}
				break;
			case "ShocklateSmoothie":
				recipe.m_amount = 2;
				list.Add(createReq("Ooze", 3, 0));
				list.Add(createReq("WaterJug_bal", 1, 0));
				list.Add(createReq("Raspberry", 3, 0));
				list.Add(createReq("Blueberries", 3, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "ScorchingMedley":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.grill;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 3;
				recipe.m_amount = 3;
				list.Add(createReq("MushroomJotunPuffs", 3, 0));
				list.Add(createReq("SpiceSet_bal", 1, 0));
				list.Add(createReq("Fiddleheadfern", 3, 0));
				list.Add(createReq("Ignicap_bal", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MashedMeat":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.grill;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 3;
				recipe.m_amount = 2;
				list.Add(createReq("AsksvinMeat", 2, 0));
				list.Add(createReq("VoltureMeat", 1, 0));
				list.Add(createReq("Fiddleheadfern", 2, 0));
				list.Add(createReq("MeatScrap_bal", 5, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "WolfMeatSkewer":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.grill;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				recipe.m_amount = 2;
				list.Add(createReq("WolfMeat", 2, 0));
				list.Add(createReq("Mushroom", 5, 0));
				list.Add(createReq("Onion", 3, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "Wolfjerky":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.grill;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				recipe.m_amount = 2;
				list.Add(createReq("WolfMeat", 1, 0));
				list.Add(createReq("Honey", 1, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "Sausages":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.grill;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				recipe.m_amount = 3;
				list.Add(createReq("Entrails", 4, 0));
				list.Add(createReq("RawMeat", 1, 0));
				list.Add(createReq("Thistle", 1, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "SizzlingBerryBroth":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 5;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Sap", 4, 0));
				list.Add(createReq("Fiddleheadfern", 3, 0));
				list.Add(createReq("Vineberry", 3, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "CarrotSoup":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Carrot", 4, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "TurnipStew":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 2;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Turnip", 5, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "BlackSoup":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 2;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Bloodbag", 1, 0));
				list.Add(createReq("Honey", 1, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "FierySvinstew":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 5;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Vineberry", 3, 0));
				list.Add(createReq("AsksvinMeat", 1, 0));
				list.Add(createReq("MushroomSmokePuff", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "OnionSoup":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 2;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Onion", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "SerpentStew":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.cauldron;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				recipe.m_amount = 2;
				list.Add(createReq("Bulion_bal", 1, 0));
				list.Add(createReq("Honey", 2, 0));
				list.Add(createReq("Mushroom", 3, 0));
				list.Add(createReq("SerpentMeatCooked", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "Feaster":
				recipe.m_enabled = true;
				recipe.m_craftingStation = TableMapper.forge;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				list.Add(createReq("Tin", 6, 0));
				list.Add(createReq("ClayPot_bal", 2, 0));
				list.Add(createReq("CarvedWood_bal", 6, 0));
				list.Add(createReq("WaterJug_bal", 1, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "SwordNiedhogg":
			case "SwordNiedhoggBlood":
			case "SwordNiedhoggLightning":
			case "SwordNiedhoggNature":
			case "SwordDyrnwyn":
			case "THSwordSlayer":
			case "THSwordSlayerBlood":
			case "THSwordSlayerLightning":
			case "THSwordSlayerNature":
			case "AxeBerzerkr":
			case "AxeBerzerkrBlood":
			case "AxeBerzerkrLightning":
			case "AxeBerzerkrNature":
			case "MaceEldner":
			case "MaceEldnerBlood":
			case "MaceEldnerLightning":
			case "MaceEldnerNature":
			case "CrossbowRipper":
			case "CrossbowRipperBlood":
			case "CrossbowRipperLightning":
			case "CrossbowRipperNature":
			case "BowAshlands":
			case "BowAshlandsBlood":
			case "BowAshlandsRoot":
			case "BowAshlandsStorm":
			case "ShieldFlametal":
			case "ShieldFlametalTower":
				recipe.m_craftingStation = TableMapper.blackforge;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				break;
			case "ArmorRootChest":
				list.Add(createReq("Root", 10, 5));
				list.Add(createReq("ElderBark", 16, 8));
				list.Add(createReq("DeerHide", 4, 2));
				list.Add(createReq("NeckSkin_bal", 6, 3));
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				break;
			case "ArmorRootLegs":
				list.Add(createReq("Root", 8, 4));
				list.Add(createReq("ElderBark", 12, 6));
				list.Add(createReq("BoarHide_bal", 4, 2));
				list.Add(createReq("NeckSkin_bal", 4, 2));
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				break;
			case "HelmetRoot":
				list.Add(createReq("Root", 6, 3));
				list.Add(createReq("ElderBark", 12, 6));
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("NeckSkin_bal", 2, 1));
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				break;
			case "Lantern":
				list.Add(createReq("BellMetal_bal", 2, 1));
				list.Add(createReq("SurtlingCore", 1, 0));
				list.Add(createReq("Crystal", 1, 0));
				list.Add(createReq("HardWood_bal", 2, 1));
				recipe.m_craftingStation = TableMapper.ironworks;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 3;
				recipe.m_resources = list.ToArray();
				break;
			case "CeramicPlate":
				recipe.m_enabled = false;
				break;
			case "StaffSkeleton":
				list.Add(createReq("TrophySkeletonPoison", 1, 1));
				list.Add(createReq("CursedBone_bal", 4, 2));
				list.Add(createReq("CorruptedEitr_bal", 8, 4));
				list.Add(createReq("Ruby", 3, 1));
				recipe.m_craftingStation = TableMapper.shamantable;
				recipe.m_repairStation = recipe.m_craftingStation;
				recipe.m_minStationLevel = 1;
				recipe.m_resources = list.ToArray();
				break;
			case "FishWraps":
				recipe.m_enabled = false;
				break;
			case "THSwordKrom":
				list.Add(createReq("HardWood_bal", 2, 1));
				list.Add(createReq("ScaleHide", 4, 2));
				list.Add(createReq("BellMetal_bal", 8, 4));
				list.Add(createReq("DarkSteel_bal", 20, 10));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "SwordMistwalker":
				list.Add(createReq("YggdrasilWood", 4, 2));
				list.Add(createReq("Eitr", 8, 4));
				list.Add(createReq("Wisp", 4, 2));
				list.Add(createReq("DarkSteel_bal", 10, 5));
				recipe.m_resources = list.ToArray();
				break;
			case "SwordSilver":
				list.Add(createReq("HardWood_bal", 4, 2));
				list.Add(createReq("LeatherScraps", 8, 4));
				list.Add(createReq("DarkSteel_bal", 4, 2));
				list.Add(createReq("Silver", 30, 15));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "AxeJotunBane":
				list.Add(createReq("YggdrasilWood", 4, 2));
				list.Add(createReq("Bilebag", 4, 2));
				list.Add(createReq("Eitr", 10, 2));
				list.Add(createReq("DarkSteel_bal", 10, 5));
				recipe.m_resources = list.ToArray();
				break;
			case "KnifeSkollAndHati":
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("FineWood", 6, 3));
				list.Add(createReq("BellMetal_bal", 10, 5));
				list.Add(createReq("StrawThread_bal", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "PickaxeStone":
				recipe.m_enabled = true;
				recipe.m_minStationLevel = 2;
				list.Add(createReq("Wood", 6, 2));
				list.Add(createReq("LeatherScraps", 6, 2));
				list.Add(createReq("Flint", 10, 5));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorMageLegs":
				list.Add(createReq("Eitr", 20, 10));
				list.Add(createReq("LinenThread", 12, 6));
				list.Add(createReq("JuteRed", 2, 1));
				list.Add(createReq("FreezeGland", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorMageChest":
				list.Add(createReq("Eitr", 20, 10));
				list.Add(createReq("LinenThread", 12, 6));
				list.Add(createReq("Feathers", 4, 2));
				list.Add(createReq("ScaleHide", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "StaffIceShards":
				list.Add(createReq("YggdrasilWood", 20, 10));
				list.Add(createReq("Eitr", 12, 6));
				list.Add(createReq("Crystal", 4, 2));
				list.Add(createReq("FreezeGland", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "StaffShield":
				list.Add(createReq("YggdrasilWood", 20, 10));
				list.Add(createReq("Eitr", 12, 6));
				list.Add(createReq("GiantBloodSack", 4, 2));
				list.Add(createReq("Bloodbag", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "StaffFireball":
				list.Add(createReq("YggdrasilWood", 20, 10));
				list.Add(createReq("Eitr", 12, 6));
				list.Add(createReq("SurtlingCore", 4, 2));
				list.Add(createReq("Resin", 20, 10));
				recipe.m_resources = list.ToArray();
				break;
			case "QueensJam":
				list.Add(createReq("Honey", 1, 0));
				list.Add(createReq("ClayPot_bal", 1, 0));
				list.Add(createReq("Raspberry", 2, 0));
				list.Add(createReq("Blueberries", 2, 0));
				recipe.m_amount = 1;
				recipe.m_resources = list.ToArray();
				break;
			case "LoxPieUncooked":
				list.Add(createReq("BarleyFlour", 4, 0));
				list.Add(createReq("Thistle", 2, 0));
				list.Add(createReq("Dandelion", 2, 0));
				list.Add(createReq("LoxMeat", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseEitrMinor":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("Sap", 4, 0));
				list.Add(createReq("MushroomJotunPuffs", 3, 0));
				list.Add(createReq("MushroomMagecap", 5, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseFrostResist":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("Thistle", 4, 0));
				list.Add(createReq("Bloodbag", 2, 0));
				list.Add(createReq("GreydwarfEye", 3, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseHealthMajor":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("Sap", 4, 0));
				list.Add(createReq("GiantBloodSack", 4, 0));
				list.Add(createReq("RoyalJelly", 5, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseHealthMedium":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("Bloodbag", 5, 0));
				list.Add(createReq("Blackberries_bal", 10, 0));
				list.Add(createReq("Thistle", 3, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseHealthMinor":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("Thistle", 3, 0));
				list.Add(createReq("Apple_bal", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBasePoisonResist":
				list.Add(createReq("TrophySkeleton", 2, 0));
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("Coal", 8, 0));
				list.Add(createReq("NeckTail", 3, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseStaminaLingering":
				list.Add(createReq("Sap", 6, 0));
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("MushroomJotunPuffs", 8, 0));
				list.Add(createReq("Cloudberry", 12, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseStaminaMedium":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("MushroomYellow", 8, 0));
				list.Add(createReq("Cloudberry", 12, 0));
				list.Add(createReq("Darkbul_bal", 6, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "MeadBaseStaminaMinor":
				list.Add(createReq("MeadBase_bal", 1, 0));
				list.Add(createReq("MushroomYellow", 6, 0));
				list.Add(createReq("Blackberries_bal", 4, 0));
				list.Add(createReq("Straw_bal", 10, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "Hammer":
				list.Add(createReq("Wood", 4, 1));
				list.Add(createReq("Flint", 0, 1));
				list.Add(createReq("LeatherScraps", 0, 1));
				list.Add(createReq("Stone", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "Hoe":
				list.Add(createReq("Wood", 6, 0));
				list.Add(createReq("Flint", 0, 1));
				list.Add(createReq("LeatherScraps", 0, 2));
				list.Add(createReq("Stone", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "HelmetFenring":
				list.Add(createReq("WolfHairBundle", 18, 6));
				list.Add(createReq("WolfPelt", 3, 4));
				list.Add(createReq("TrophyCultist", 1, 0));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "ArmorFenringChest":
			case "ArmorFenringLegs":
				list.Add(createReq("WolfHairBundle", 18, 6));
				list.Add(createReq("WolfPelt", 6, 4));
				list.Add(createReq("BoarHide_bal", 6, 2));
				list.Add(createReq("StrawThread_bal", 8, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "AtgeirBronze":
				list.Add(createReq("Bronze", 8, 4));
				list.Add(createReq("Wood", 12, 3));
				list.Add(createReq("LeatherScraps", 6, 2));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "AtgeirIron":
				list.Add(createReq("Iron", 28, 12));
				list.Add(createReq("HardWood_bal", 5, 2));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("StrawThread_bal", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "AtgeirBlackmetal":
				list.Add(createReq("BlackMetal", 28, 12));
				list.Add(createReq("HardWood_bal", 8, 4));
				list.Add(createReq("LeatherScraps", 10, 4));
				list.Add(createReq("LinenThread", 6, 4));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "ArmorWolfLegs":
				list.Add(createReq("Silver", 16, 8));
				list.Add(createReq("WolfPelt", 6, 3));
				list.Add(createReq("WolfFang", 6, 0));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "ArmorWolfChest":
				list.Add(createReq("Silver", 18, 9));
				list.Add(createReq("WolfPelt", 4, 2));
				list.Add(createReq("LeatherScraps", 8, 4));
				list.Add(createReq("Chain", 2, 0));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "PickaxeBronze":
				list.Add(createReq("RoundLog", 4, 2));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("Bronze", 10, 5));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "MaceBronze":
				list.Add(createReq("RoundLog", 2, 1));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("Bronze", 8, 4));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "MaceIron":
				list.Add(createReq("FineWood", 4, 2));
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("Iron", 18, 9));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "MaceNeedle":
				list.Add(createReq("FineWood", 6, 3));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("Needle", 4, 2));
				list.Add(createReq("JuteRed", 2, 1));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "MaceSilver":
				list.Add(createReq("ElderBark", 20, 10));
				list.Add(createReq("Silver", 24, 12));
				list.Add(createReq("FreezeGland", 6, 3));
				list.Add(createReq("YmirRemains", 6, 0));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "KnifeButcher":
				list.Add(createReq("Tin", 4, 0));
				list.Add(createReq("FineWood", 4, 2));
				list.Add(createReq("LeatherScraps", 2, 0));
				list.Add(createReq("StrawThread_bal", 2, 0));
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_resources = list.ToArray();
				break;
			case "KnifeChitin":
				list.Add(createReq("Chitin", 20, 10));
				list.Add(createReq("FineWood", 4, 2));
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("StrawThread_bal", 2, 1));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				break;
			case "PickaxeIron":
				list.Add(createReq("StrawThread_bal", 4, 2));
				list.Add(createReq("HardWood_bal", 4, 2));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("Iron", 18, 9));
				recipe.m_resources = list.ToArray();
				break;
			case "PickaxeBlackMetal":
				list.Add(createReq("LinenThread", 4, 2));
				list.Add(createReq("HardWood_bal", 8, 4));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("BlackMetal", 22, 11));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "AxeIron":
				list.Add(createReq("RoundLog", 4, 2));
				list.Add(createReq("BoarHide_bal", 1, 0));
				list.Add(createReq("LeatherScraps", 2, 1));
				list.Add(createReq("Iron", 18, 10));
				recipe.m_resources = list.ToArray();
				break;
			case "AxeBlackMetal":
				list.Add(createReq("HardWood_bal", 4, 2));
				list.Add(createReq("JuteRed", 2, 1));
				list.Add(createReq("LinenThread", 4, 2));
				list.Add(createReq("BlackMetal", 16, 8));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "SwordIron":
				list.Add(createReq("HardWood_bal", 3, 1));
				list.Add(createReq("BoarHide_bal", 1, 0));
				list.Add(createReq("LeatherScraps", 2, 1));
				list.Add(createReq("Iron", 18, 10));
				recipe.m_resources = list.ToArray();
				break;
			case "SwordBronze":
				list.Add(createReq("Wood", 4, 2));
				list.Add(createReq("StrawThread_bal", 2, 1));
				list.Add(createReq("LeatherScraps", 2, 1));
				list.Add(createReq("Bronze", 8, 4));
				recipe.m_resources = list.ToArray();
				break;
			case "SwordBlackmetal":
				list.Add(createReq("HardWood_bal", 4, 2));
				list.Add(createReq("JuteRed", 2, 1));
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("BlackMetal", 20, 10));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "AxeBronze":
				list.Add(createReq("RoundLog", 4, 2));
				list.Add(createReq("BoarHide_bal", 1, 0));
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("Bronze", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "AxeFlint":
				list.Add(createReq("Wood", 4, 2));
				list.Add(createReq("BoarHide_bal", 1, 0));
				list.Add(createReq("LeatherScraps", 2, 1));
				list.Add(createReq("Flint", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "HelmetPadded":
				list.Add(createReq("LeatherScraps", 10, 5));
				list.Add(createReq("LinenThread", 12, 6));
				list.Add(createReq("BlackMetal", 6, 3));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "ArmorPaddedCuirass":
				list.Add(createReq("LoxPelt", 4, 2));
				list.Add(createReq("LinenThread", 14, 7));
				list.Add(createReq("BlackMetal", 6, 3));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "ArmorPaddedGreaves":
				list.Add(createReq("BoarHide_bal", 6, 3));
				list.Add(createReq("LinenThread", 20, 10));
				list.Add(createReq("BlackMetal", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "HelmetIron":
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("Iron", 14, 7));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorIronChest":
				list.Add(createReq("TrollHide", 4, 2));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("Iron", 18, 9));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorIronLegs":
				list.Add(createReq("TrollHide", 6, 3));
				list.Add(createReq("LeatherScraps", 8, 4));
				list.Add(createReq("Iron", 16, 8));
				recipe.m_resources = list.ToArray();
				break;
			case "HelmetBronze":
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("StrawThread_bal", 4, 2));
				list.Add(createReq("Bronze", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorBronzeChest":
				list.Add(createReq("DeerHide", 2, 1));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("Bronze", 8, 4));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorBronzeLegs":
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("DeerHide", 2, 1));
				list.Add(createReq("Bronze", 6, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "HelmetTrollLeather":
				list.Add(createReq("StrawThread_bal", 2, 1));
				list.Add(createReq("TrollHide", 4, 2));
				list.Add(createReq("BoneFragments", 4, 2));
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_repairStation = TableMapper.heavyWorkbench;
				break;
			case "CapeTrollHide":
				recipe.m_minStationLevel = 1;
				list.Add(createReq("StrawThread_bal", 4, 2));
				list.Add(createReq("TrollHide", 8, 4));
				list.Add(createReq("BoneFragments", 4, 2));
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_repairStation = TableMapper.heavyWorkbench;
				break;
			case "ArmorTrollLeatherChest":
			case "ArmorTrollLeatherLegs":
				list.Add(createReq("BoneFragments", 3, 2));
				list.Add(createReq("TrollHide", 4, 3));
				list.Add(createReq("StrawThread_bal", 3, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				recipe.m_repairStation = TableMapper.heavyWorkbench;
				break;
			case "CapeDeer":
				recipe.m_minStationLevel = 1;
				list.Add(createReq("DeerHide", 4, 3));
				list.Add(createReq("StrawThread_bal", 3, 2));
				list.Add(createReq("LeatherScraps", 5, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_repairStation = TableMapper.heavyWorkbench;
				break;
			case "ArmorLeatherChest":
				list.Add(createReq("DeerHide", 4, 3));
				list.Add(createReq("StrawThread_bal", 3, 2));
				list.Add(createReq("LeatherScraps", 5, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorLeatherLegs":
				list.Add(createReq("DeerHide", 3, 2));
				list.Add(createReq("StrawThread_bal", 5, 4));
				list.Add(createReq("LeatherScraps", 7, 3));
				recipe.m_resources = list.ToArray();
				break;
			case "SpearChitin":
				list.Add(createReq("FineWood", 16, 8));
				list.Add(createReq("BoarHide_bal", 4, 2));
				list.Add(createReq("Chitin", 24, 12));
				list.Add(createReq("Resin", 8, 4));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				break;
			case "SpearBronze":
				list.Add(createReq("RoundLog", 4, 2));
				list.Add(createReq("DeerHide", 2, 1));
				list.Add(createReq("Bronze", 6, 3));
				list.Add(createReq("Resin", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "SpearCarapace":
				list.Add(createReq("YggdrasilWood", 8, 4));
				list.Add(createReq("Carapace", 6, 3));
				list.Add(createReq("Mandible", 2, 1));
				list.Add(createReq("JuteRed", 2, 1));
				recipe.m_resources = list.ToArray();
				break;
			case "SpearElderbark":
				list.Add(createReq("ElderBark", 12, 6));
				list.Add(createReq("TrollHide", 4, 2));
				list.Add(createReq("Iron", 10, 5));
				list.Add(createReq("Root", 1, 0));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.forge;
				break;
			case "SpearFlint":
				list.Add(createReq("Wood", 6, 3));
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("Flint", 10, 5));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.workbench;
				break;
			case "ShieldWood":
				list.Add(createReq("Wood", 12, 6));
				list.Add(createReq("BoarHide_bal", 1, 0));
				list.Add(createReq("Resin", 4, 2));
				list.Add(createReq("LeatherScraps", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.workbench;
				break;
			case "ShieldWoodTower":
				list.Add(createReq("Wood", 14, 6));
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("Resin", 8, 0));
				list.Add(createReq("LeatherScraps", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.workbench;
				break;
			case "SaddleLox":
				list.Add(createReq("LinenThread", 22, 0));
				list.Add(createReq("BlackMetal", 14, 0));
				list.Add(createReq("BoarHide_bal", 5, 0));
				list.Add(createReq("Resin", 6, 0));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.workbench;
				break;
			case "KnifeSilver":
				list.Add(createReq("Silver", 10, 5));
				list.Add(createReq("ElderBark", 8, 4));
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("Resin", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "KnifeCopper":
				list.Add(createReq("Copper", 10, 5));
				list.Add(createReq("Wood", 4, 2));
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("GreydwarfEye", 8, 4));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				break;
			case "BombOoze":
				list.Add(createReq("Ooze", 5, 0));
				list.Add(createReq("Resin", 5, 0));
				list.Add(createReq("BoarHide_bal", 2, 0));
				recipe.m_resources = list.ToArray();
				break;
			case "Bow":
				list.Add(createReq("Wood", 10, 5));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("BoarHide_bal", 2, 1));
				list.Add(createReq("StrawThread_bal", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.workbench;
				break;
			case "CrossbowArbalest":
				list.Add(createReq("StrawThread_bal", 10, 5));
				list.Add(createReq("DarkSteel_bal", 12, 6));
				list.Add(createReq("HardWood_bal", 14, 7));
				list.Add(createReq("Root", 10, 5));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.fletcher;
				break;
			case "BowSpineSnap":
				list.Add(createReq("Eitr", 10, 5));
				list.Add(createReq("BoneFragments", 30, 15));
				list.Add(createReq("YggdrasilWood", 4, 2));
				list.Add(createReq("LinenThread", 8, 4));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.fletcher;
				break;
			case "BowHuntsman":
				list.Add(createReq("Feathers", 12, 6));
				list.Add(createReq("DeerHide", 4, 2));
				list.Add(createReq("HardWood_bal", 6, 3));
				list.Add(createReq("Iron", 18, 9));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.fletcher;
				break;
			case "BowFineWood":
				list.Add(createReq("FineWood", 16, 8));
				list.Add(createReq("Bronze", 6, 3));
				list.Add(createReq("BoarHide_bal", 6, 3));
				list.Add(createReq("StrawThread_bal", 10, 5));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.fletcher;
				break;
			case "BowDraugrFang":
				list.Add(createReq("ElderBark", 16, 8));
				list.Add(createReq("Silver", 18, 9));
				list.Add(createReq("WolfPelt", 4, 2));
				list.Add(createReq("Guck", 8, 4));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.fletcher;
				break;
			case "Battleaxe":
				list.Add(createReq("ElderBark", 20, 10));
				list.Add(createReq("Iron", 30, 15));
				list.Add(createReq("BoarHide_bal", 4, 2));
				list.Add(createReq("FineWood", 4, 2));
				recipe.m_resources = list.ToArray();
				break;
			case "BattleaxeCrystal":
				list.Add(createReq("ElderBark", 30, 15));
				list.Add(createReq("Silver", 30, 15));
				list.Add(createReq("Crystal", 10, 5));
				list.Add(createReq("JuteRed", 4, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.ironworks;
				break;
			case "SledgeStagbreaker":
				list.Add(createReq("TrophyDeer", 2, 1));
				list.Add(createReq("RoundLog", 6, 3));
				list.Add(createReq("LeatherScraps", 6, 3));
				list.Add(createReq("BoarHide_bal", 3, 2));
				recipe.m_resources = list.ToArray();
				recipe.m_craftingStation = TableMapper.heavyWorkbench;
				break;
			case "ArmorRagsChest":
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("BoarHide_bal", 2, 1));
				recipe.m_resources = list.ToArray();
				break;
			case "ArmorRagsLegs":
				list.Add(createReq("LeatherScraps", 4, 2));
				list.Add(createReq("BoarHide_bal", 2, 1));
				recipe.m_resources = list.ToArray();
				break;
			}
		}

		private Requirement createReq(string name, int amount, int amountPerLevel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Requirement val = new Requirement();
			val.m_recover = true;
			ItemDrop component = FindItem(name).GetComponent<ItemDrop>();
			val.m_resItem = component;
			val.m_amount = amount;
			val.m_amountPerLevel = amountPerLevel;
			return val;
		}
	}
	public class TableMapper
	{
		public static CraftingStation cauldron;

		public static CraftingStation workbench;

		public static CraftingStation heavyWorkbench;

		public static CraftingStation forge;

		public static CraftingStation ironworks;

		public static CraftingStation blackforge;

		public static CraftingStation stoneCutter;

		public static CraftingStation artisian;

		public static CraftingStation magetable;

		public static CraftingStation runeforge;

		public static CraftingStation tannery;

		public static CraftingStation fletcher;

		public static CraftingStation grill;

		public static CraftingStation alchemylab;

		public static CraftingStation shamantable;

		public static CraftingStation foodtable;

		public static CraftingStation smeltworks;

		public static ZNetScene zNetScene;

		public static List<GameObject> list = new List<GameObject>();

		public static void setupTables(ZNetScene zNetScene = null, List<GameObject> list = null)
		{
			TableMapper.zNetScene = zNetScene;
			TableMapper.list = list;
			prepareTables();
		}

		private static GameObject FindPrefabInZnet(string name, ZNetScene zNetScene)
		{
			GameObject value = null;
			zNetScene.m_namedPrefabs.TryGetValue(BalrondHashCompat.StableHash(name), out value);
			if ((Object)(object)value == (Object)null)
			{
				value = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
			}
			return value;
		}

		private static CraftingStation FindStation(string name)
		{
			GameObject val = null;
			val = (GameObject)((!((Object)(object)zNetScene != (Object)null)) ? ((object)list.Find((GameObject x) => ((Object)x).name == name)) : ((object)FindPrefabInZnet(name, zNetScene)));
			if ((Object)(object)val != (Object)null)
			{
				return val.GetComponent<CraftingStation>();
			}
			return null;
		}

		private static void prepareTables()
		{
			cauldron = FindStation("piece_cauldron");
			workbench = FindStation("piece_workbench");
			heavyWorkbench = FindStation("piece_heavy_workbench_bal");
			forge = FindStation("forge");
			ironworks = FindStation("piece_metalworks_bal");
			blackforge = FindStation("blackforge");
			stoneCutter = FindStation("piece_stonecutter");
			artisian = FindStation("piece_artisanstation");
			runeforge = FindStation("piece_runeforge_bal");
			magetable = FindStation("piece_magetable");
			fletcher = FindStation("piece_fletcher_bal");
			shamantable = FindStation("piece_shamantable_bal");
			foodtable = FindStation("piece_preptable");
			grill = FindStation("piece_grill_bal");
			alchemylab = FindStation("piece_MeadCauldron");
			smeltworks = FindStation("piece_scrapsmelter_bal");
		}
	}
	internal class BuildPieceList
	{
		public static string[] buildPieces = new string[13]
		{
			"capturedsurtling_bal", "marblesundial_bal", "runeobelsik_bal", "straw_floor_2x2_bal", "trainingmanekin_bal", "witchtalisman_bal", "piece_waterwell_bal", "piece_AncientSkullRock_bal", "piece_DragonSkull2_bal", "piece_DragonSkull_bal",
			"piece_loxSkeleton_bal", "piece_WhaleSkeleton_bal", "piece_jotunfinger_bal"
		};
	}
	public class DungeonFactory
	{
		private struct DungeonConfig
		{
			public int MinRooms;

			public int MaxRooms;

			public int MinRequiredRooms;

			public float? CampRadiusMin;

			public float? CampRadiusMax;

			public DungeonConfig(int min, int max, int minRequired = 10, float? campMin = null, float? campMax = null)
			{
				MinRooms = min;
				MaxRooms = max;
				MinRequiredRooms = minRequired;
				CampRadiusMin = campMin;
				CampRadiusMax = campMax;
			}
		}

		private readonly Dictionary<string, DungeonConfig> _dungeonConfigs = new Dictionary<string, DungeonConfig>
		{
			{
				"DG_Cave",
				new DungeonConfig(15, 60)
			},
			{
				"DG_AshlandRuins",
				new DungeonConfig(20, 40)
			},
			{
				"DG_SunkenCrypt",
				new DungeonConfig(20, 80, 10, 20f, 40f)
			},
			{
				"DG_Crypt",
				new DungeonConfig(15, 60)
			},
			{
				"DG_MeadowsFarm",
				new DungeonConfig(10, 40, 10, 10f, 50f)
			},
			{
				"DG_MeadowsVillage",
				new DungeonConfig(10, 40, 10, 10f, 50f)
			},
			{
				"DG_GoblinCamp",
				new DungeonConfig(5, 50, 5, 10f, 50f)
			},
			{
				"DG_FortressRuins",
				new DungeonConfig(30, 40, 10, 30f, 45f)
			},
			{
				"DG_ForestCrypt",
				new DungeonConfig(15, 60)
			},
			{
				"DG_DvergrTown",
				new DungeonConfig(30, 120, 10, 10f, 50f)
			}
		};

		public void EditDungeons(List<GameObject> dungeons)
		{
			if (dungeons == null || dungeons.Count == 0)
			{
				return;
			}
			foreach (GameObject dungeon in dungeons)
			{
				DungeonGenerator val = (((Object)(object)dungeon != (Object)null) ? dungeon.GetComponent<DungeonGenerator>() : null);
				if ((Object)(object)val != (Object)null)
				{
					ApplyDungeonSettings(val);
				}
			}
		}

		private void ApplyDungeonSettings(DungeonGenerator dungeon)
		{
			if (_dungeonConfigs.TryGetValue(((Object)dungeon).name, out var value))
			{
				SetRoomLimits(dungeon, value.MinRooms, value.MaxRooms, value.MinRequiredRooms);
				if (value.CampRadiusMin.HasValue && value.CampRadiusMax.HasValue)
				{
					SetCampRadius(dungeon, value.CampRadiusMin.Value, value.CampRadiusMax.Value);
				}
			}
		}

		private void SetRoomLimits(DungeonGenerator dungeon, int min, int max, int minRequired)
		{
			dungeon.m_minRooms = min;
			dungeon.m_maxRooms = max;
			dungeon.m_minRequiredRooms = minRequired;
		}

		private void SetCampRadius(DungeonGenerator dungeon, float min, float max)
		{
			dungeon.m_campRadiusMin = min;
			dungeon.m_campRadiusMax = max;
		}
	}
	internal class ItemList
	{
		public static readonly string[] items = new string[29]
		{
			"AshtreeSeeds_bal", "CrystalTreeSeeds_bal", "DeadAcaiSeeds_bal", "GiantOakSeeds_bal", "ElderTreeSeeds_bal", "HangingMossSeeds_bal", "OrangeOakSeeds_bal", "YewSeeds_bal", "BlackMetalOre_bal", "StrawBundle_bal",
			"Straw_bal", "AcaiSeeds_bal", "CypressSeeds_bal", "Darkbul_bal", "MapleSeeds_bal", "PoplarSeeds_bal", "Blackberries_bal", "BlackTissue_bal", "Bloodfruit_bal", "Ignicap_bal",
			"Moss_bal", "Lavender_bal", "Lingonberry_bal", "RedKelp_bal", "Snowleaf_bal", "YggTreeSeed_bal", "RedwoodSeeds_bal", "SwampTreeSeeds_bal", "WillowSeeds_bal"
		};
	}
	public class JsonLoader
	{
		public string defaultPath = string.Empty;

		public void loadJson()
		{
			LoadTranslations();
			justDefaultPath();
		}

		public void justDefaultPath()
		{
			string configPath = Paths.ConfigPath;
			string text = Path.Combine(configPath, "BalrondPapayonPack-translation/");
			defaultPath = text;
		}

		public void createDefaultPath()
		{
			string configPath = Paths.ConfigPath;
			string path = Path.Combine(configPath, "BalrondPapayonPack-translation/");
			if (!Directory.Exists(path))
			{
				CreateFolder(path);
			}
			defaultPath = path;
		}

		private string[] jsonFilePath(string folderName, string extension)
		{
			string configPath = Paths.ConfigPath;
			string path = Path.Combine(configPath, "BalrondPapayonPack-translation/");
			if (!Directory.Exists(path))
			{
				CreateFolder(path);
			}
			return Directory.GetFiles(path, extension);
		}

		private static void CreateFolder(string path)
		{
			try
			{
				Directory.CreateDirectory(path);
				Debug.Log((object)"BalrondPapayonPack: Folder created successfully.");
			}
			catch (Exception ex)
			{
				Debug.Log((object)("BalrondPapayonPack: Error creating folder: " + ex.Message));
			}
		}

		private void LoadTranslations()
		{
			int num = 0;
			string[] array = jsonFilePath("Translation", "*.json");
			foreach (string text in array)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
				string json = File.ReadAllText(text);
				JsonData jsonData = JsonMapper.ToObject(json);
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				foreach (string key in jsonData.Keys)
				{
					dictionary[key] = jsonData[key].ToString();
				}
				if (dictionary != null)
				{
					BalrondTranslator.translations.Add(fileNameWithoutExtension, dictionary);
					num++;
				}
				else
				{
					Debug.LogError((object)("BalrondPapayonPack: Loading FAILED file: " + text));
				}
			}
		}
	}
	[BepInPlugin("balrond.astafaraios.BalrondPapayonPack", "BalrondPapayonPack", "1.0.0")]
	public class Launch : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Player), "UseStamina")]
		private class Player_UseStamina
		{
			private static bool Prefix()
			{
				return !Player.m_debugMode || !((Terminal)Console.instance).IsCheatsEnabled();
			}
		}

		[HarmonyPatch(typeof(Player), "UseEitr")]
		private class Player_UseEitr
		{
			private static bool Prefix()
			{
				return !Player.m_debugMode || !((Terminal)Console.instance).IsCheatsEnabled();
			}
		}

		[HarmonyPatch(typeof(AudioMan), "Awake")]
		private static class AudioMan_Awake_Patch
		{
			private static void Postfix(AudioMan __instance)
			{
				List<List<GameObject>> list = new List<List<GameObject>> { modResourceLoader.itemPrefabs, modResourceLoader.buildPrefabs, modResourceLoader.monsterPrefabs, modResourceLoader.vfxPrefabs, modResourceLoader.vegetationPrefabs };
				foreach (List<GameObject> item in list)
				{
					foreach (GameObject item2 in item)
					{
						AudioSource[] componentsInChildren = item2.GetComponentsInChildren<AudioSource>(true);
						foreach (AudioSource val in componentsInChildren)
						{
							val.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static class Object_CopyOtherDB_Patch
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					modResourceLoader.setupBuildPiecesListDB();
					databaseAddMethods.AddItems(modResourceLoader.itemPrefabs);
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_Patch
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					modResourceLoader.setupBuildPiecesListDB();
					databaseAddMethods.AddItems(modResourceLoader.itemPrefabs);
					databaseAddMethods.AddStatuseffects(modResourceLoader.statusEffects);
					recipeFactory.createRecipes(ObjectDB.instance.m_items, modResourceLoader.itemPrefabs);
					modResourceLoader.recipes.AddRange(recipeFactory.recipes);
					databaseAddMethods.AddRecipes(modResourceLoader.recipes);
				}
			}

			private static int SortByScore(Recipe p1, Recipe p2)
			{
				if ((Object)(object)p1.m_item == (Object)null)
				{
					return 0;
				}
				if ((Object)(object)p2.m_item == (Object)null)
				{
					return 1;
				}
				return string.Compare(((Object)p1.m_item).name, ((Object)p2.m_item).name, StringComparison.Ordinal);
			}
		}

		[HarmonyPatch(typeof(Tutorial), "Awake")]
		public static class Tutorial_Awake_Patch
		{
			public static void Postfix(Tutorial __instance)
			{
				__instance.m_texts.AddRange(ConversionChanges.m_texts);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class ZNetScene_Awake_Patch
		{
			private static bool _sessionInitialized;

			public static void Prefix(ZNetScene __instance)
			{
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogWarning((object)(projectName + ": No ZNetScene found"));
					return;
				}
				TryAddRuntimePrefabs(__instance);
				if (_sessionInitialized)
				{
					return;
				}
				try
				{
					RunOneTimeSceneSetup(__instance);
					_sessionInitialized = true;
					Debug.Log((object)(projectName + ": ZNetScene one-time setup completed."));
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"{projectName}: ZNetScene one-time setup failed: {arg}");
				}
			}
		}

		private readonly Harmony harmony = new Harmony("balrond.astafaraios.BalrondPapayonPack");

		public const string PluginGUID = "balrond.astafaraios.BalrondPapayonPack";

		public const string PluginName = "BalrondPapayonPack";

		public const string PluginVersion = "1.0.0";

		public static ModResourceLoader modResourceLoader = new ModResourceLoader();

		public static DatabaseAddMethods databaseAddMethods = new DatabaseAddMethods();

		public static MonsterManager monsterManager = new MonsterManager();

		public static ConversionChanges conversionEdits = new ConversionChanges();

		public static BuildPieceBuilder buildPieceBuilder = new BuildPieceBuilder();

		public static VegetationBuilder vegetationBuilder = new VegetationBuilder();

		public static RecipeFactory recipeFactory = new RecipeFactory();

		public static VendorBuilder vendorBuilder = new VendorBuilder();

		public static ItemEdits itemEdits = new ItemEdits();

		public static VegetationDropFix vegetationDropFix = new VegetationDropFix();

		public static string projectName = "BalrondPapayonPack";

		public static JsonLoader jsonLoader = new JsonLoader();

		public static GameObject RootObject;

		public static GameObject PrefabContainer;

		public static bool hasSpawned = false;

		public static LocationBuilder locationBuilder = new LocationBuilder();

		public static DungeonFactory dungeonFactory = new DungeonFactory();

		public static float biomeCounter = 1000f;

		public static NatureGrowth natureGrowth = new NatureGrowth();

		public static List<string> loadingScreens = new List<string>();

		public static Dictionary<string, string> loadingScreens2 = new Dictionary<string, string>();

		public static Dictionary<string, DateTime> fileWriteTimes = new Dictionary<string, DateTime>();

		public static List<string> screensToLoad = new List<string>();

		public static string[] loadingTips = new string[0];

		public static Dictionary<string, Texture2D> cachedScreens = new Dictionary<string, Texture2D>();

		private void Awake()
		{
			CreatePrefabContainer();
			modResourceLoader.loadAssets();
			vegetationBuilder.createVegetationObjects(modResourceLoader.vegetationPrefabs);
			vegetationBuilder.createVegetationObjects(modResourceLoader.plantPrefabs);
			harmony.PatchAll();
		}

		public void Start()
		{
			RegisterUpgrade("vegetation_add", "Adds vegetations of mod BalrondAmazingNature.", modResourceLoader.vegetationPrefabs.Select((GameObject p) => ((Object)p).name), "vegetation_reset");
			RegisterUpgrade("vegetation_update", "Modify vanilla vegetations changed by mod BalrondAmazingNature.", VegetationBuilder.vegNames, "vegetation_reset");
			RegisterUpgrade("locations", "Modify vanilla Locations changed by mod BalrondAmazingNature.", LocationBuilder.vanillaLocationsYouEdit, "locations_add");
		}

		private void RegisterUpgrade(string keySuffix, string description, IEnumerable<string> names, string lineName)
		{
			string name = "BalrondAmazingNature_" + keySuffix;
			string text = string.Format("{0} {1} start", lineName, string.Join(",", names));
			Upgrade.Register(name, description, text);
		}

		public void CreatePrefabContainer()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			RootObject = new GameObject("_ValheimReforgedRoot");
			Object.DontDestroyOnLoad((Object)(object)RootObject);
			PrefabContainer = new GameObject("Prefabs");
			PrefabContainer.transform.parent = RootObject.transform;
			PrefabContainer.SetActive(false);
		}

		public static GameObject CloneMe(GameObject source, string name)
		{
			GameObject val = Object.Instantiate<GameObject>(source, PrefabContainer.transform);
			((Object)val).name = name;
			FixMaterials(val, source);
			val.SetActive(true);
			return val;
		}

		public static GameObject FixMaterials(GameObject clone, GameObject source)
		{
			MeshRenderer[] componentsInChildren = source.GetComponentsInChildren<MeshRenderer>();
			MeshRenderer[] componentsInChildren2 = clone.GetComponentsInChildren<MeshRenderer>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				string name = ((Object)componentsInChildren[i]).name;
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					if (((Object)componentsInChildren2[j]).name == name)
					{
						((Renderer)componentsInChildren2[j]).materials = ((Renderer)componentsInChildren[i]).sharedMaterials;
						((Renderer)componentsInChildren2[j]).sharedMaterials = ((Renderer)componentsInChildren[i]).sharedMaterials;
						break;
					}
				}
			}
			return clone;
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}

		private static bool IsObjectDBValid()
		{
			ObjectDB instance = ObjectDB.instance;
			return (Object)(object)instance != (Object)null && instance.m_items.Count != 0 && instance.m_recipes.Count != 0 && (Object)(object)instance.GetItemPrefab("Amber") != (Object)null;
		}

		private static void TryAddRuntimePrefabs(ZNetScene zNetScene)
		{
			GameObject val = CreateTentacleMinion(zNetScene);
			if ((Object)(object)val != (Object)null && !zNetScene.m_prefabs.Contains(val))
			{
				zNetScene.m_prefabs.Add(val);
			}
			modResourceLoader.AddPrefabsToZnetScene(zNetScene);
		}

		private static void RunOneTimeSceneSetup(ZNetScene zNetScene)
		{
			vegetationDropFix.items = zNetScene.m_prefabs;
			vegetationDropFix.fixDrops(zNetScene.m_prefabs, zNetScene);
			modResourceLoader.addPlantstoCultivator(zNetScene);
			modResourceLoader.setupBuildPiecesList(zNetScene);
			List<GameObject> dungeons = zNetScene.m_prefabs.FindAll((GameObject x) => (Object)(object)x.GetComponent<DungeonGenerator>() != (Object)null);
			dungeonFactory.EditDungeons(dungeons);
			monsterManager.setupMonsterList(zNetScene.m_prefabs);
			buildPieceBuilder.SetupBuildPieces(zNetScene);
			conversionEdits.editBuidlPieces(zNetScene.m_prefabs);
			monsterManager.setupSpawners(zNetScene.m_prefabs);
			vendorBuilder.EditVendors(zNetScene.m_prefabs);
			natureGrowth.setupNewSaplings(zNetScene);
			if (!IsDedicatedServer())
			{
				ShaderReplacment.RunMaterialFix();
			}
		}

		private static bool IsDedicatedServer()
		{
			return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated();
		}

		public static void SetupSeekers(ZNetScene scene)
		{
			GameObject val = FindPrefabInZnet("SeekerBrood", scene);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Growup val2 = val.GetComponent<Growup>() ?? val.AddComponent<Growup>();
			val2.m_growTime = 4500f;
			val2.m_grownPrefab = FindPrefabInZnet("Seeker", scene);
			GameObject val3 = FindPrefabInZnet("SeekerEgg_bal", scene);
			if ((Object)(object)val3 != (Object)null)
			{
				EggHatch component = val3.GetComponent<EggHatch>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_spawnPrefab = val;
				}
			}
			GameObject val4 = FindPrefabInZnet("Larva_bal", scene);
			if ((Object)(object)val4 != (Object)null)
			{
				EggGrow component2 = val4.GetComponent<EggGrow>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.m_grownPrefab = val;
				}
			}
		}

		public static GameObject FindPrefabInZnet(string name, ZNetScene zNetScene)
		{
			if (!zNetScene.m_namedPrefabs.TryGetValue(BalrondHashCompat.StableHash(name), out var value))
			{
				return zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
			}
			return value;
		}

		public static void SetRunestonesDestructible(List<GameObject> runestones, List<GameObject> prefabs)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = prefabs.Find((GameObject x) => ((Object)x).name == "Rock_4");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Destructible component = val.GetComponent<Destructible>();
			DropOnDestroyed component2 = val.GetComponent<DropOnDestroyed>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null)
			{
				return;
			}
			foreach (GameObject runestone in runestones)
			{
				Destructible val2 = runestone.GetComponent<Destructible>() ?? runestone.AddComponent<Destructible>();
				val2.m_autoCreateFragments = component.m_autoCreateFragments;
				val2.m_damages = component.m_damages;
				val2.m_destroyed = component.m_destroyed;
				val2.m_destroyNoise = component.m_destroyNoise;
				val2.m_destructibleType = component.m_destructibleType;
				val2.m_health = component.m_health;
				val2.m_hitEffect = component.m_hitEffect;
				val2.m_hitNoise = component.m_hitNoise;
				val2.m_minDamageTreshold = component.m_minDamageTreshold;
				val2.m_minToolTier = 1;
				DropOnDestroyed val3 = runestone.GetComponent<DropOnDestroyed>() ?? runestone.AddComponent<DropOnDestroyed>();
				val3.m_dropWhenDestroyed = component2.m_dropWhenDestroyed;
				val3.m_spawnYOffset = component2.m_spawnYOffset;
				val3.m_spawnYStep = component2.m_spawnYStep;
			}
		}

		public static GameObject CreateTentacleMinion(ZNetScene scene)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = FindPrefabInZnet("TentaRoot", scene);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = CloneMe(val, "tentacle_plant_bal");
			Humanoid component = val2.GetComponent<Humanoid>();
			((Character)component).m_name = "$tag_tentaroot_bal";
			((Character)component).m_faction = (Faction)0;
			((Character)component).m_health = 33f;
			CharacterTimedDestruction component2 = val.GetComponent<CharacterTimedDestruction>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
			GameObject val3 = FindPrefabInZnet("Skeleton_Friendly", scene);
			Tameable component3 = val3.GetComponent<Tameable>();
			Tameable val4 = val2.AddComponent<Tameable>();
			val4.m_commandable = true;
			val4.m_startsTamed = true;
			val4.m_fedDuration = component3.m_fedDuration;
			val4.m_petEffect = component3.m_petEffect;
			val4.m_sootheEffect = component3.m_sootheEffect;
			val4.m_tamedEffect = component3.m_tamedEffect;
			val4.m_unsummonDistance = component3.m_unsummonDistance;
			val4.m_unSummonEffect = component3.m_unSummonEffect;
			val4.m_tamingTime = component3.m_tamingTime;
			val4.m_unsummonOnOwnerLogoutSeconds = component3.m_unsummonOnOwnerLogoutSeconds;
			val4.m_levelUpOwnerSkill = component3.m_levelUpOwnerSkill;
			val4.m_levelUpFactor = component3.m_levelUpFactor;
			val4.m_randomStartingName = component3.m_randomStartingName;
			return val2;
		}

		public static void EditCart(ZNetScene scene)
		{
			GameObject val = FindPrefabInZnet("Cart", scene);
			if (!((Object)(object)val == (Object)null))
			{
				Vagon component = val.GetComponent<Vagon>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_itemWeightMassFactor = 0.02f;
				}
			}
		}

		public static void AddHoverToHearthRocks(ZNetScene scene)
		{
			AddHover(FindPrefabInZnet("rock2_heath", scene), "$tag_limeStone_deposit_bal");
			AddHover(FindPrefabInZnet("rock4_heath", scene), "$tag_limeStone_deposit_bal");
		}

		public static void AddHover(GameObject obj, string text)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				HoverText val = obj.GetComponent<HoverText>() ?? obj.AddComponent<HoverText>();
				val.m_text = text;
			}
		}

		public static void EditLeviathans(ZNetScene scene)
		{
			GameObject val = FindPrefabInZnet("Leviathan", scene);
			if ((Object)(object)val != (Object)null)
			{
				Leviathan component = val.GetComponent<Leviathan>();
				component.m_leaveDelay = 25;
			}
			GameObject val2 = FindPrefabInZnet("LeviathanLava", scene);
			if ((Object)(object)val2 != (Object)null)
			{
				Leviathan component2 = val2.GetComponent<Leviathan>();
				component2.m_leaveDelay = 40;
			}
		}
	}
	public class PicaxeFix
	{
		public static void fix(ZNetScene zNetScene)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			dictionary.Add("PickaxeBlackMetal", 5);
			dictionary.Add("PickaxeBronze", 3);
			dictionary.Add("PickaxeIron", 4);
			dictionary.Add("PickaxeAntler", 2);
			dictionary.Add("PickaxeStone", 1);
			foreach (KeyValuePair<string, int> kvp in dictionary)
			{
				GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == kvp.Key);
				if ((Object)(object)val != (Object)null)
				{
					val.GetComponent<ItemDrop>().m_itemData.m_shared.m_toolTier = kvp.Value;
				}
			}
		}
	}
	internal class VegetationList
	{
		public static string[] vegetation = new string[65]
		{
			"Oak2_bal", "Oak2_Stub_bal", "Oak3_bal", "Oak_Swamp_bal", "AcaiTree_New_bal", "AcaiTree_Stub_bal", "Acai_Dead_bal", "Acai_Dead_Stub_bal", "Lingonberry_shrub_bal", "BigShootStump_bal",
			"BirchAutStub_bal", "BlackberryBush2_bal", "BlackberryBush_bal", "Cypress_bal", "Cypress_Stub_bal", "DeathsquitoHive_bal", "deposit_jotunfinger_bal", "DragonRibcage_bal", "DragonSkull2_bal", "DragonSkull_bal",
			"ElderMushroom_bal", "ElderMushroom_Stub_bal", "ElderTreeStump_bal", "ElderTree_bal", "IcedTree_bal", "IcedTree_Stub_bal", "LinedSwampTreeLarge2_bal", "LinedSwampTreeLarge_bal", "MammothRibcage_bal", "MammothSkull_bal",
			"MammothSpine_bal", "Maple_bal", "Maple_Stub_bal", "MineRock_Blackmetal_bal", "Pickable_Bloodvine_bal", "Pickable_Ignicap_bal", "Pickable_Kelp_bal", "MineRock_IronNew_bal", "Pickable_Lavender_bal", "Pickable_MountainCaveCrystal_bal",
			"Pickable_Snowleaf_bal", "Pickable_StrawPlant_bal", "Pickable_Straw_bal", "Poplar_bal", "Poplar_Stub_bal", "SurtlingSpawner_bal", "WetTree1_bal", "WetTree2_bal", "WetTree3_bal", "WetTree_Stub_bal",
			"WhaleRibs_bal", "WhaleSkeleton_bal", "WhaleSkull_bal", "WhaleSpine_bal", "Willow_bal", "Willow_Stub_bal", "YewTree_bal", "YewTree_Stub_bal", "YggaBigShoot_bal", "TwistedTree_small_bal",
			"loxSkeleton_bal", "Pickable_Straw_DeepNorth_bal", "HugeRoot1_bal", "RockGolemSpawn_bal", "AncientSkullRock_bal"
		};
	}
	public class LocationBuilder
	{
		public static List<ZoneLocation> zoneLocations = new List<ZoneLocation>();

		public static List<Location> workingLocations = new List<Location>();

		public static List<string> vanillaLocationsYouEdit = new List<string>
		{
			"Ruin1", "Ruin2", "StoneTower1", "StoneTower3", "Ruin3", "MountainWell1", "StoneHenge6", "ShipWreck01", "ShipWreck02", "ShipWreck03",
			"ShipWreck04", "CharredTowerRuins1_dvergr", "VoltureNest", "PlaceofMystery1", "PlaceofMystery2", "PlaceofMystery3", "StoneCircle", "StoneHouse5_heath", "DrakeNest01", "MountainCave02",
			"Dolmen01", "Dolmen02", "Dolmen03", "Mistlands_Swords1", "Mistlands_Swords2", "Mistlands_Swords3", "Mistlands_Viaduct1", "Mistlands_Viaduct2", "Mistlands_Lighthouse1_new", "Mistlands_Swords3",
			"Mistlands_GuardTower1_new", "Mistlands_GuardTower2_new", "Mistlands_GuardTower3_new", "Mistlands_RockSpire1", "Mistlands_RoadPost1", "Mistlands_Giant1", "Mistlands_Giant2", "Mistlands_Harbour1", "Waymarker01", "Waymarker02",
			"TrollCave02", "AbandonedLogCabin02", "AbandonedLogCabin03", "AbandonedLogCabin04", "TarPit1", "TarPit2", "TarPit3", "SwampWell1", "ShipSetting01", "MountainGrave01",
			"InfestedTree01", "StoneTowerRuins03", "StoneTowerRuins04", "StoneTowerRuins05", "StoneTowerRuins07", "StoneTowerRuins08", "StoneTowerRuins09", "StoneTowerRuins10", "SwampRuin1", "SwampRuin2",
			"WoodHouse1", "WoodHouse2", "WoodHouse3", "WoodHouse4", "WoodHouse5", "WoodHouse6", "WoodHouse7", "WoodHouse8", "WoodHouse9", "WoodHouse10",
			"WoodHouse11", "WoodHouse12", "WoodHouse13", "StoneHenge6", "StoneHouse3", "StoneHouse4", "SwampHut1", "SwampHut2", "SwampHut3", "SwampHut4",
			"SwampHut5", "StoneHouse5_heath", "WoodFarm1", "WoodVillage1", "GoblinCamp2", "Crypt2", "Crypt3", "Crypt4"
		};

		public HashSet<string> deepNorthNames = new HashSet<string>
		{
			"MountainWell1", "StoneHenge6", "ShipWreck01", "ShipWreck02", "ShipWreck03", "ShipWreck04", "CharredTowerRuins1_dvergr", "StoneCircle", "DrakeNest01", "Dolmen01",
			"Dolmen02", "Dolmen03", "Mistlands_Swords1", "Mistlands_Swords2", "Mistlands_Swords3", "Mistlands_Viaduct1", "Mistlands_Viaduct2", "Mistlands_Lighthouse1_new", "Mistlands_GuardTower1_new", "Mistlands_GuardTower2_new",
			"Mistlands_GuardTower3_new", "Mistlands_RockSpire1", "Mistlands_RoadPost1", "Mistlands_Giant2", "Waymarker01", "Waymarker02", "TrollCave02"
		};

		public List<ZoneLocation> locations = new List<ZoneLocation>();

		public void editLocations(List<ZoneLocation> locationList)
		{
			if (locationList == null || locationList.Count == 0)
			{
				Debug.LogWarning((object)"LOCATION LIST IS EMPTY!");
			}
			else
			{
				changeBiomeSetup(locationList);
			}
		}

		private ZoneLocation FindLocation(List<ZoneLocation> locationList, string name)
		{
			return locationList.Find((ZoneLocation x) => x.m_prefabName == name);
		}

		private bool isForDeepNorth(string name)
		{
			return deepNorthNames.Contains(name);
		}

		private void editLocation(ZoneLocation zoneLocation)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			_ = zoneLocation.m_prefab;
			if (0 == 0)
			{
				zoneLocation.m_biome = (Biome)(zoneLocation.m_biome | 0x40);
				zoneLocation.m_quantity *= 2;
				zoneLocation.m_minDistance = 0f;
				zoneLocation.m_maxDistance = 0f;
				string prefabName = zoneLocation.m_prefabName;
				zoneLocation.m_biome = (Biome)(zoneLocation.m_biome | 0x60);
			}
		}

		private void changeBiomeSetup(List<ZoneLocation> locationList)
		{
			Debug.Log((object)(Launch.projectName + ": Editing Locations for world spawn"));
			ApplyToLocations(locationList, new string[68]
			{
				"TarPit1", "TarPit2", "TarPit3", "SwampWell1", "ShipSetting01", "MountainGrave01", "InfestedTree01", "StoneTowerRuins03", "StoneTowerRuins04", "StoneTowerRuins05",
				"StoneTowerRuins07", "StoneTowerRuins08", "StoneTowerRuins09", "StoneTowerRuins10", "SwampRuin1", "SwampRuin2", "WoodHouse1", "WoodHouse2", "WoodHouse3", "WoodHouse4",
				"WoodHouse5", "WoodHouse6", "WoodHouse7", "WoodHouse8", "WoodHouse9", "WoodHouse10", "WoodHouse11", "WoodHouse12", "WoodHouse13", "StoneHenge6",
				"StoneHouse3", "StoneHouse4", "SwampHut1", "SwampHut2", "SwampHut3", "SwampHut4", "SwampHut5", "StoneHouse5_heath", "Ruin1", "Ruin2",
				"Mistlands_Giant2", "Mistlands_Harbour1", "Waymarker01", "Waymarker02", "TrollCave02", "Mistlands_RockSpire1", "Mistlands_RoadPost1", "DrakeNest01", "Dolmen01", "Dolmen02",
				"Dolmen03", "Mistlands_Swords1", "Mistlands_Swords2", "Mistlands_Swords3", "Mistlands_Viaduct1", "Mistlands_Viaduct2", "StoneCircle", "MountainWell1", "StoneHenge6", "ShipWreck01",
				"ShipWreck02", "ShipWreck03", "ShipWreck04", "CharredTowerRuins1_dvergr", "Mistlands_Lighthouse1_new", "Mistlands_GuardTower1_new", "Mistlands_GuardTower2_new", "Mistlands_GuardTower3_new"
			}, biomeSwap);
			ApplyToLocations(locationList, new string[18]
			{
				"WoodFarm1", "WoodVillage1", "GoblinCamp2", "MountainCave02", "Crypt2", "Crypt3", "Crypt4", "SunkenCrypt4", "StoneTower1", "StoneTower3",
				"Ruin3", "GoblinKing", "Eikthyrnir", "Dragonqueen", "GDKing", "Bonemass", "Mistlands_DvergrBossEntrance1", "FaderLocation"
			}, locationEditSpecial);
		}

		private void ApplyToLocations(List<ZoneLocation> locationList, string[] names, Action<ZoneLocation> action)
		{
			for (int i = 0; i < names.Length; i++)
			{
				ZoneLocation val = FindLocation(locationList, names[i]);
				if (val != null)
				{
					action(val);
				}
				else
				{
					Debug.LogWarning((object)("Location not found: " + names[i]));
				}
			}
		}

		private void locationEditSpecial(ZoneLocation loc)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			string prefabName = loc.m_prefabName;
			if (IsIn(prefabName, "SunkenCrypt", "SunkenCrypt4"))
			{
				loc.m_biome = (Biome)2;
				loc.m_minDistance = 600f;
				loc.m_minDistanceFromCenter = 600f;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 0f;
				loc.m_maxAltitude = 100000f;
				loc.m_iconPlaced = true;
				loc.m_quantity *= 2;
				loc.m_prioritized = true;
				loc.m_biomeArea = (BiomeArea)3;
				loc.m_minDistanceFromSimilar = 44f;
				return;
			}
			switch (prefabName)
			{
			case "MountainCave02":
				loc.m_biome = (Biome)68;
				loc.m_minAltitude = 20f;
				loc.m_maxAltitude = 100000f;
				loc.m_minDistance = 600f;
				loc.m_minDistanceFromCenter = 600f;
				loc.m_quantity *= 3;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minDistanceFromSimilar = 44f;
				return;
			case "Crypt2":
				loc.m_biome = (Biome)522;
				loc.m_minDistanceFromCenter = 300f;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 15f;
				loc.m_maxAltitude = 100000f;
				loc.m_minDistanceFromSimilar = 44f;
				loc.m_quantity *= 2;
				return;
			case "Crypt3":
				loc.m_biome = (Biome)524;
				loc.m_minDistanceFromCenter = 300f;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 15f;
				loc.m_maxAltitude = 100000f;
				loc.m_minDistanceFromSimilar = 44f;
				loc.m_quantity *= 2;
				return;
			case "Crypt4":
				loc.m_biome = (Biome)81;
				loc.m_minDistanceFromCenter = 600f;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 15f;
				loc.m_maxAltitude = 100000f;
				loc.m_minDistanceFromSimilar = 44f;
				loc.m_quantity *= 2;
				return;
			case "WoodFarm1":
				loc.m_biome = (Biome)95;
				loc.m_minDistanceFromCenter = 300f;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 10f;
				loc.m_maxAltitude = 10000f;
				loc.m_quantity *= 2;
				return;
			case "WoodVillage1":
				loc.m_biome = (Biome)95;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 10f;
				loc.m_maxAltitude = 10000f;
				loc.m_minDistanceFromCenter = 1500f;
				loc.m_quantity *= 2;
				return;
			}
			if (IsIn(prefabName, "GoblinCamp2", "StoneTower1", "StoneTower3", "Ruin3"))
			{
				loc.m_biome = (Biome)25;
				loc.m_maxDistance = 10500f;
				loc.m_maxDistanceFromCenter = 10500f;
				loc.m_minAltitude = 10f;
				loc.m_maxAltitude = 100000f;
				loc.m_minDistanceFromCenter = 2900f;
				return;
			}
			switch (prefabName)
			{
			case "Eikthyrnir":
				loc.m_group = "bossarena";
				loc.m_minDistance = 300f;
				loc.m_minDistanceFromCenter = 300f;
				loc.m_maxDistanceFromCenter = 1000f;
				loc.m_maxDistance = 800f;
				loc.m_quantity = 15;
				loc.m_unique = true;
				break;
			case "GDKing":
				loc.m_group = "bossarena";
				loc.m_minDistanceFromSimilar = 500f;
				loc.m_minDistance = 1000f;
				loc.m_minDistanceFromCenter = 1000f;
				loc.m_maxDistanceFromCenter = 2500f;
				loc.m_maxDistance = 2500f;
				loc.m_quantity = 10;
				loc.m_unique = true;
				break;
			case "Bonemass":
				loc.m_group = "bossarena";
				loc.m_minDistanceFromSimilar = 500f;
				loc.m_minDistance = 1500f;
				loc.m_minDistanceFromCenter = 1500f;
				loc.m_maxDistanceFromCenter = 3500f;
				loc.m_maxDistance = 3500f;
				loc.m_quantity = 10;
				loc.m_unique = true;
				break;
			case "Dragonqueen":
				loc.m_group = "bossarena";
				loc.m_minDistanceFromSimilar = 50f;
				loc.m_minDistance = 300f;
				loc.m_minDistanceFromCenter = 100f;
				loc.m_maxDistanceFromCenter = 7000f;
				loc.m_maxDistance = 7000f;
				loc.m_quantity = 15;
				loc.m_unique = true;
				break;
			case "GoblinKing":
				loc.m_group = "bossarena";
				loc.m_minDistanceFromSimilar = 500f;
				loc.m_minDistance = 3000f;
				loc.m_minDistanceFromCenter = 3000f;
				loc.m_maxDistance = 7000f;
				loc.m_maxDistanceFromCenter = 7000f;
				loc.m_quantity = 10;
				loc.m_unique = true;
				break;
			case "Mistlands_DvergrBossEntrance1":
				loc.m_group = "bossarena";
				loc.m_minDistanceFromSimilar = 500f;
				loc.m_minDistance = 4000f;
				loc.m_minDistanceFromCenter = 5500f;
				loc.m_maxDistanceFromCenter = 8500f;
				loc.m_maxDistance = 8500f;
				loc.m_quantity = 10;
				loc.m_unique = true;
				break;
			case "FaderLocation":
				loc.m_group = "bossarena";
				loc.m_quantity = 10;
				loc.m_unique = true;
				break;
			}
		}

		private void biomeSwap(ZoneLocation zoneLocation)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0616: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			string prefabName = zoneLocation.m_prefabName;
			Biome val = (Biome)9;
			Biome val2 = (Biome)11;
			Biome biome = (Biome)10;
			Biome val3 = (Biome)17;
			Biome val4 = (Biome)18;
			Biome val5 = (Biome)24;
			Biome val6 = (Biome)(val4 | val);
			Biome biome2 = (Biome)48;
			Biome val7 = (Biome)580;
			Biome val8 = (Biome)516;
			Biome val9 = (Biome)514;
			Biome val10 = (Biome)68;
			Biome biome3 = (Biome)(val7 | val6);
			Biome val11 = (Biome)(val10 | val4);
			Biome biome4 = (Biome)(val4 | val7);
			Biome biome5 = (Biome)(val5 | val9);
			Biome biome6 = (Biome)608;
			Biome biome7 = (Biome)25;
			if (isForDeepNorth(prefabName))
			{
				if (prefabName == "Mistlands_RoadPost1" || prefabName == "Mistlands_RockSpire1")
				{
					zoneLocation.m_biome = (Biome)(zoneLocation.m_biome | 0x60);
					zoneLocation.m_minDistance = 0f;
					zoneLocation.m_maxDistance = 0f;
				}
				else
				{
					editLocationParams(zoneLocation, (Biome)(zoneLocation.m_biome | 0x40), 0);
				}
			}
			if (prefabName == "Mistlands_Harbour1")
			{
				editLocationParams(zoneLocation, biome6);
				zoneLocation.m_maxAltitude = 3000f;
			}
			if (prefabName == "MountainWell1")
			{
				editLocationParams(zoneLocation, val10);
				zoneLocation.m_minAltitude = 0f;
				zoneLocation.m_maxAltitude = 3000f;
			}
			else if (IsIn(prefabName, "ShipWreck01", "ShipWreck02", "ShipWreck03", "ShipWreck04"))
			{
				zoneLocation.m_biome = (Biome)91;
				zoneLocation.m_quantity *= 2;
				zoneLocation.m_maxDistance = 10500f;
				zoneLocation.m_maxDistanceFromCenter = 10500f;
				zoneLocation.m_minAltitude = -6f;
				zoneLocation.m_maxAltitude = 100000f;
				zoneLocation.m_minDistanceFromCenter = 200f;
			}
			if (IsIn(prefabName, "Ruin1", "Ruin2"))
			{
				editLocationParams(zoneLocation, val, 600);
				zoneLocation.m_minAltitude = 5f;
				zoneLocation.m_maxAltitude = 150f;
			}
			if (IsIn(prefabName, "TarPit1", "TarPit2", "TarPit3"))
			{
				editLocationParams(zoneLocation, biome2);
				zoneLocation.m_minAltitude = 5f;
				zoneLocation.m_maxAltitude = 70f;
				return;
			}
			switch (prefabName)
			{
			case "SwampWell1":
				editLocationParams(zoneLocation, biome3, 1200);
				return;
			case "ShipSetting01":
				editLocationParams(zoneLocation, biome3);
				zoneLocation.m_minAltitude = -5f;
				zoneLocation.m_maxAltitude = 25f;
				return;
			case "MountainGrave01":
				editLocationParams(zoneLocation, biome3);
				zoneLocation.m_minAltitude = -1f;
				zoneLocation.m_maxAltitude = 30000f;
				zoneLocation.m_biomeArea = (BiomeArea)3;
				zoneLocation.m_quantity *= 2;
				return;
			case "InfestedTree01":
				editLocationParams(zoneLocation, val9);
				return;
			}
			if (IsIn(prefabName, "AbandonedLogCabin02", "AbandonedLogCabin03", "AbandonedLogCabin04"))
			{
				editLocationParams(zoneLocation, val7);
			}
			else if (prefabName == "StoneTowerRuins03")
			{
				editLocationParams(zoneLocation, biome, 400);
			}
			else if (IsIn(prefabName, "Waymarker01", "Waymarker02"))
			{
				editLocationParams(zoneLocation, val7);
				zoneLocation.m_minAltitude = -1f;
			}
			else if (IsIn(prefabName, "WoodHouse3", "WoodHouse4", "WoodHouse5"))
			{
				editLocationParams(zoneLocation, biome7);
				zoneLocation.m_maxAltitude = 30000f;
			}
			else if (IsIn(prefabName, "WoodHouse1", "WoodHouse13", "WoodHouse6", "WoodHouse7"))
			{
				editLocationParams(zoneLocation, val);
				zoneLocation.m_maxAltitude = 30000f;
			}
			else if (IsIn(prefabName, "WoodHouse2", "WoodHouse9", "WoodHouse11"))
			{
				editLocationParams(zoneLocation, val6);
				zoneLocation.m_maxAltitude = 30000f;
			}
			else if (IsIn(prefabName, "WoodHouse8", "WoodHouse9", "WoodHouse10", "WoodHouse12", "StoneHouse3", "StoneHouse4", "StoneHenge6"))
			{
				editLocationParams(zoneLocation, biome3);
				zoneLocation.m_maxAltitude = 30000f;
			}
			else if (IsIn(prefabName, "SwampRuin1", "SwampRuin2", "StoneTowerRuins04"))
			{
				editLocationParams(zoneLocation, biome3, 1500);
				zoneLocation.m_maxAltitude = 30000f;
			}
			else if (prefabName == "StoneTowerRuins05")
			{
				editLocationParams(zoneLocation, biome4);
				zoneLocation.m_minAltitude = -1f;
				zoneLocation.m_maxAltitude = 30000f;
			}
			else if (IsIn(prefabName, "StoneTowerRuins06", "StoneTowerRuins07", "StoneTowerRuins08", "StoneTowerRuins09", "StoneTowerRuins10", "StoneWall1", "StoneWall2"))
			{
				editLocationParams(zoneLocation, val6, 750);
			}
			else if (prefabName == "StoneHouse5_heath")
			{
				editLocationParams(zoneLocation, biome2);
			}
			else if (IsIn(prefabName, "SwampHut1", "SwampHut2", "SwampHut3", "SwampHut5"))
			{
				editLocationParams(zoneLocation, biome4, 1000);
			}
			else if (prefabName == "SwampHut4")
			{
				editLocationParams(zoneLocation, biome5, 500);
			}
		}

		private void editLocationParams(ZoneLocation zoneLocation, Biome biome, int minDistance = 200)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			zoneLocation.m_enable = true;
			zoneLocation.m_biome = biome;
			zoneLocation.m_quantity *= 2;
			zoneLocation.m_minAltitude = ((zoneLocation.m_minAltitude == 0f) ? 10f : zoneLocation.m_minAltitude);
			zoneLocation.m_maxAltitude = ((zoneLocation.m_maxAltitude == 0f) ? 3000f : zoneLocation.m_maxAltitude);
			zoneLocation.m_minDistance = minDistance;
			zoneLocation.m_maxDistance = 0f;
		}

		private bool IsIn(string name, params string[] options)
		{
			for (int i = 0; i < options.Length; i++)
			{
				if (name == options[i])
				{
					return true;
				}
			}
			return false;
		}
	}
	public class MonsterManager
	{
		private List<GameObject> monsters;

		private List<GameObject> list;

		public void setupMonsterList(List<GameObject> list)
		{
			if (list == null)
			{
				Debug.LogWarning((object)"I DID NOT FOUND PREFAB LIST!");
				return;
			}
			this.list = list;
			List<GameObject> list2 = list.FindAll((GameObject x) => Object.op_Implicit((Object)(object)x.GetComponent<MonsterAI>()) || Object.op_Implicit((Object)(object)x.GetComponent<AnimalAI>()) || Object.op_Implicit((Object)(object)x.GetComponent<Humanoid>()));
			monsters = list2;
		}

		public void changeMonsterResistance()
		{
			if (monsters == null)
			{
				Debug.LogWarning((object)"I DID NOT FOUND ANY MONSTERS!");
				return;
			}
			foreach (GameObject monster in monsters)
			{
				Humanoid component = monster.GetComponent<Humanoid>();
				if ((Object)(object)component != (Object)null)
				{
					changeSpiritResistance(component);
				}
			}
			changeMonsterDrops();
		}

		public void setupSpawners(List<GameObject> list)
		{
			doSpawnerChanges("BonePileSpawner");
			doSpawnerChanges("Spawner_DraugrPile");
			doSpawnerChanges("Spawner_GreydwarfNest");
			doSpawnerChanges("SurtlingSpawner_bal");
			doSpawnerChanges("DeathsquitoHive_bal");
			doSpawnerChanges("RockGolemSpawn_bal");
		}

		private void doSpawnerChanges(string name)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				CreateSpanwerDropList(val);
				if (name == "DeathsquitoHive_bal")
				{
					SpawnArea component = val.GetComponent<SpawnArea>();
					SpawnData val2 = new SpawnData();
					val2.m_maxLevel = 3;
					val2.m_weight = 1f;
					val2.m_minLevel = 1;
					GameObject val3 = list.Find((GameObject x) => ((Object)x).name == "Deathsquito");
					if ((Object)(object)val3 != (Object)null)
					{
						val2.m_prefab = val3;
					}
					else
					{
						val2.m_prefab = list.Find((GameObject x) => ((Object)x).name == "Deathsquito");
					}
					component.m_prefabs.Add(val2);
				}
				if (name == "RockGolemSpawn_bal")
				{
					SpawnArea component2 = val.GetComponent<SpawnArea>();
					SpawnData val4 = new SpawnData();
					val4.m_maxLevel = 2;
					val4.m_weight = 1f;
					val4.m_minLevel = 1;
					GameObject val5 = list.Find((GameObject x) => ((Object)x).name == "StoneGolem");
					if ((Object)(object)val5 != (Object)null)
					{
						val4.m_prefab = val5;
					}
					else
					{
						val4.m_prefab = list.Find((GameObject x) => ((Object)x).name == "StoneGolem");
					}
					component2.m_prefabs.Add(val4);
				}
				if (name == "SurtlingSpawner_bal")
				{
					SpawnArea component3 = val.GetComponent<SpawnArea>();
					SpawnData val6 = new SpawnData();
					val6.m_maxLevel = 3;
					val6.m_weight = 1f;
					val6.m_minLevel = 1;
					val6.m_prefab = list.Find((GameObject x) => ((Object)x).name == "Surtling");
					component3.m_prefabs.Add(val6);
				}
			}
			else
			{
				Debug.LogWarning((object)("spawner not found: " + name));
			}
		}

		private DropData prepareDrop(GameObject item, int min, int max, float chance)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			DropData result = default(DropData);
			result.m_item = item;
			result.m_stackMin = min;
			result.m_stackMax = max;
			result.m_weight = chance;
			return result;
		}

		private void CreateSpanwerDropList(GameObject gameObject)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_070e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0737: Unknown result type (might be due to invalid IL or missing references)
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0809: Unknown result type (might be due to invalid IL or missing references)
			//IL_0832: Unknown result type (might be due to invalid IL or missing references)
			//IL_085b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			DropOnDestroyed val = gameObject.GetComponent<DropOnDestroyed>();
			if ((Object)(object)val == (Object)null)
			{
				val = gameObject.AddComponent<DropOnDestroyed>();
				val.m_dropWhenDestroyed.m_dropMin = 2;
				val.m_dropWhenDestroyed.m_dropMax = 3;
				val.m_spawnYOffset = 0.5f;
				val.m_spawnYStep = 0.3f;
			}
			val.m_dropWhenDestroyed.m_drops.Clear();
			switch (((Object)gameObject).name)
			{
			case "BonePileSpawner":
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("BoneFragments"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TrophySkeleton"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("BronzeScrap"), 1, 2, 0.22f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("CopperScrap"), 1, 2, 0.33f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("WitheredBone"), 1, 1, 0.5f));
				break;
			case "Spawner_DraugrPile":
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("BoneFragments"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Entrails"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TrophyDraugr"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TrophySkeleton"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("SilverNecklace"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("IronScrap"), 1, 2, 0.1f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("BronzeScrap"), 1, 2, 0.25f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("CopperScrap"), 1, 2, 0.33f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("SwampTreeSeeds_bal"), 1, 2, 0.5f));
				break;
			case "Spawner_GreydwarfNest":
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Wood"), 2, 4, 1f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("RoundLog"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("FineWood"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Root"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("AncientSeed"), 1, 2, 1f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Dandelion"), 2, 4, 1f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Thistle"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TrophyGreydwarf"), 2, 4, 0.95f));
				break;
			case "SurtlingSpawner_bal":
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("FlametalOre"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("IronOre"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Stone"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("BlackMarble"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Obsidian"), 1, 1, 0.5f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TinOre"), 2, 4, 0.9f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Ruby"), 1, 1, 0.01f));
				break;
			case "DeathsquitoHive_bal":
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Wood"), 2, 4, 1f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("RoundLog"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("FineWood"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Root"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("AncientSeed"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Dandelion"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Straw_bal"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Needle"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Thistle"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("BoneFragments"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TrophyDeathsquito"), 1, 1, 0.95f));
				break;
			case "RockGolemSpawn_bal":
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TrophySGolem"), 1, 1, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Stone"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Obsidian"), 1, 1, 0.5f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("IronOre"), 1, 1, 0.1f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Flint"), 2, 4, 0.95f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("Crystal"), 2, 4, 0.5f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("SilverOre"), 1, 1, 0.5f));
				val.m_dropWhenDestroyed.m_drops.Add(prepareDrop(FindItem("TinOre"), 1, 1, 0.5f));
				break;
			}
		}

		private void changeSpiritResistance(Humanoid humanoid)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected I4, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Faction faction = ((Character)humanoid).m_faction;
			Faction val = faction;
			switch (val - 1)
			{
			case 7:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)1;
				break;
			case 0:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)5;
				break;
			case 1:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)1;
				break;
			case 5:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)5;
				break;
			case 2:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)2;
				break;
			case 3:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)2;
				break;
			case 6:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)1;
				break;
			case 4:
				((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)1;
				break;
			}
		}

		private void changeMonsterDrops()
		{
			foreach (GameObject monster in monsters)
			{
				monsterLootChange(monster);
			}
		}

		private void monsterLootChange(GameObject monster)
		{
			CharacterDrop val = monster.GetComponent<CharacterDrop>();
			if ((Object)(object)val == (Object)null)
			{
				val = monster.AddComponent<CharacterDrop>();
			}
			switch (((Object)monster).name)
			{
			case "Skeleton_Hildir":
			case "GoblinShaman_Hildir":
			case "Fenring_Cultist_Hildir":
			case "Skeleton_Hildir_nochest":
			case "GoblinBruteBros_nochest":
			case "GoblinShaman_Hildir_nochest":
			case "GoblinBrute_Hildir":
			case "Fenring_Cultist_Hildir_nochest":
				addItemToLootTable(val, "SeaPearl_bal", 1, 2, 0.2f);
				addItemToLootTable(val, "Amber", 1, 2, 0.3f);
				addItemToLootTable(val, "Ruby", 2, 3, 0.4f);
				addItemToLootTable(val, "Coins", 20, 40, 0.5f);
				addItemToLootTable(val, "CorruptedEitr_bal", 3, 5, 0.6f);
				addItemToLootTable(val, "Peningar_bal", 30, 40, 0.7f);
				addItemToLootTable(val, "RustedScrap_bal", 3, 6, 0.1f, multiplier: false);
				break;
			case "Abomination":
				editDrop(val, "Root", 4, 8, 1f);
				editMonsterHealth(monster, 1000);
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 3, 0.3f);
				addItemToLootTable(val, "AncientSeed", 1, 1, 0.1f);
				addItemToLootTable(val, "SwampTreeSeeds_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "HardWood_bal", 1, 3, 0.5f);
				addItemToLootTable(val, "FineWood", 1, 3, 0.5f);
				break;
			case "Hare":
				editMonsterHealth(monster, 25);
				addItemToLootTable(val, "LeatherScraps", 1, 3, 0.5f);
				addItemToLootTable(val, "AcaiSeeds_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "Straw_bal", 1, 2, 0.2f);
				break;
			case "Leech":
				addItemToLootTable(val, "SmallBloodSack_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "SwampTreeSeeds_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "RottenMeat", 1, 1, 0.4f);
				break;
			case "Troll_ru":
			case "Troll":
				editDrop(val, "TrollHide", 2, 3, 1f);
				editDrop(val, "Coins", 10, 20, 0.5f);
				addItemToLootTable(val, "TrollMeat_bal", 1, 1, 0.75f);
				addItemToLootTable(val, "LeatherScraps", 1, 3, 0.5f);
				addItemToLootTable(val, "Clay_bal", 1, 3, 0.3f);
				addItemToLootTable(val, "RottenMeat", 1, 1, 0.4f);
				addItemToLootTable(val, "RustyBrokenSword_bal", 1, 1, 0.02f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 40, 50, 0.5f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 2, 0.1f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				break;
			case "Charred_Archer":
			case "Charred_Melee":
			case "Charred_Mage":
			case "Charred_Twitcher":
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.3f);
				addItemToLootTable(val, "MagmaStone_bal", 1, 2, 0.1f);
				addItemToLootTable(val, "FlametalScrap_bal", 1, 2, 0.1f, multiplier: false);
				addItemToLootTable(val, "Ruby", 0, 1, 0.05f);
				addItemToLootTable(val, "Amethyst_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Emerald_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Opal_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Onyx_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Sapphire_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "VikingTalisman_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "LeatherScraps", 1, 3, 0.1f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.5f, multiplier: false);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				break;
			case "Surtling":
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 2, 0.1f);
				addItemToLootTable(val, "MagmaStone_bal", 1, 2, 0.1f);
				addItemToLootTable(val, "SurtrAmulet_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "Ruby", 0, 1, 0.05f);
				addItemToLootTable(val, "Opal_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Onyx_bal", 0, 1, 0.05f);
				editMonsterHealth(monster, 50);
				break;
			case "Dragon":
				addItemToLootTable(val, "CorruptedEitr_bal", 4, 8, 0.8f);
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.7f);
				addItemToLootTable(val, "Onyx_bal", 1, 1, 0.05f);
				addItemToLootTable(val, "Sapphire_bal", 1, 1, 0.05f);
				addItemToLootTable(val, "Peningar_bal", 50, 200, 0.5f);
				addItemToLootTable(val, "DrakeMeat_bal", 2, 4, 0.33f);
				addItemToLootTable(val, "DrakeSkin_bal", 3, 6, 0.33f);
				break;
			case "GoblinKing":
				addItemToLootTable(val, "CorruptedEitr_bal", 5, 10, 0.9f, multiplier: false);
				addItemToLootTable(val, "JuteRed", 2, 4, 0.7f);
				addItemToLootTable(val, "CursedBone_bal", 6, 12, 0.8f, multiplier: true, perPlayer: true);
				addItemToLootTable(val, "SilverScrap_bal", 3, 5, 0.1f, multiplier: false);
				addItemToLootTable(val, "IronScrap", 3, 5, 0.2f);
				addItemToLootTable(val, "BronzeScrap", 3, 5, 0.3f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 3, 5, 0.4f, multiplier: false);
				addItemToLootTable(val, "Amethyst_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "Emerald_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "Opal_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "Onyx_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "Sapphire_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "Coins", 25, 100, 0.5f);
				addItemToLootTable(val, "Peningar_bal", 50, 200, 0.5f);
				addItemToLootTable(val, "RustedScrap_bal", 5, 8, 0.5f, multiplier: false);
				break;
			case "GoblinBrute":
				editDrop(val, "GoblinTotem", 1, 1, 0.33f, multiplier: false);
				addItemToLootTable(val, "SilverScrap_bal", 1, 1, 0.06f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 10, 20, 0.5f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.5f, multiplier: false);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "IronScrap", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.15f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.2f, multiplier: false);
				break;
			case "GoblinShaman":
				addItemToLootTable(val, "CorruptedEitr_bal", 2, 4, 0.7f);
				addItemToLootTable(val, "Ectoplasm", 1, 1, 0.5f);
				addItemToLootTable(val, "SilverScrap_bal", 1, 1, 0.06f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 10, 20, 0.5f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.5f, multiplier: false);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "IronScrap", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.15f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.2f, multiplier: false);
				addItemToLootTable(val, "GoblinTotem", 1, 1, 0.55f, multiplier: false);
				break;
			case "Goblin":
				addItemToLootTable(val, "GoblinTotem", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "RustyBrokenSword_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 10, 20, 0.25f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.25f, multiplier: false);
				break;
			case "Draugr_Elite":
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.5f, multiplier: false);
				addItemToLootTable(val, "RustyBrokenSword_bal", 1, 1, 0.2f, multiplier: false);
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.2f);
				addItemToLootTable(val, "Ectoplasm", 1, 1, 0.75f);
				addItemToLootTable(val, "ArrowFlint", 1, 3, 0.5f);
				addItemToLootTable(val, "SilverScrap_bal", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "IronScrap", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.15f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.2f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 10, 20, 0.5f);
				if (!Compatibility.IsLoaded())
				{
					addItemToLootTable(val, "CryptKey", 1, 1, 0.5f, multiplier: false);
				}
				addItemToLootTable(val, "CultInsignia_bal", 1, 1, 0.8f, multiplier: false);
				addItemToLootTable(val, "Mycelium_bal", 1, 2, 0.8f);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "VikingTalisman_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				editMonsterHealth(monster, 350);
				break;
			case "Greydwarf_Elite":
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.02f);
				addItemToLootTable(val, "StrawSeeds_bal", 1, 1, 0.3f);
				addItemToLootTable(val, "AppleSeeds_bal", 1, 1, 0.25f);
				addItemToLootTable(val, "Thistle", 1, 1, 0.1f);
				addItemToLootTable(val, "Dandelion", 1, 1, 0.1f);
				addItemToLootTable(val, "Moss_bal", 1, 1, 0.4f);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "BasicSeed_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "RottenVegetable_bal", 1, 1, 0.55f);
				editMonsterHealth(monster, 250);
				break;
			case "Skeleton_Poison":
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.05f);
				addItemToLootTable(val, "RustyBrokenSword_bal", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.25f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "IronScrap", 1, 1, 0.005f, multiplier: false);
				addItemToLootTable(val, "BrassScrap_bal", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.01f);
				editMonsterHealth(monster, 150);
				break;
			case "Skeleton":
			case "Skeleton_NoArcher":
				addItemToLootTable(val, "RustyBrokenSword_bal", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.005f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.01f, multiplier: false);
				break;
			case "DraugrRanged":
			case "DraugrArcher":
			case "Draugr":
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.02f);
				addItemToLootTable(val, "RustyBrokenSword_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "ArrowFlint", 1, 3, 0.1f);
				addItemToLootTable(val, "Ectoplasm", 1, 1, 0.03f);
				addItemToLootTable(val, "IronScrap", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 5, 10, 0.5f);
				if (!Compatibility.IsLoaded())
				{
					addItemToLootTable(val, "CryptKey", 0, 1, 0.005f, multiplier: false);
				}
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.15f);
				addItemToLootTable(val, "CultInsignia_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "Mycelium_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "VikingTalisman_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				break;
			case "gd_king":
				addItemToLootTable(val, "WatcherHeart_bal", 1, 1, 1f, multiplier: false, perPlayer: true);
				addItemToLootTable(val, "CorruptedEitr_bal", 2, 4, 0.1f, multiplier: false);
				addItemToLootTable(val, "Amethyst_bal", 1, 2, 0.1f);
				addItemToLootTable(val, "FineWood", 2, 4, 0.7f);
				addItemToLootTable(val, "RoundLog", 4, 6, 0.8f);
				addItemToLootTable(val, "Wood", 8, 10, 0.9f);
				addItemToLootTable(val, "ElderBark", 1, 2, 0.6f);
				addItemToLootTable(val, "Root", 1, 3, 0.6f);
				addItemToLootTable(val, "AppleSeeds_bal", 4, 8, 0.75f);
				addItemToLootTable(val, "Thistle", 2, 4, 0.5f);
				editMonsterHealth(monster, 3300);
				break;
			case "Deer":
				editDrop(val, "TrophyDeer", 1, 1, 0.25f, multiplier: false);
				editDrop(val, "DeerHide", 1, 1, 0.75f);
				editDrop(val, "DeerMeat", 1, 1, 1f);
				addItemToLootTable(val, "LeatherScraps", 1, 1, 0.33f);
				break;
			case "Hatchling":
				editDrop(val, "FreezeGland", 1, 2, 0.75f);
				addItemToLootTable(val, "DrakeSkin_bal", 1, 1, 0.15f);
				addItemToLootTable(val, "LeatherScraps", 0, 2, 0.5f);
				addItemToLootTable(val, "BoneFragments", 1, 2, 0.1f);
				addItemToLootTable(val, "DrakeMeat_bal", 1, 1, 0.55f);
				break;
			case "BlobElite":
				editDrop(val, "IronScrap", 1, 1, 0.11f);
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.5f);
				addItemToLootTable(val, "BoneFragments", 2, 4, 0.5f);
				addItemToLootTable(val, "Guck", 1, 1, 0.5f);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.22f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.33f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 2, 0.44f, multiplier: false);
				break;
			case "Blob":
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.5f);
				addItemToLootTable(val, "BoneFragments", 1, 2, 0.5f);
				addItemToLootTable(val, "Guck", 1, 1, 0.1f);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.25f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.8f, multiplier: false);
				break;
			case "BlobLava":
				addItemToLootTable(val, "Tar", 1, 1, 0.4f);
				addItemToLootTable(val, "MagmaStone_bal", 1, 1, 0.3f);
				addItemToLootTable(val, "Obsidian", 1, 1, 0.1f);
				addItemToLootTable(val, "Coal", 1, 1, 0.7f);
				addItemToLootTable(val, "SulfurStone", 1, 1, 0.3f);
				addItemToLootTable(val, "FlametalScrap_bal", 1, 1, 0.25f, multiplier: false);
				addItemToLootTable(val, "DarksteelScrap_bal", 1, 1, 0.35f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.5f, multiplier: false);
				addItemToLootTable(val, "Opal_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Onyx_bal", 0, 1, 0.05f);
				break;
			case "DvergerMage":
			case "DvergerMageFire":
			case "DvergerMageIce":
			case "DvergerMageSupport":
			case "Dverger":
				addItemToLootTable(val, "BoraxCrystal_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Ruby", 0, 1, 0.05f);
				addItemToLootTable(val, "Amethyst_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Emerald_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Opal_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Onyx_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Sapphire_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "SilverScrap_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "IronScrap", 1, 1, 0.25f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 1, 1, 0.35f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.4f, multiplier: false);
				addItemToLootTable(val, "Peningar_bal", 10, 20, 0.5f);
				addItemToLootTable(val, "JuteRed", 1, 1, 0.5f);
				addItemToLootTable(val, "JuteBlue", 1, 1, 0.5f);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				addGlobalKey(monster, "killedDverger");
				break;
			case "Tick":
				addItemToLootTable(val, "SmallBloodSack_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "Bloodbag", 1, 1, 0.15f);
				addGlobalKey(monster, "killedInsecto");
				break;
			case "StoneGolem":
				addItemToLootTable(val, "LeadOre_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "CopperOre", 1, 1, 0.15f);
				addItemToLootTable(val, "TinOre", 1, 1, 0.2f);
				addItemToLootTable(val, "IronOre", 1, 1, 0.1f);
				addItemToLootTable(val, "SilverOre", 1, 1, 0.05f);
				addItemToLootTable(val, "Ruby", 0, 1, 0.05f);
				addItemToLootTable(val, "Amethyst_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Emerald_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Opal_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Onyx_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "Sapphire_bal", 0, 1, 0.05f);
				addItemToLootTable(val, "LimeStone_bal", 1, 3, 0.45f);
				addItemToLootTable(val, "GemChunks_bal", 1, 1, 0.1f);
				addGlobalKey(monster, "killedStoneGolem");
				break;
			case "Bonemass":
				editMonsterHealth(monster, 6500);
				addItemToLootTable(val, "SoulCore_bal", 1, 1, 1f, multiplier: false, perPlayer: true);
				addItemToLootTable(val, "CursedBone_bal", 6, 12, 1f, multiplier: true, perPlayer: true);
				addItemToLootTable(val, "Ectoplasm", 2, 4, 0.2f);
				addItemToLootTable(val, "CorruptedEitr_bal", 6, 12, 0.6f);
				addItemToLootTable(val, "BoneFragments", 5, 20, 0.2f);
				addItemToLootTable(val, "Ooze", 3, 6, 0.2f);
				addItemToLootTable(val, "Guck", 3, 6, 0.2f);
				addItemToLootTable(val, "RustedScrap_bal", 8, 16, 0.8f, multiplier: false);
				addItemToLootTable(val, "IronScrap", 2, 4, 0.25f, multiplier: false);
				addItemToLootTable(val, "BronzeScrap", 4, 8, 0.35f, multiplier: false);
				addItemToLootTable(val, "CopperScrap", 6, 12, 0.4f, multiplier: false);
				addItemToLootTable(val, "Mycelium_bal", 3, 6, 0.2f);
				break;
			case "Greyling":
				editMonsterHealth(monster, 30);
				addItemToLootTable(val, "Straw_bal", 1, 1, 0.9f);
				addItemToLootTable(val, "Dandelion", 1, 1, 0.1f);
				addItemToLootTable(val, "Mushroom", 1, 1, 0.1f);
				addItemToLootTable(val, "Raspberry", 1, 1, 0.1f);
				addItemToLootTable(val, "Blueberries", 1, 1, 0.1f);
				addItemToLootTable(val, "BasicSeed_bal", 1, 1, 0.1f);
				break;
			case "Greydwarf":
				addItemToLootTable(val, "StrawSeeds_bal", 1, 1, 0.44f);
				addItemToLootTable(val, "AppleSeeds_bal", 1, 1, 0.22f);
				addItemToLootTable(val, "Moss_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "BasicSeed_bal", 1, 1, 0.33f);
				addItemToLootTable(val, "RottenVegetable_bal", 1, 1, 0.11f);
				break;
			case "Greydwarf_Shaman":
				addItemToLootTable(val, "Apple_bal", 1, 1, 0.33f);
				addItemToLootTable(val, "Thistle", 1, 1, 0.5f);
				addItemToLootTable(val, "EnrichedSoil_bal", 1, 1, 0.2f);
				addItemToLootTable(val, "Moss_bal", 1, 1, 0.7f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "RottenVegetable_bal", 1, 1, 0.55f);
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.05f, multiplier: false);
				editMonsterHealth(monster, 100);
				break;
			case "SeekerBrood":
				addItemToLootTable(val, "RawSilkScrap_bal", 1, 1, 0.25f);
				addItemToLootTable(val, "Resin", 1, 1, 0.25f);
				addItemToLootTable(val, "Ooze", 1, 1, 0.25f);
				break;
			case "SeekerBrute":
				addItemToLootTable(val, "SeekerBrain_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "RawSilk_bal", 1, 1, 0.4f);
				addItemToLootTable(val, "RawSilkScrap_bal", 1, 2, 0.8f);
				addItemToLootTable(val, "Larva_bal", 1, 1, 0.3f);
				addGlobalKey(monster, "killedSeeker");
				break;
			case "Seeker":
				addItemToLootTable(val, "SeekerBrain_bal", 1, 1, 0.01f, multiplier: false);
				addItemToLootTable(val, "RawSilk_bal", 1, 1, 0.25f);
				addItemToLootTable(val, "RawSilkScrap_bal", 1, 2, 0.5f);
				addGlobalKey(monster, "killedSeeker");
				break;
			case "SeekerQueen":
				editDrop(val, "QueenDrop", 10, 20, 1f, multiplier: true, perPlayer: true);
				addItemToLootTable(val, "RawSilk_bal", 4, 8, 1f);
				addItemToLootTable(val, "RawSilkScrap_bal", 8, 16, 1f);
				addItemToLootTable(val, "BugMeat", 3, 6, 0.8f);
				addItemToLootTable(val, "GiantBloodSack", 1, 3, 0.8f);
				addItemToLootTable(val, "Mandible", 1, 3, 0.8f);
				addItemToLootTable(val, "CorruptedEitr_bal", 5, 10, 0.9f);
				addItemToLootTable(val, "Chitin", 4, 8, 0.4f);
				addItemToLootTable(val, "Bilebag", 1, 3, 0.3f);
				addItemToLootTable(val, "Carapace", 3, 6, 0.3f);
				addItemToLootTable(val, "Bloodbag", 4, 8, 0.3f);
				addItemToLootTable(val, "AcidSludge_bal", 3, 6, 0.3f);
				break;
			case "Eikthyr":
				editDrop(val, "HardAntler", 5, 5, 1f);
				addItemToLootTable(val, "LeatherScraps", 5, 10, 0.5f);
				addItemToLootTable(val, "DeerHide", 2, 4, 0.9f);
				addItemToLootTable(val, "BasicSeed_bal", 3, 5, 0.75f);
				addItemToLootTable(val, "StrawSeeds_bal", 2, 4, 0.33f);
				addItemToLootTable(val, "Clay_bal", 2, 4, 0.1f);
				addItemToLootTable(val, "AppleSeeds_bal", 1, 2, 0.11f);
				addItemToLootTable(val, "DeerMeat", 2, 4, 0.9f);
				addItemToLootTable(val, "RottenMeat", 1, 2, 0.5f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.1f, multiplier: false);
				editMonsterHealth(monster, 800);
				break;
			case "Neck":
				editDrop(val, "TrophyNeck", 1, 1, 0.2f, multiplier: false);
				editDrop(val, "NeckTail", 1, 1, 1f);
				addItemToLootTable(val, "NeckSkin_bal", 1, 1, 0.33f);
				addItemToLootTable(val, "LeatherScraps", 1, 1, 0.5f);
				addItemToLootTable(val, "Clay_bal", 1, 1, 0.1f);
				editMonsterHealth(monster, 10);
				break;
			case "Boar":
				editDrop(val, "TrophyBoar", 1, 1, 0.2f, multiplier: false);
				editDrop(val, "LeatherScraps", 1, 3, 0.5f);
				editDrop(val, "RawMeat", 1, 1, 1f);
				addItemToLootTable(val, "BoarHide_bal", 1, 1, 0.75f);
				editMonsterHealth(monster, 15);
				break;
			case "Ghost":
				addItemToLootTable(val, "RottenMeat", 1, 1, 0.5f);
				addItemToLootTable(val, "ArrowFlint", 1, 3, 0.5f);
				addItemToLootTable(val, "SilverNecklace", 1, 1, 0.1f);
				addItemToLootTable(val, "CopperScrap", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.1f, multiplier: false);
				addItemToLootTable(val, "Amber", 1, 1, 0.1f);
				addItemToLootTable(val, "Peningar_bal", 1, 1, 0.2f);
				addItemToLootTable(val, "Coins", 1, 1, 0.1f);
				break;
			case "Ulv":
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.5f);
				addItemToLootTable(val, "WolfMeat", 1, 1, 0.5f);
				addItemToLootTable(val, "WolfHairBundle", 1, 1, 0.1f);
				addItemToLootTable(val, "Bloodbag", 1, 1, 0.1f);
				addItemToLootTable(val, "BoneFragments", 1, 2, 0.5f);
				addItemToLootTable(val, "FenringMeat_bal", 1, 1, 0.15f);
				addItemToLootTable(val, "WolfClaw", 1, 1, 0.15f);
				break;
			case "Fenring":
				addItemToLootTable(val, "FenringMeat_bal", 1, 1, 0.33f);
				addItemToLootTable(val, "SilverScrap_bal", 1, 1, 0.3f, multiplier: false);
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.5f);
				addItemToLootTable(val, "CorruptedEitr_bal", 1, 2, 0.3f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.33f, multiplier: false);
				addItemToLootTable(val, "FenringInsygnia_bal", 1, 1, 0.05f, multiplier: false);
				addItemToLootTable(val, "WolfHairBundle", 1, 1, 0.2f);
				addItemToLootTable(val, "WolfClaw", 1, 1, 0.2f);
				break;
			case "Fenring_Cultist":
				addItemToLootTable(val, "SilverScrap_bal", 1, 1, 0.6f, multiplier: false);
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.5f);
				addItemToLootTable(val, "FenringMeat_bal", 1, 1, 0.33f);
				addItemToLootTable(val, "CorruptedEitr_bal", 2, 5, 0.6f);
				addItemToLootTable(val, "RustedScrap_bal", 1, 1, 0.5f, multiplier: false);
				addItemToLootTable(val, "JuteRed", 1, 1, 0.5f);
				addItemToLootTable(val, "FenringInsygnia_bal", 1, 2, 0.1f, multiplier: false);
				addItemToLootTable(val, "WolfHairBundle", 1, 1, 0.2f);
				break;
			case "Bat":
				addItemToLootTable(val, "SmallBloodSack_bal", 1, 1, 0.5f);
				addItemToLootTable(val, "EnrichedSoil_bal", 1, 1, 0.1f);
				addItemToLootTable(val, "BoneFragments", 1, 1, 0.2f);
				addItemToLootTable(val, "LeatherScraps", 1, 2, 0.5f);
				addItemToLootTable(val, "BatWing_bal", 1, 1, 0.5f);
				break;
			case "Serpent":
				addItemToLootTable(val, "LeatherScraps", 4, 8, 0.5f);
				addItemToLootTable(val, "SerpentEgg_bal", 1, 1, 0.15f, multiplier: false);
				addItemToLootTable(val, "SeaPearl_bal", 1, 1, 0.15f);
				addItemToLootTable(val, "FreshSeaweed", 1, 1, 0.75f);
				addItemToLootTable(val, "RottenMeat", 1, 1, 0.4f);
				addItemToLootTable(val, "Bloodbag", 1, 1, 0.3f);
				addItemToLootTable(val, "FishRaw", 1, 2, 0.9f);
				editMonsterHealth(monster, 600);
				break;
			case "BonemawSerpent":
				addItemToLootTable(val, "LeatherScraps", 4, 8, 0.5f);
				addItemToLootTable(val, "BoneFragments", 3, 6, 0.15f);
				addItemToLootTable(val, "BonemawSerpentScale", 3, 6, 0.65f);
				addItemToLootTable(val, "Bloodbag", 1, 2, 0.5f);
				addItemToLootTable(val, "CorruptedEitr_bal", 2, 3, 0.1f, multiplier: false);
				editMonsterHealth(monster, 1200);
				break;
			}
		}

		private void addAttack(GameObject gameObject, string name)
		{
			Humanoid component = gameObject.GetComponent<Humanoid>();
			List<GameObject> list = new List<GameObject>();
			list.AddRange(component.m_defaultItems);
			list.Add(FindItem(name));
			component.m_defaultItems = list.ToArray();
		}

		private void editMonsterHealth(GameObject gameObject, int health)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Humanoid component = gameObject.GetComponent<Humanoid>();
			if ((Object)(object)component == (Object)null)
			{
				Character component2 = gameObject.GetComponent<Character>();
				component2.m_health = health;
			}
			else
			{
				((Character)component).m_health = health;
				((Character)component).m_damageModifiers.m_fire = (DamageModifier)1;
			}
		}

		private void editDrop(CharacterDrop drops, string itemName, int amountMin, int amountMax, float chance, bool multiplier = true, bool perPlayer = false)
		{
			foreach (Drop drop in drops.m_drops)
			{
				if (((Object)drop.m_prefab).name == itemName)
				{
					drop.m_amountMin = amountMin;
					drop.m_amountMax = amountMax;
					drop.m_chance = chance;
					drop.m_levelMultiplier = multiplier;
					drop.m_onePerPlayer = perPlayer;
				}
			}
		}

		private void setBoss(GameObject gameObject, bool isBoss = false)
		{
			Humanoid component = gameObject.GetComponent<Humanoid>();
			if (!((Object)(object)component == (Object)null))
			{
				((Character)component).m_boss = isBoss;
			}
		}

		private void addItemToLootTable(CharacterDrop drops, string itemName, int amountMin, int amountMax, float chance, bool multiplier = true, bool perPlayer = false)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			GameObject val = FindItem(itemName);
			if ((Object)(object)val != (Object)null)
			{
				List<Drop> list = drops.m_drops.FindAll((Drop x) => ((Object)x.m_prefab).name == itemName);
				if (list.Count <= 0)
				{
					Drop val2 = new Drop();
					val2.m_amountMin = amountMin;
					val2.m_amountMax = amountMax;
					val2.m_chance = chance;
					val2.m_levelMultiplier = multiplier;
					val2.m_prefab = val;
					val2.m_onePerPlayer = perPlayer;
					drops.m_drops.Add(val2);
				}
			}
		}

		private void addGlobalKey(GameObject monster, string key)
		{
			Humanoid component = monster.GetComponent<Humanoid>();
			((Character)component).m_defeatSetGlobalKey = key;
		}

		private GameObject FindItem(string name)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val == (Object)null)
			{
				val = list.Find((GameObject x) => ((Object)x).name == name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
				return list.Find((GameObject x) => ((Object)x).name == "Wood");
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Debug.LogWarning((object)("Item Not Found At All - " + name + ", Replaced With Wood"));
			return list.Find((GameObject x) => ((Object)x).name == "Wood");
		}
	}
	public class BuildPieceBuilder
	{
		private List<GameObject> list;

		private readonly Dictionary<string, GameObject> _itemCache = new Dictionary<string, GameObject>();

		public void SetupBuildPieces(ZNetScene zNetScene)
		{
			TableMapper.setupTables(zNetScene);
			list = zNetScene.m_prefabs;
			foreach (GameObject prefab in zNetScene.m_prefabs)
			{
				EditBuildPiece(prefab);
			}
		}

		private void EditBuildPiece(GameObject gameObject)
		{
			//IL_1275: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1531: Unknown result type (might be due to invalid IL or missing references)
			//IL_15fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_1576: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_14a7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Piece component = gameObject.gameObject.GetComponent<Piece>();
			if (!((Object)(object)component == (Object)null))
			{
				if ((Object)(object)component.m_craftingStation != (Object)null && ((Object)component.m_craftingStation).name == ((Object)TableMapper.workbench).name)
				{
					SetStation(component, TableMapper.heavyWorkbench);
				}
				switch (((Object)gameObject).name)
				{
				case "sapling_eldermushroom_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "BlackTissue_bal", 1);
					AddResources(component, "Mushroom", 3);
					break;
				case "sapling_Bloodvine_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Thistle", 3);
					break;
				case "sapling_bush_lingonberry_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Lingonberry_bal", 3);
					break;
				case "sapling_darkbul_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Darkbul_bal", 3);
					break;
				case "sapling_DeadAcaiTree_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "DeadAcaiSeeds_bal", 1);
					break;
				case "sapling_eldertree_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "ElderTreeSeeds_bal", 1);
					break;
				case "sapling_Iced_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "CrystalTreeSeeds_bal", 1);
					break;
				case "sapling_Snowleaf_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Snowleaf_bal", 3);
					break;
				case "sapling_ignicap_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Ignicap_bal", 3);
					break;
				case "sapling_Kelp_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "RedKelp_bal", 3);
					break;
				case "sapling_Lavender_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Lavender_bal", 3);
					break;
				case "sapling_Oak2_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "GiantOakSeeds_bal", 1);
					break;
				case "sapling_oak3_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "OrangeOakSeeds_bal", 1);
					break;
				case "sapling_twisted_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "RedwoodSeeds_bal", 1);
					break;
				case "sapling_wettree_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "HangingMossSeeds_bal", 1);
					break;
				case "sapling_Yew_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "YewSeeds_bal", 1);
					break;
				case "sapling_Ygg_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "YggdrasilWood", 2);
					AddResources(component, "AncientSeed", 1);
					AddResources(component, "Eitr", 2);
					break;
				case "sapling_bush_blackberry_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Blackberries_bal", 1);
					break;
				case "sapling_MushroomBlue_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "MushroomBlue", 1);
					AddResources(component, "Mycelium_bal", 1);
					break;
				case "sapling_MushroomGray_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "GrayMushroom_bal", 1);
					AddResources(component, "Mycelium_bal", 1);
					break;
				case "sapling_MushroomRandom_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Mycelium_bal", 2);
					break;
				case "sapling_mycelium_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Mycelium_bal", 1);
					break;
				case "sapling_MushroomRed_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Mushroom", 1);
					AddResources(component, "Mycelium_bal", 1);
					break;
				case "sapling_MushroomYellow_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "MushroomYellow", 1);
					AddResources(component, "Mycelium_bal", 1);
					break;
				case "sapling_Thistle_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Thistle", 3);
					break;
				case "sapling_Dandelion_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Dandelion", 3);
					break;
				case "sapling_bush_blueberry_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Blueberries", 3);
					break;
				case "sapling_bush_raspberry_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Raspberry", 3);
					break;
				case "sapling_bush_bal":
				case "sapling_bushPlains_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "BasicSeed_bal", 1);
					break;
				case "sapling_bushPlains2_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "BasicSeed_bal", 2);
					break;
				case "sapling_TentaRoot_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "AncientSeed", 1);
					AddResources(component, "TrophyGreydwarf", 1);
					break;
				case "sapling_AcaiTree_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "AcaiSeeds_bal", 1);
					break;
				case "sapling_Swamp_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "SwampTreeSeeds_bal", 1);
					break;
				case "sapling_Willow_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "WillowSeeds_bal", 1);
					break;
				case "sapling_BirchAtumn_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "BirchSeeds", 1);
					break;
				case "sapling_Poplar_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "PoplarSeeds_bal", 1);
					break;
				case "sapling_Maple_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "MapleSeeds_bal", 1);
					break;
				case "sapling_Cypress_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "CypressSeeds_bal", 1);
					break;
				case "sapling_AppleTree_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "AppleSeeds_bal", 3);
					break;
				case "sapling_Ashtree1_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "AshtreeSeeds_bal", 1);
					break;
				case "sapling_Ashtree2_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "AshtreeSeeds_bal", 1);
					break;
				case "sapling_Straw_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Straw_bal", 3);
					break;
				case "sapling_garlic_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "GarlicSeeds_bal", 1);
					break;
				case "sapling_seedgarlic_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "Garlic_bal", 1);
					break;
				case "sapling_Cabbage_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "CabbageSeeds_bal", 1);
					break;
				case "sapling_CabbageSeed_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					SetStation(component, null);
					AddResources(component, "CabbageLeaf_bal", 1);
					break;
				case "straw_floor_2x2_bal":
					SetStation(component, null);
					component.m_resources = (Requirement[])(object)new Requirement[0];
					AddResources(component, "StrawBundle_bal", 1);
					component.m_category = (PieceCategory)2;
					break;
				case "trainingmanekin_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_craftingStation = TableMapper.forge;
					AddResources(component, "Bronze", 2);
					AddResources(component, "Wood", 5);
					AddResources(component, "Iron", 2);
					break;
				case "piece_waterwell_bal":
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_craftingStation = TableMapper.stoneCutter;
					AddResources(component, "Stone", 15);
					AddResources(component, "FineWood", 10);
					AddResources(component, "Crystal", 5);
					break;
				case "capturedsurtling_bal":
					component.m_craftingStation = TableMapper.magetable;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					AddResources(component, "BlackMarble", 1);
					AddResources(component, "Crystal", 10);
					AddResources(component, "SurtlingCore", 5);
					AddResources(component, "MushroomMagecap", 2);
					break;
				case "marblesundial_bal":
					component.m_craftingStation = TableMapper.blackforge;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					AddResources(component, "MushroomMagecap", 2);
					AddResources(component, "Stone", 10);
					AddResources(component, "Crystal", 10);
					AddResources(component, "SurtlingCore", 1);
					break;
				case "runeobelsik_bal":
					component.m_craftingStation = TableMapper.blackforge;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					AddResources(component, "MushroomMagecap", 2);
					AddResources(component, "Stone", 15);
					AddResources(component, "Crystal", 15);
					AddResources(component, "SurtlingCore", 5);
					break;
				case "witchtalisman_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					AddResources(component, "Iron", 1);
					AddResources(component, "Ooze", 1);
					AddResources(component, "Chain", 1);
					AddResources(component, "WitheredBone", 1);
					break;
				case "piece_AncientSkullRock_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_category = (PieceCategory)0;
					AddResources(component, "CharredBone", 10);
					AddResources(component, "Stone", 10);
					break;
				case "piece_DragonSkull2_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_category = (PieceCategory)0;
					AddResources(component, "CharredBone", 50);
					AddResources(component, "Stone", 50);
					break;
				case "piece_DragonSkull_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_category = (PieceCategory)0;
					AddResources(component, "CharredBone", 100);
					AddResources(component, "Stone", 100);
					break;
				case "piece_loxSkeleton_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_category = (PieceCategory)0;
					AddResources(component, "CharredBone", 5);
					AddResources(component, "Stone", 5);
					break;
				case "piece_WhaleSkeleton_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_category = (PieceCategory)0;
					AddResources(component, "CharredBone", 15);
					AddResources(component, "Stone", 15);
					break;
				case "piece_jotunfinger_bal":
					component.m_craftingStation = TableMapper.workbench;
					component.m_resources = (Requirement[])(object)new Requirement[0];
					component.m_category = (PieceCategory)0;
					AddResources(component, "Crystal", 10);
					AddResources(component, "Stone", 10);
					break;
				}
			}
		}

		private void SetStation(Piece piece, CraftingStation station)
		{
			if ((Object)(object)piece == (Object)null)
			{
				Debug.LogWarning((object)"SetStation: Piece is null");
			}
			else
			{
				piece.m_craftingStation = station;
			}
		}

		private void AddResources(Piece piece, string itemName, int amount, int amountPerLevel = 0, bool recover = true)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			List<Requirement> list = new List<Requirement>();
			if (piece.m_resources != null)
			{
				list.AddRange(piece.m_resources);
			}
			GameObject val = FindItem(itemName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("AddResources: Could not find item prefab for " + itemName));
				return;
			}
			ItemDrop component = val.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("AddResources: Missing ItemDrop on " + itemName));
				return;
			}
			list.Add(new Requirement
			{
				m_resItem = component,
				m_amount = amount,
				m_amountPerLevel = amountPerLevel,
				m_recover = recover
			});
			piece.m_resources = list.ToArray();
		}

		private GameObject FindPrefabInZnet(string name, ZNetScene zNetScene)
		{
			if (!zNetScene.m_namedPrefabs.TryGetValue(BalrondHashCompat.StableHash(name), out var value))
			{
				return zNetScene.m_prefabs.Find((GameObject x) => (Object)(object)x != (Object)null && ((Object)x).name == name);
			}
			return value;
		}

		private GameObject FindItem(string name)
		{
			if (_itemCache.TryGetValue(name, out var value))
			{
				return value;
			}
			GameObject val = FindPrefabInZnet(name, TableMapper.zNetScene);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)(Launch.projectName + ": Item Not Found - " + name + ", Replaced With Wood"));
				val = FindPrefabInZnet("Wood", TableMapper.zNetScene);
			}
			if ((Object)(object)val != (Object)null)
			{
				_itemCache[name] = val;
			}
			return val;
		}
	}
	public class ItemEdits
	{
		private List<GameObject> items;

		private List<GameObject> buildPieces;

		public string[] addFloatTo = new string[6] { "LeatherScraps", "DeerHide", "LoxPelt", "WolfPelt", "BoarHide", "AskHide" };

		private GameObject FindItem(List<GameObject> list, string name)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
			if ((Object)(object)itemPrefab != (Object)null)
			{
				return itemPrefab;
			}
			Debug.LogWarning((object)("BalrondPapayonPack: Item Not Found: " + name));
			return null;
		}

		private bool statment(GameObject item)
		{
			return ((Object)item).name.Contains("Sword") || ((Object)item).name.Contains("Mace") || ((Object)item).name.Contains("Armor") || ((Object)item).name.Contains("Bow") || ((Object)item).name.Contains("Knife") || ((Object)item).name.Contains("Armor") || ((Object)item).name.Contains("Helmet") || ((Object)item).name.Contains("Axe") || ((Object)item).name.Contains("Spear") || ((Object)item).name.Contains("Atgeir") || ((Object)item).name.Contains("Nails") || ((Object)item).name.Contains("Shield") || ((Object)item).name.Contains("Meat");
		}

		public void editItems(List<GameObject> list)
		{
			GameObject val = FindItem(list, "Wood");
			Floating component = val.GetComponent<Floating>();
			foreach (GameObject item in list)
			{
				if ((Object)(object)item.GetComponent<Floating>() == (Object)null && addFloatTo.Contains(((Object)item).name))
				{
					Floating val2 = item.AddComponent<Floating>();
					val2.m_waterLevelOffset = component.m_waterLevelOffset;
					val2.m_forceDistance = component.m_forceDistance;
					val2.m_force = component.m_force;
					val2.m_balanceForceFraction = component.m_balanceForceFraction;
					val2.m_damping = component.m_damping;
				}
				if (!((Object)item).name.Contains("Arrow") && !((Object)item).name.Contains("Trophy"))
				{
					CheckStats(item);
				}
			}
			List<GameObject> list2 = list.FindAll((GameObject x) => ((Object)x).name.Contains("Arrow"));
			foreach (GameObject item2 in list2)
			{
				editStackAndWeight(item2, 0.05f, 500);
			}
			List<GameObject> list3 = list.FindAll((GameObject x) => ((Object)x).name.Contains("Trophy"));
			foreach (GameObject item3 in list3)
			{
				editStackAndWeight(item3, -1f, 50);
				eidtTrophyValue(item3);
			}
		}

		private void CheckStats(GameObject gameObject)
		{
			//IL_1ea7: Unknown result type (might be due to invalid IL or missing references)
			editLvevel(gameObject, 5, hasUpgrade: true);
			switch (((Object)gameObject).name)
			{
			case "Ironpit":
				editValueAndTeleport(gameObject, 75);
				break;
			case "QueensJam":
				editFoodStat(gameObject, 15, 45, 0, 1200, 3f);
				break;
			case "SizzlingBerryBroth":
				editFoodStat(gameObject, 30, 20, 80, 1600, 4f);
				break;
			case "CarrotSoup":
				editFoodStat(gameObject, 20, 40, 0, 1700, 3f);
				break;
			case "TurnipStew":
				editFoodStat(gameObject, 20, 60, 0, 1500, 2f);
				break;
			case "Turnip":
				gameObject.GetComponent<ItemDrop>().m_itemData.m_shared.m_itemType = (ItemType)2;
				editFoodStat(gameObject, 12, 38, 0, 800, 1f);
				break;
			case "BlackSoup":
				editFoodStat(gameObject, 50, 15, 15, 1200, 3f);
				break;
			case "FierySvinstew":
				editFoodStat(gameObject, 90, 30, 20, 1500, 6f);
				break;
			case "OnionSoup":
				editFoodStat(gameObject, 25, 65, 0, 1300, 1f);
				break;
			case "SerpentStew":
				editFoodStat(gameObject, 80, 30, 0, 1900, 4f);
				break;
			case "SwordTaunt_bal":
				addAttackStatusEffect(gameObject, "TauntAttack");
				break;
			case "StaffSkeleton":
				editSkeletonStaff(gameObject);
				break;
			case "RottenMeat":
				editFoodStat(gameObject, 15, 5, 0, 2400, -4f);
				editRemoveStatusEffect(gameObject);
				break;
			case "WitheredBone":
			case "GoblinTotem":
			case "AncientSeed":
			case "Bell":
			case "DvergrKey":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				break;
			case "RustyBrokenSword_bal":
				editValueAndTeleport(gameObject, 15);
				break;
			case "Moss_bal":
				editStackAndWeight(gameObject, 0.05f, 300);
				break;
			case "imp_fireball_attack":
				editSurtlingDamageStat(gameObject, 15);
				break;
			case "PickaxeBlackMetal":
				editTool(gameObject, 5);
				editLvevel(gameObject, 4);
				break;
			case "PickaxeIron":
				editTool(gameObject, 4);
				editLvevel(gameObject, 4);
				break;
			case "PickaxeBronze":
				editTool(gameObject, 3);
				editLvevel(gameObject, 4);
				break;
			case "PickaxeAntler":
				editTool(gameObject, 2);
				editLvevel(gameObject, 4);
				break;
			case "PickaxeStone":
				editTool(gameObject, 1);
				editLvevel(gameObject, 4);
				editPickaxeStone(gameObject, 70, "Flint Pickaxe");
				break;
			case "Hammer":
				editQualityValues(gameObject, 0f, 5, 1f, 0.01f);
				editDurability(gameObject, 300f, 150f, 1f);
				break;
			case "HammerIron":
				editQualityValues(gameObject, 0f, 5, 1f, 0.02f);
				editDurability(gameObject, 400f, 200f, 1f);
				break;
			case "HammerBlackmetal":
				editQualityValues(gameObject, 0f, 5, 1f, 0.03f);
				editDurability(gameObject, 500f, 250f, 1f);
				break;
			case "HammerDverger":
				editQualityValues(gameObject, 0f, 5, 1f, 0.04f);
				editDurability(gameObject, 600f, 300f, 1f);
				break;
			case "SpearElderbark":
				editSpiritDamageStat(gameObject, 5);
				break;
			case "BowSpineSnap":
				editSpiritDamageStat(gameObject, 10);
				break;
			case "KnifeCopper":
				editSpiritDamageStat(gameObject, 5);
				break;
			case "THSwordKrom":
				editSpiritDamageStat(gameObject, 10);
				editDurability(gameObject, 200f, 50f);
				editDefense(gameObject, 50f, 10f, 50f, 10f, 2f);
				editArmor(gameObject, 40f, 20f);
				break;
			case "Coins":
				editStackAndWeight(gameObject, 0.01f, 999);
				break;
			case "BoltBlackmetal":
			case "BoltBone":
			case "BoltCarapace":
			case "BoltIron":
				editStackAndWeight(gameObject, 0.1f, 666);
				break;
			case "Feathers":
				editStackAndWeight(gameObject, 0.01f, 999);
				break;
			case "LeatherScraps":
			case "ChickenEgg":
			case "LinenThread":
			case "BoneFragments":
				editStackAndWeight(gameObject, 0.1f, 200);
				break;
			case "Sap":
				editStackAndWeight(gameObject, 0.1f, 100);
				break;
			case "SurtlingCore":
				editStackAndWeight(gameObject, 3f, 100);
				break;
			case "Wood":
				editStackAndWeight(gameObject, 1.25f, 200);
				break;
			case "RoundLog":
			case "FineWood":
				editStackAndWeight(gameObject, 1.5f, 100);
				break;
			case "HardWood_bal":
				editStackAndWeight(gameObject, 1.75f, 100);
				break;
			case "Straw_bal":
				editStackAndWeight(gameObject, 0.05f, 500);
				break;
			case "YggdrasilWood":
			case "Stone":
			case "Obsidian":
			case "Flint":
			case "Gabro_bal":
			case "LimeStone_bal":
			case "BlackMarble":
				editStackAndWeight(gameObject, 1.75f, 150);
				break;
			case "MushroomBzerker":
			case "Darkbul_bal":
			case "MushroomIcecap_bal":
			case "MushroomInkcap_bal":
			case "GrayMushroom_bal":
			case "MushroomBlueNew_bal":
			case "MushroomBlue_bal":
			case "MushroomBlue":
			case "MushroomYellow":
			case "Mushroom":
			case "MushroomJotunPuffs":
				editStackAndWeight(gameObject, 0.1f, 100);
				break;
			case "Resin":
				editStackAndWeight(gameObject, 0.2f, 300);
				break;
			case "Ooze":
			case "Guck":
				editStackAndWeight(gameObject, 0.25f, 300);
				break;
			case "Tar":
				editStackAndWeight(gameObject, 1f, 300);
				break;
			case "Tin":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 5f, 50);
				break;
			case "TinOre":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 6f, 50);
				break;
			case "Copper":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 50);
				break;
			case "GoldOre_bal":
				editValueAndTeleport(gameObject, 75, teleportable: false);
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "CopperOre":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "CopperScrap":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 6f, 100);
				break;
			case "Bronze":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "BronzeScrap":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 100);
				break;
			case "Iron":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "IronScrap":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 100);
				break;
			case "IronOre":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "Nickel_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 50);
				break;
			case "NickelOre_bal":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "NickelScrap_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 6f, 100);
				break;
			case "SilverOre":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 7f, 50);
				break;
			case "SilverScrap_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 6f, 100);
				break;
			case "SilverPouch_bal":
				editValueAndTeleport(gameObject, 20);
				break;
			case "GoldBar_bal":
				editValueAndTeleport(gameObject, 150);
				break;
			case "Silver":
				editValueAndTeleport(gameObject, 30);
				editStackAndWeight(gameObject, 6f, 50);
				break;
			case "BlackMetal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "BlackMetalOre_bal":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "BlackMetalScrap":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 100);
				break;
			case "GoldScrap_bal":
				editValueAndTeleport(gameObject, 50);
				editStackAndWeight(gameObject, 5f, 100);
				break;
			case "FlametalScrap_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 100);
				break;
			case "BrassScrap_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 100);
				break;
			case "Flametal":
				editValueAndTeleport(gameObject, 0);
				editItemName(gameObject, "$tag_ifrytium_bal");
				editStackAndWeight(gameObject, 7f, 50);
				break;
			case "FlametalNew":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "FlametalOre":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editItemName(gameObject, "$tag_ifrytium_ore_bal");
				editStackAndWeight(gameObject, 8f, 50);
				break;
			case "FlametalOreNew":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 10f, 50);
				break;
			case "WhiteMetal_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "Electrum_bal":
				editValueAndTeleport(gameObject, 150);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "BellMetal_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "Ferroboron_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 10f, 50);
				break;
			case "DarkSteel_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "DarkIron_bal":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 10f, 50);
				break;
			case "BoraxCrysta_ball":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 6f, 50);
				break;
			case "MoltenSteel_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 11f, 50);
				break;
			case "TernarySilver_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 6f, 100);
				break;
			case "MoltenSteelScrap_bal":
			case "IfrytiumScrap_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 7f, 100);
				break;
			case "VineberrySeeds":
			case "FirCone":
			case "PineCone":
			case "OnionSeeds":
			case "BirchSeeds":
			case "BeechSeeds":
			case "Acorn":
			case "VineGreenSeeds":
			case "CarrotSeeds":
			case "TurnipSeeds":
			case "YggTreeSeed_bal":
			case "StrawSeeds_bal":
			case "RedwoodSeeds_bal":
			case "SwampTreeSeeds_bal":
			case "WaterLilySeeds_bal":
			case "WillowSeeds_bal":
			case "AcaiSeeds_bal":
			case "AppleSeeds_bal":
			case "BasicSeed_bal":
			case "CabbageSeeds_bal":
			case "CypressSeeds_bal":
			case "GarlicSeeds_bal":
			case "MapleSeeds_bal":
			case "PoplarSeeds_bal":
				editStackAndWeight(gameObject, 0.01f, 200);
				break;
			case "Cobalt_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 9f, 50);
				break;
			case "CobaltOre_bal":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 10f, 50);
				break;
			case "Frosteel_bal":
				editValueAndTeleport(gameObject, 0);
				editStackAndWeight(gameObject, 11f, 50);
				break;
			case "Coal":
				editStackAndWeight(gameObject, 1f, 200);
				break;
			case "DragonEgg":
				editValueAndTeleport(gameObject, 0, teleportable: false);
				editStackAndWeight(gameObject, 75f, 10);
				break;
			case "Honey":
				editStackAndWeight(gameObject, 0.2f, 100);
				break;
			case "Lingonberry_bal":
			case "Seaberries_bal":
			case "Cloudberry":
			case "Blueberries":
			case "Raspberry":
				editStackAndWeight(gameObject, 0.1f, 200);
				break;
			case "CryptKey":
				if (!Compatibility.IsLoaded())
				{
					editStackAndWeight(gameObject, 0.25f, 50);
				}
				break;
			case "WoodNails_bal":
				editStackAndWeight(gameObject, 0.01f, 999);
				break;
			case "IronNails":
				editStackAndWeight(gameObject, 0.2f, 666);
				break;
			case "CorruptedEitr_bal":
			case "EnrichedEitr_bal":
			case "Eitr":
				editStackAndWeight(gameObject, 1f, 100);
				editValueAndTeleport(gameObject, 0, teleportable: false);
				break;
			case "TinNails_bal":
			case "CopperNails_bal":
			case "BronzeNails":
			case "SilverNails_bal":
			case "GoldNails_bal":
			case "FlametalNails_bal":
			case "BlackMetalNails_bal":
			case "DarksteelNails_bal":
				editStackAndWeight(gameObject, 0.2f, 666);
				break;
			case "TrollMeat_bal":
			case "DrakeMeat_bal":
			case "FenringMeat_bal":
				editStackAndWeight(gameObject, 2f, 50);
				break;
			case "SharkMeat_bal":
			case "RawSteak_bal":
			case "SteakCooked_bal":
			case "GoatMeat_bal":
			case "BearMeat":
				editStackAndWeight(gameObject, 1.25f, 50);
				break;
			case "BugMeat":
			case "HareMeat":
				editStackAndWeight(gameObject, 1.25f, 50);
				break;
			case "WolfMeat":
				editStackAndWeight(gameObject, 1.25f, 50);
				break;
			case "DeerMeat":
				editStackAndWeight(gameObject, 1.25f, 50);
				break;
			case "RawMeat":
				editStackAndWeight(gameObject, 1.25f, 50);
				break;
			case "DrakeSkin_bal":
				editStackAndWeight(gameObject, 1f, 100);
				break;
			case "NeckSkin_bal":
				editStackAndWeight(gameObject, 0.5f, 100);
				break;
			case "BoarHide_bal":
			case "DeerHide":
				editStackAndWeight(gameObject, 0.75f, 100);
				break;
			case "TrollHide":
				editStackAndWeight(gameObject, 1.5f, 100);
				break;
			case "WolfPelt":
				editStackAndWeight(gameObject, 1f, 100);
				break;
			case "LoxPelt":
				editStackAndWeight(gameObject, 1.25f, 100);
				break;
			case "BoneMawSerpentMeat":
			case "SerpentMeat":
				editStackAndWeight(gameObject, 5f, 50);
				break;
			case "CookedBoneMawSerpentMeat":
			case "SerpentMeatCooked":
				editStackAndWeight(gameObject, 4f, 50);
				break;
			case "RawCrowMeat_bal":
			case "ChickenMeat":
				editStackAndWeight(gameObject, 1f, 50);
				break;
			case "CookedBearMeat":
				editStackAndWeight(gameObject, 1f, 50);
				break;
			case "TrollMeatCooked_bal":
			case "DrakeMeatCooked_bal":
			case "FenringMeatCooked_bal":
				editStackAndWeight(gameObject, 1.5f, 50);
				break;
			case "SharkMeatCooked_bal":
			case "GoatMeatCooked_bal":
			case "CookedBugMeat":
			case "CookedHareMeat":
				editStackAndWeight(gameObject, 1f, 50);
				break;
			case "CookedWolfMeat":
				editStackAndWeight(gameObject, 1f, 50);
				break;
			case "CookedDeerMeat":
				editStackAndWeight(gameObject, 1f, 50);
				break;
			case "CookedRawMeat":
				editStackAndWeight(gameObject, 1f, 50);
				break;
			case "CookedCrowMeat_bal":
			case "CookedChickenMeat":
				editStackAndWeight(gameObject, 0.75f, 50);
				break;
			}
		}

		private void addAttackStatusEffect(GameObject gameObject, string name)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_attackStatusEffect = ObjectDB.instance.GetStatusEffect(BalrondHashCompat.StableHash(name));
		}

		private void editSkeletonStaff(GameObject gameObject)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_attack.m_attackEitr = 44f;
		}

		private void editItemName(GameObject gameObject, string name)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_name = name;
		}

		private void editSpiritDamageStat(GameObject gameObject, int spiritDamage)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_damages.m_spirit = spiritDamage;
			if (((Object)gameObject).name == "skeleton_mace" || ((Object)gameObject).name == "imp_fireball_attack")
			{
				component.m_itemData.m_shared.m_damages.m_blunt += spiritDamage;
			}
		}

		private void editSurtlingDamageStat(GameObject gameObject, int fireDamage)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_damages.m_fire = fireDamage;
			component.m_itemData.m_shared.m_damages.m_blunt += fireDamage;
		}

		private void editTool(GameObject gameObject, int lvl)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_toolTier = lvl;
		}

		private void editLvevel(GameObject gameObject, int lvl, bool hasUpgrade = false)
		{
			if (hasUpgrade)
			{
				ItemDrop component = gameObject.GetComponent<ItemDrop>();
				if (component.m_itemData.m_shared.m_maxQuality > 1)
				{
					component.m_itemData.m_shared.m_maxQuality = lvl;
				}
			}
			else
			{
				ItemDrop component2 = gameObject.GetComponent<ItemDrop>();
				component2.m_itemData.m_shared.m_maxQuality = lvl;
			}
		}

		private void editPickaxeStone(GameObject gameObject, int durability, string name = "")
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_name = "Flint Pickaxe";
			component.m_itemData.m_shared.m_maxDurability = 70f;
			component.m_itemData.m_shared.m_weight = 4f;
		}

		private void addConsumeStatusEffect(GameObject gameObject, string statusName)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_consumeStatusEffect = ObjectDB.m_instance.m_StatusEffects.Find((StatusEffect x) => ((Object)x).name == statusName);
		}

		private void editRemoveStatusEffect(GameObject gameObject)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_consumeStatusEffect = null;
		}

		private void editFoodStat(GameObject gameObject, int hp = -99, int stam = -99, int eitr = -99, int time = -99, float regen = -99f)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_food = ((hp == -99) ? component.m_itemData.m_shared.m_food : ((float)hp));
			component.m_itemData.m_shared.m_foodStamina = ((stam == -99) ? component.m_itemData.m_shared.m_foodStamina : ((float)stam));
			component.m_itemData.m_shared.m_foodEitr = ((eitr == -99) ? component.m_itemData.m_shared.m_foodEitr : ((float)eitr));
			component.m_itemData.m_shared.m_foodRegen = ((regen == -99f) ? component.m_itemData.m_shared.m_foodRegen : regen);
			component.m_itemData.m_shared.m_foodBurnTime = ((time == -99) ? component.m_itemData.m_shared.m_foodBurnTime : ((float)time));
		}

		private void editStackAndWeight(GameObject gameObject, float weight = -1f, int stack = 1)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("missing itemdrop on:" + ((Object)gameObject).name));
				return;
			}
			component.m_itemData.m_shared.m_weight = ((weight == -1f) ? component.m_itemData.m_shared.m_weight : weight);
			component.m_itemData.m_shared.m_autoStack = true;
			component.m_itemData.m_shared.m_maxStackSize = stack;
		}

		private void editArmorSetEffect(GameObject gameObject, int setSize, string statusName, string setName)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_setName = setName;
			component.m_itemData.m_shared.m_setSize = setSize;
			component.m_itemData.m_shared.m_setStatusEffect = ObjectDB.instance.m_StatusEffects.Find((StatusEffect x) => ((Object)x).name == statusName);
		}

		private void editQualityValues(GameObject gameObject, float weightRatio = 0f, int quality = 4, float weight = -1f, float sppedDebuff = 0f, float equipeSpeed = -1f)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_weight = ((weight == -1f) ? ((float)component.m_itemData.m_shared.m_maxQuality) : weight);
			component.m_itemData.m_shared.m_scaleWeightByQuality = ((weightRatio == 0f) ? component.m_itemData.m_shared.m_scaleWeightByQuality : weightRatio);
			component.m_itemData.m_shared.m_equipDuration = ((equipeSpeed == -1f) ? component.m_itemData.m_shared.m_equipDuration : equipeSpeed);
			component.m_itemData.m_shared.m_movementModifier = sppedDebuff;
			component.m_itemData.m_shared.m_maxQuality = quality;
		}

		private void editDefense(GameObject gameObject, float blockPower = -1f, float blockPowerPerLevel = -1f, float deflectionForce = -1f, float deflectionForcePerLevel = 0f, float blockBonus = -1f)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_blockPower = ((blockPower == -1f) ? component.m_itemData.m_shared.m_blockPower : blockPower);
			component.m_itemData.m_shared.m_blockPowerPerLevel = ((blockPowerPerLevel == -1f) ? component.m_itemData.m_shared.m_blockPowerPerLevel : blockPowerPerLevel);
			component.m_itemData.m_shared.m_deflectionForce = ((deflectionForce == -1f) ? component.m_itemData.m_shared.m_deflectionForce : deflectionForce);
			component.m_itemData.m_shared.m_deflectionForcePerLevel = ((deflectionForcePerLevel == -1f) ? component.m_itemData.m_shared.m_deflectionForcePerLevel : deflectionForcePerLevel);
			component.m_itemData.m_shared.m_timedBlockBonus = ((blockBonus == -1f) ? component.m_itemData.m_shared.m_timedBlockBonus : blockBonus);
		}

		private void editArmor(GameObject gameObject, float armor = -1f, float armorPerLevel = -1f)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_armor = ((armor == -1f) ? component.m_itemData.m_shared.m_armor : armor);
			component.m_itemData.m_shared.m_armorPerLevel = ((armorPerLevel == -1f) ? component.m_itemData.m_shared.m_armorPerLevel : armorPerLevel);
		}

		private void editDurability(GameObject gameObject, float durability = -1f, float durabilityPerLevel = -1f, float useDrain = -1f)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_durability = ((durability == -1f) ? component.m_itemData.m_durability : durability);
			component.m_itemData.m_shared.m_durabilityPerLevel = ((durabilityPerLevel == -1f) ? component.m_itemData.m_shared.m_durabilityPerLevel : durabilityPerLevel);
			component.m_itemData.m_shared.m_useDurabilityDrain = ((useDrain == -1f) ? component.m_itemData.m_shared.m_useDurabilityDrain : useDrain);
		}

		private void editValueAndTeleport(GameObject gameObject, int newValue = -1, bool teleportable = true)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			int value = component.m_itemData.m_shared.m_value;
			component.m_itemData.m_shared.m_value = ((newValue != -1) ? newValue : value);
			component.m_itemData.m_shared.m_teleportable = teleportable;
		}

		private void eidtTrophyValue(GameObject gameObject)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			switch (((Object)gameObject).name)
			{
			case "TrophyKelpie_bal":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyAbomination":
				component.m_itemData.m_shared.m_value = 12;
				break;
			case "TrophyAbominationNew_bal":
				component.m_itemData.m_shared.m_value = 12;
				break;
			case "TrophyBearNew_bal":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyBlob":
				component.m_itemData.m_shared.m_value = 6;
				break;
			case "TrophyBoar":
				component.m_itemData.m_shared.m_value = 2;
				break;
			case "TrophyBonemass":
				component.m_itemData.m_shared.m_value = 60;
				break;
			case "TrophyCultist":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyDeathsquito":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyDeer":
				component.m_itemData.m_shared.m_value = 2;
				break;
			case "TrophyDevilWasp_bal":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyDragonQueen":
				component.m_itemData.m_shared.m_value = 80;
				break;
			case "TrophyDraugr":
				component.m_itemData.m_shared.m_value = 6;
				break;
			case "TrophyDraugrElite":
				component.m_itemData.m_shared.m_value = 8;
				break;
			case "TrophyDvergr":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyEikthyr":
				component.m_itemData.m_shared.m_value = 20;
				break;
			case "TrophyFenring":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyForsake_baln":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyFrostTroll":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyGjall":
				component.m_itemData.m_shared.m_value = 20;
				break;
			case "TrophyGoat_bal":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyGoblin":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyGoblinBrute":
				component.m_itemData.m_shared.m_value = 15;
				break;
			case "TrophyGoblinKing":
				component.m_itemData.m_shared.m_value = 100;
				break;
			case "TrophyGoblinShaman":
				component.m_itemData.m_shared.m_value = 15;
				break;
			case "TrophyGreydwarf":
				component.m_itemData.m_shared.m_value = 4;
				break;
			case "TrophyGreydwarfBrute":
				component.m_itemData.m_shared.m_value = 6;
				break;
			case "TrophyGreydwarfShaman":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyGreywatcher_bal":
				component.m_itemData.m_shared.m_value = 8;
				break;
			case "TrophyGrowth":
				component.m_itemData.m_shared.m_value = 8;
				break;
			case "TrophyHare":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyHatchling":
				component.m_itemData.m_shared.m_value = 9;
				break;
			case "TrophyHaugbui_bal":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyLeech":
				component.m_itemData.m_shared.m_value = 7;
				break;
			case "TrophyLox":
				component.m_itemData.m_shared.m_value = 9;
				break;
			case "TrophyNeck":
				component.m_itemData.m_shared.m_value = 2;
				break;
			case "TrophyNeckBrute":
				component.m_itemData.m_shared.m_value = 3;
				break;
			case "TrophyObsidianCrab_bal":
				component.m_itemData.m_shared.m_value = 6;
				break;
			case "TrophySeeker":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophySeekerBrute":
				component.m_itemData.m_shared.m_value = 15;
				break;
			case "TrophySeekerQueen":
				component.m_itemData.m_shared.m_value = 120;
				break;
			case "TrophySerpent":
				component.m_itemData.m_shared.m_value = 20;
				break;
			case "TrophySGolem":
				component.m_itemData.m_shared.m_value = 20;
				break;
			case "TrophyShark_bal":
				component.m_itemData.m_shared.m_value = 7;
				break;
			case "TrophySkeleton":
				component.m_itemData.m_shared.m_value = 4;
				break;
			case "TrophySkeletonPoison":
				component.m_itemData.m_shared.m_value = 6;
				break;
			case "TrophySouling":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophySpectre_bal":
				component.m_itemData.m_shared.m_value = 12;
				break;
			case "TrophyStormdrake_bal":
				component.m_itemData.m_shared.m_value = 11;
				break;
			case "TrophySurtling":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyTheElder":
				component.m_itemData.m_shared.m_value = 40;
				break;
			case "TrophyTick":
				component.m_itemData.m_shared.m_value = 4;
				break;
			case "TrophyUlv":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyVarsvin_bal":
				component.m_itemData.m_shared.m_value = 10;
				break;
			case "TrophyVarsvinBrute_bal":
				component.m_itemData.m_shared.m_value = 15;
				break;
			case "TrophyVarsvinHunter_bal":
				component.m_itemData.m_shared.m_value = 12;
				break;
			case "TrophyWolf":
				component.m_itemData.m_shared.m_value = 5;
				break;
			case "TrophyWraith":
				component.m_itemData.m_shared.m_value = 10;
				break;
			}
		}
	}
	public class RecipeFactory
	{
		private class RustedRecipeData
		{
			public string NameSuffix;

			public CraftingStation Station;

			public int StationLevel;

			public int Amount;

			public bool RequireOne = false;

			public List<Tuple<string, int>> Ingredients;
		}

		private class MincedMeatRecipeData
		{
			public string GroupName;

			public List<Tuple<string, int>> Ingredients;
		}

		private class CookedMeatRecipeData
		{
			public string ResultItemName;

			public int Amount;

			public int StationLevel;

			public List<Tuple<string, int>> Ingredients;
		}

		private class ScrapMetalRecipeData
		{
			public string MetalName;

			public string ScrapName;

			public int ScrapAmount;

			public int CoalAmount;

			public int CharredBoneAmount;

			public int EitrAmount;

			public CraftingStation Station;

			public int StationLevel = 1;
		}

		private class ShredLeatherRecipeData
		{
			public string RecipeName;

			public int StationLevel;

			public int OutputAmount;

			public List<Tuple<string, int>> Ingredients;
		}

		private List<GameObject> pieces;

		private List<GameObject> items;

		private List<GameObject> newItems;

		public List<Recipe> recipes = new List<Recipe>();

		private Dictionary<string, GameObject> _itemCache = new Dictionary<string, GameObject>();

		private readonly string[] toRecipe = new string[1] { "StrawBundle_bal" };

		public List<Recipe> createRecipes(List<GameObject> items, List<GameObject> newItems)
		{
			this.items = items;
			this.newItems = newItems;
			pieces = ObjectDB.instance.GetItemPrefab("Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
			TableMapper.setupTables(null, pieces);
			CraftingStation forge = TableMapper.forge;
			int minStationLevel = 3;
			foreach (GameObject newItem in newItems)
			{
				if (toRecipe.Contains(((Object)newItem).name))
				{
					Recipe val = ScriptableObject.CreateInstance<Recipe>();
					val.m_craftingStation = forge;
					val.m_repairStation = forge;
					val.m_minStationLevel = minStationLevel;
					val = createResources(newItem, val);
					recipes.Add(val);
				}
			}
			return recipes;
		}

		private void createTutorialInfoForRecipes()
		{
			string text = "";
			foreach (Recipe recipe in recipes)
			{
				string text2 = "\nName: " + ((Component)recipe.m_item).GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				string text3 = "\nAmount: " + recipe.m_amount + "x";
				string text4 = "\nCost: ";
				Requirement[] resources = recipe.m_resources;
				foreach (Requirement val in resources)
				{
					string name = ((Component)val.m_resItem).GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
					string text5 = val.m_amount + "x";
					string text6 = ((val.m_amountPerLevel > 0) ? (" / " + val.m_amountPerLevel + "x") : "");
					string text7 = "\n" + name + ":" + text5 + text6;
					text4 += text7;
				}
				string text8 = text2 + text3 + text4 + "\n";
				text += text8;
			}
			buildRecipeStationTutorialTag(text);
		}

		private void buildRecipeStationTutorialTag(string tutorialExtra, string tag = "workbench")
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			string text = "\n  <color=orange>BALROND AMAZING NATURE: </color>";
			TutorialText val = new TutorialText();
			val.m_name = "BAN Recipes";
			val.m_globalKeyTrigger = "AmazingNature Recipes";
			val.m_tutorialTrigger = tag;
			val.m_topic = "BAN-Recipes";
			val.m_label = "BAN-Recipes";
			val.m_isMunin = true;
			val.m_text = text + tutorialExtra;
			ConversionChanges.m_texts.Add(val);
		}

		private Recipe createCorruptedEitrRecipe()
		{
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			val.m_craftingStation = TableMapper.magetable;
			((Object)val).name = "Recipe_CorruptedEitr_bal";
			val.m_repairStation = val.m_craftingStation;
			val.m_enabled = true;
			val.m_amount = 5;
			val.m_minStationLevel = 1;
			val.m_item = FindItem("Eitr").GetComponent<ItemDrop>();
			List<Requirement> list = new List<Requirement>();
			list.Add(createReq("Thistle", 3, 0));
			list.Add(createReq("DragonTear", 1, 0));
			list.Add(createReq("CorruptedEitr_bal", 10, 0));
			val.m_resources = list.ToArray();
			recipes.Add(val);
			return val;
		}

		private Recipe createCorruptedSilverRecipe()
		{
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			val.m_craftingStation = TableMapper.artisian;
			((Object)val).name = "Recipe_CorruptedSilver_bal";
			val.m_repairStation = val.m_craftingStation;
			val.m_enabled = true;
			val.m_amount = 2;
			val.m_minStationLevel = 1;
			val.m_item = FindItem("Silver").GetComponent<ItemDrop>();
			List<Requirement> list = new List<Requirement>();
			list.Add(createReq("TernarySilver_bal", 2, 0));
			list.Add(createReq("SilverScrap_bal", 1, 0));
			val.m_resources = list.ToArray();
			recipes.Add(val);
			return val;
		}

		private void createRustedRecipes()
		{
			string[] array = new string[20]
			{
				"Eitr", "Lead_bal", "Nickel_bal", "Tin", "Iron", "Copper", "Silver", "Coins", "JuteRed", "JuteBlue",
				"DarksteelScrap_bal", "BrassScrap_bal", "Chain", "Stone", "Coal", "Bloodbag", "CarvedDeerSkull_bal", "CarvedWood_bal", "Ruby", "BeltStrength"
			};
			Dictionary<string, RustedRecipeData> dictionary = new Dictionary<string, RustedRecipeData>
			{
				{
					"BeltStrength",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_BeltStrength",
						Station = TableMapper.workbench,
						StationLevel = 2,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("DeerHide", 10),
							Tuple.Create("MeadStrength", 2),
							Tuple.Create("BellMetal_bal", 6),
							Tuple.Create("BjornHide", 6)
						}
					}
				},
				{
					"CarvedWood_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_CarvedWoodAlt",
						Station = TableMapper.heavyWorkbench,
						StationLevel = 1,
						Amount = 6,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("Wood", 7),
							Tuple.Create("Flint", 2)
						}
					}
				},
				{
					"CarvedDeerSkull_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_CarvedStagSkull",
						Station = TableMapper.workbench,
						StationLevel = 2,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("TrophyStag_bal", 1),
							Tuple.Create("LeatherScraps", 1),
							Tuple.Create("Raspberry", 1),
							Tuple.Create("Flint", 1)
						}
					}
				},
				{
					"Ruby",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_CrushedLimeStone",
						Station = TableMapper.artisian,
						StationLevel = 1,
						Amount = 1,
						RequireOne = false,
						Ingredients = new List<Tuple<string, int>> { Tuple.Create("GemChunks_bal", 7) }
					}
				},
				{
					"Coal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_CrushedCoalCoal",
						Station = TableMapper.workbench,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("CoalPowder_bal", 4),
							Tuple.Create("Resin", 1)
						}
					}
				},
				{
					"Stone",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_CrushedLimeStone",
						Station = TableMapper.stoneCutter,
						StationLevel = 1,
						Amount = 3,
						RequireOne = true,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("Gabro_bal", 2),
							Tuple.Create("LimeStone_bal", 2),
							Tuple.Create("Flint", 3)
						}
					}
				},
				{
					"Bloodbag",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_SmallSackBloodbag",
						Station = TableMapper.cauldron,
						StationLevel = 2,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("SmallBloodSack_bal", 5),
							Tuple.Create("WaterJug_bal", 1)
						}
					}
				},
				{
					"JuteRed",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_WovenJuteRed",
						Station = TableMapper.artisian,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("JuteThread_bal", 1),
							Tuple.Create("Wood", 1),
							Tuple.Create("WolfHairBundle", 1),
							Tuple.Create("Raspberry", 3)
						}
					}
				},
				{
					"JuteBlue",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_WovenJuteBlue",
						Station = TableMapper.artisian,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("JuteThread_bal", 1),
							Tuple.Create("WolfHairBundle", 1),
							Tuple.Create("Wood", 1),
							Tuple.Create("Blueberries", 3)
						}
					}
				},
				{
					"Eitr",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_BrokenEitr",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 4),
							Tuple.Create("Coal", 2)
						}
					}
				},
				{
					"Iron",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedIron",
						Station = TableMapper.smeltworks,
						StationLevel = 2,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 10),
							Tuple.Create("Coal", 8)
						}
					}
				},
				{
					"Lead_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedLead",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 4),
							Tuple.Create("Coal", 2)
						}
					}
				},
				{
					"Nickel_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedNickel",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 8),
							Tuple.Create("Coal", 7)
						}
					}
				},
				{
					"Zinc_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedZinc",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 6),
							Tuple.Create("Coal", 5)
						}
					}
				},
				{
					"Copper",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedCopper",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 5),
							Tuple.Create("Coal", 4)
						}
					}
				},
				{
					"Tin",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedTin",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 4),
							Tuple.Create("Coal", 3)
						}
					}
				},
				{
					"Coins",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_GoldCoinsCoins",
						Station = TableMapper.artisian,
						StationLevel = 1,
						Amount = 100,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("GoldBar_bal", 1),
							Tuple.Create("Coal", 3)
						}
					}
				},
				{
					"Chain",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_DarksteelChain",
						Station = TableMapper.ironworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("DarkSteel_bal", 2),
							Tuple.Create("Coal", 3)
						}
					}
				},
				{
					"Silver",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_SilverBarBogSilver",
						Station = TableMapper.smeltworks,
						StationLevel = 2,
						Amount = 2,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("TernarySilver_bal", 3),
							Tuple.Create("Coal", 6)
						}
					}
				},
				{
					"DarksteelScrap_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedBDarksteelScrap",
						Station = TableMapper.smeltworks,
						StationLevel = 2,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 11),
							Tuple.Create("Coal", 9)
						}
					}
				},
				{
					"BrassScrap_bal",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedBrassScrap",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 7),
							Tuple.Create("Coal", 6)
						}
					}
				},
				{
					"BronzeScrap",
					new RustedRecipeData
					{
						NameSuffix = "Recipe_RustedBronzeScrap",
						Station = TableMapper.smeltworks,
						StationLevel = 1,
						Amount = 1,
						Ingredients = new List<Tuple<string, int>>
						{
							Tuple.Create("RustedScrap_bal", 5),
							Tuple.Create("Coal", 4)
						}
					}
				}
			};
			string[] array2 = array;
			foreach (string text in array2)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(BalrondHashCompat.StableHash(text));
				if ((Object)(object)itemPrefab == (Object)null)
				{
					Debug.LogWarning((object)("Item not found: " + text));
					continue;
				}
				ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					Debug.LogWarning((object)("ItemDrop missing for: " + text));
					continue;
				}
				if (!dictionary.TryGetValue(text, out var value))
				{
					Debug.LogWarning((object)("No recipe data for item: " + text));
					continue;
				}
				Recipe val = ScriptableObject.CreateInstance<Recipe>();
				((Object)val).name = value.NameSuffix;
				val.m_item = component;
				val.m_enabled = true;
				val.m_amount = value.Amount;
				val.m_minStationLevel = value.StationLevel;
				val.m_craftingStation = value.Station;
				val.m_repairStation = value.Station;
				val.m_requireOnlyOneIngredient = value.RequireOne;
				List<Requirement> list = new List<Requirement>();
				for (int j = 0; j < value.Ingredients.Count; j++)
				{
					Tuple<string, int> tuple = value.Ingredients[j];
					Requirement val2 = createReq(tuple.Item1, tuple.Item2, 0);
					if (val2 != null)
					{
						list.Add(val2);
					}
				}
				val.m_resources = list.ToArray();
				recipes.Add(val);
			}
		}

		private void createMincedMeatRecipes()
		{
			List<MincedMeatRecipeData> list = new List<MincedMeatRecipeData>
			{
				new MincedMeatRecipeData
				{
					GroupName = "Animal",
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("RawMeat", 2),
						Tuple.Create("WolfMeat", 2),
						Tuple.Create("DeerMeat", 2),
						Tuple.Create("GoatMeat_bal", 2)
					}
				},
				new MincedMeatRecipeData
				{
					GroupName = "Lizard",
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("NeckTail", 2),
						Tuple.Create("AsksvinMeat", 2),
						Tuple.Create("DrakeMeat_bal", 2),
						Tuple.Create("LoxMeat", 2)
					}
				},
				new MincedMeatRecipeData
				{
					GroupName = "Bird",
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("RawCrowMeat_bal", 2),
						Tuple.Create("ChickenMeat", 2),
						Tuple.Create("VoltureMeat", 2),
						Tuple.Create("HareMeat", 2)
					}
				}
			};
			GameObject? obj = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == "MincedMeat_bal");
			ItemDrop val = ((obj != null) ? obj.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)"MincedMeat_bal not found in ObjectDB.");
				return;
			}
			foreach (MincedMeatRecipeData item in list)
			{
				Recipe val2 = ScriptableObject.CreateInstance<Recipe>();
				((Object)val2).name = "Recipe_ScrapForge" + item.GroupName;
				val2.m_item = val;
				val2.m_enabled = true;
				val2.m_amount = 5;
				val2.m_minStationLevel = 1;
				val2.m_craftingStation = TableMapper.foodtable;
				val2.m_repairStation = TableMapper.foodtable;
				List<Requirement> list2 = new List<Requirement>();
				for (int i = 0; i < item.Ingredients.Count; i++)
				{
					Tuple<string, int> tuple = item.Ingredients[i];
					Requirement val3 = createReq(tuple.Item1, tuple.Item2, 0);
					if (val3 != null)
					{
						list2.Add(val3);
					}
				}
				if (list2.Count > 0)
				{
					val2.m_resources = list2.ToArray();
					recipes.Add(val2);
				}
				else
				{
					Debug.LogWarning((object)("Skipped recipe due to missing ingredients: " + ((Object)val2).name));
				}
			}
		}

		private void createCookedMeatRecipes()
		{
			List<CookedMeatRecipeData> list = new List<CookedMeatRecipeData>
			{
				new CookedMeatRecipeData
				{
					ResultItemName = "SteakCooked_bal",
					Amount = 3,
					StationLevel = 1,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("RawSteak_bal", 3),
						Tuple.Create("WaterJug_bal", 1),
						Tuple.Create("Coal", 5)
					}
				},
				new CookedMeatRecipeData
				{
					ResultItemName = "FishCooked",
					Amount = 5,
					StationLevel = 1,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("FishRaw", 5),
						Tuple.Create("WaterJug_bal", 1),
						Tuple.Create("Coal", 5)
					}
				},
				new CookedMeatRecipeData
				{
					ResultItemName = "NeckTailGrilled",
					Amount = 5,
					StationLevel = 1,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("NeckTail", 5),
						Tuple.Create("WaterJug_bal", 1),
						Tuple.Create("Coal", 6)
					}
				},
				new CookedMeatRecipeData
				{
					ResultItemName = "CookedMeat",
					Amount = 4,
					StationLevel = 1,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("RawMeat", 4),
						Tuple.Create("WaterJug_bal", 1),
						Tuple.Create("Coal", 7)
					}
				},
				new CookedMeatRecipeData
				{
					ResultItemName = "CookedWolfMeat",
					Amount = 3,
					StationLevel = 2,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("WolfMeat", 3),
						Tuple.Create("Coal", 7)
					}
				},
				new CookedMeatRecipeData
				{
					ResultItemName = "CookedDeerMeat",
					Amount = 3,
					StationLevel = 1,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("DeerMeat", 3),
						Tuple.Create("WaterJug_bal", 1),
						Tuple.Create("Coal", 5)
					}
				},
				new CookedMeatRecipeData
				{
					ResultItemName = "GoatMeatCooked_bal",
					Amount = 2,
					StationLevel = 2,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("GoatMeat_bal", 2),
						Tuple.Create("WaterJug_bal", 1),
						Tuple.Create("Coal", 4)
					}
				}
			};
			foreach (CookedMeatRecipeData data in list)
			{
				GameObject val = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == data.ResultItemName);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Skipping invalid cooked meat item: " + data.ResultItemName));
					continue;
				}
				ItemDrop component = val.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					Debug.LogWarning((object)("ItemDrop missing on prefab: " + data.ResultItemName));
					continue;
				}
				Recipe val2 = ScriptableObject.CreateInstance<Recipe>();
				((Object)val2).name = "Recipe_Grill" + data.ResultItemName;
				val2.m_item = component;
				val2.m_enabled = true;
				val2.m_amount = data.Amount;
				val2.m_minStationLevel = data.StationLevel;
				val2.m_craftingStation = TableMapper.grill;
				val2.m_repairStation = TableMapper.grill;
				List<Requirement> list2 = new List<Requirement>();
				HashSet<ItemDrop> hashSet = new HashSet<ItemDrop>();
				foreach (Tuple<string, int> ingredient in data.Ingredients)
				{
					Requirement val3 = createReq(ingredient.Item1, ingredient.Item2, 0);
					if (val3 != null && hashSet.Add(val3.m_resItem))
					{
						list2.Add(val3);
					}
				}
				if (list2.Count > 0)
				{
					val2.m_resources = list2.ToArray();
					recipes.Add(val2);
				}
				else
				{
					Debug.LogWarning((object)("Recipe skipped due to missing requirements: " + ((Object)val2).name));
				}
			}
		}

		private List<ScrapMetalRecipeData> GetScrapMetalRecipes(bool isFiveVersion)
		{
			int num = ((!isFiveVersion) ? 1 : 5);
			CraftingStation smeltworks = TableMapper.smeltworks;
			return new List<ScrapMetalRecipeData>
			{
				new ScrapMetalRecipeData
				{
					MetalName = "Copper",
					ScrapName = "CopperScrap",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Zinc_bal",
					ScrapName = "ZincScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Bronze",
					ScrapName = "BronzeScrap",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Iron",
					ScrapName = "IronScrap",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Silver",
					ScrapName = "SilverScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "BlackMetal",
					ScrapName = "BlackMetalScrap",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "GoldBar_bal",
					ScrapName = "GoldScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Electrum_bal",
					ScrapName = "ElectrumScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 43),
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Tin",
					ScrapName = "TinScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Nickel_bal",
					ScrapName = "NickelScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "BellMetal_bal",
					ScrapName = "BrassScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "DarkSteel_bal",
					ScrapName = "DarksteelScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					Station = smeltworks,
					StationLevel = 1
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Amethysteel_bal",
					ScrapName = "AmethysteelScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					EitrAmount = ((!isFiveVersion) ? 1 : 2),
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Cobalt_bal",
					ScrapName = "CobaltScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Frosteel_bal",
					ScrapName = "FrosteelScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = 4 * num,
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "WhiteMetal_bal",
					ScrapName = "WhiteMetalScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Ferroboron_bal",
					ScrapName = "FerroboronScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "Flametal",
					ScrapName = "IfrytiumScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					CharredBoneAmount = 2 * num,
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "FlametalNew",
					ScrapName = "FlametalScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 12 : 3),
					CharredBoneAmount = 2 * num,
					Station = smeltworks,
					StationLevel = 2
				},
				new ScrapMetalRecipeData
				{
					MetalName = "MoltenSteel_bal",
					ScrapName = "MoltenSteelScrap_bal",
					ScrapAmount = 2 * num,
					CoalAmount = (isFiveVersion ? 13 : 3),
					CharredBoneAmount = 2 * num,
					Station = smeltworks,
					StationLevel = 2
				}
			};
		}

		private void CreateScrapMetalRecipes(bool isFiveVersion)
		{
			List<ScrapMetalRecipeData> scrapMetalRecipes = GetScrapMetalRecipes(isFiveVersion);
			int amount = ((!isFiveVersion) ? 1 : 5);
			foreach (ScrapMetalRecipeData data in scrapMetalRecipes)
			{
				GameObject val = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == data.MetalName);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				ItemDrop component = val.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null))
				{
					Recipe val2 = ScriptableObject.CreateInstance<Recipe>();
					((Object)val2).name = "Recipe_ScrapForge" + (isFiveVersion ? "5" : "") + data.MetalName;
					val2.m_item = component;
					val2.m_enabled = true;
					val2.m_amount = amount;
					val2.m_minStationLevel = data.StationLevel;
					val2.m_craftingStation = data.Station;
					val2.m_repairStation = data.Station;
					List<Requirement> list = new List<Requirement>();
					Requirement val3 = createReq(data.ScrapName, data.ScrapAmount, 0);
					Requirement val4 = createReq("Coal", data.CoalAmount, 0, CommonItemReferences.coal);
					if (val3 != null)
					{
						list.Add(val3);
					}
					if (val4 != null)
					{
						list.Add(val4);
					}
					if (data.CharredBoneAmount > 0)
					{
						list.Add(createReq("CharredBone", data.CharredBoneAmount, 0));
					}
					if (data.EitrAmount > 0)
					{
						list.Add(createReq("Eitr", data.EitrAmount, 0));
					}
					val2.m_resources = list.ToArray();
					recipes.Add(val2);
				}
			}
		}

		private void meatScraps1()
		{
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			val.m_item = items.Find((GameObject x) => ((Object)x).name == "MeatScrap_bal").GetComponent<ItemDrop>();
			((Object)val).name = "Recipe_ShredMeatA";
			val.m_craftingStation = TableMapper.workbench;
			val.m_repairStation = TableMapper.workbench;
			val.m_minStationLevel = 2;
			val.m_amount = 5;
			List<Requirement> list = new List<Requirement>();
			list.Add(createReq("NeckTail", 4, 0));
			list.Add(createReq("DeerMeat", 4, 0));
			list.Add(createReq("RawMeat", 4, 0));
			list.Add(createReq("WolfMeat", 3, 0));
			list.Add(createReq("GoatMeat_bal", 3, 0));
			list.Add(createReq("HareMeat", 3, 0));
			list.Add(createReq("AsksvinMeat", 2, 0));
			list.Add(createReq("DrakeMeat_bal", 2, 0));
			list.Add(createReq("LoxMeat", 2, 0));
			list.Add(createReq("RawSteak_bal", 3, 0));
			val.m_resources = list.ToArray();
			val.m_requireOnlyOneIngredient = true;
			recipes.Add(val);
		}

		private void shredLeatherRecipes()
		{
			List<ShredLeatherRecipeData> list = new List<ShredLeatherRecipeData>
			{
				new ShredLeatherRecipeData
				{
					RecipeName = "Recipe_ShredLeatherBalA",
					StationLevel = 2,
					OutputAmount = 5,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("NeckSkin_bal", 3),
						Tuple.Create("BoarHide_bal", 2),
						Tuple.Create("DeerHide", 2)
					}
				},
				new ShredLeatherRecipeData
				{
					RecipeName = "Recipe_ShredLeatherBalB",
					StationLevel = 2,
					OutputAmount = 6,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("WolfPelt", 2),
						Tuple.Create("ScaleHide", 2)
					}
				},
				new ShredLeatherRecipeData
				{
					RecipeName = "Recipe_ShredLeatherBalC",
					StationLevel = 2,
					OutputAmount = 7,
					Ingredients = new List<Tuple<string, int>>
					{
						Tuple.Create("TrollHide", 2),
						Tuple.Create("LoxPelt", 2),
						Tuple.Create("AskHide", 1)
					}
				}
			};
			GameObject? obj = items.Find((GameObject x) => ((Object)x).name == "LeatherScraps");
			ItemDrop val = ((obj != null) ? obj.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)"LeatherScraps item not found.");
				return;
			}
			foreach (ShredLeatherRecipeData item in list)
			{
				Recipe val2 = ScriptableObject.CreateInstance<Recipe>();
				((Object)val2).name = item.RecipeName;
				val2.m_item = val;
				val2.m_enabled = true;
				val2.m_craftingStation = TableMapper.workbench;
				val2.m_repairStation = TableMapper.workbench;
				val2.m_minStationLevel = item.StationLevel;
				val2.m_amount = item.OutputAmount;
				val2.m_requireOnlyOneIngredient = true;
				List<Requirement> list2 = new List<Requirement>();
				for (int i = 0; i < item.Ingredients.Count; i++)
				{
					Tuple<string, int> tuple = item.Ingredients[i];
					Requirement val3 = createReq(tuple.Item1, tuple.Item2, 0);
					if (val3 != null)
					{
						list2.Add(val3);
					}
				}
				val2.m_resources = list2.ToArray();
				recipes.Add(val2);
			}
		}

		private Recipe createResources(GameObject item, Recipe newRecipe)
		{
			((Object)newRecipe).name = "Recipe_" + ((Object)item).name;
			newRecipe.m_item = item.GetComponent<ItemDrop>();
			newRecipe.m_amount = 1;
			newRecipe.m_enabled = true;
			List<Requirement> list = new List<Requirement>();
			string name = ((Object)item).name;
			string text = name;
			if (text == "StrawBundle_bal")
			{
				newRecipe.m_amount = 1;
				newRecipe.m_craftingStation = TableMapper.workbench;
				newRecipe.m_minStationLevel = 1;
				list.Add(createReq("Straw_bal", 5, 0));
				list.Add(createReq("Moss_bal", 5, 0));
				newRecipe.m_resources = list.ToArray();
			}
			newRecipe.m_repairStation = newRecipe.m_craftingStation;
			if (list.Count == 0)
			{
			}
			newRecipe.m_resources = list.ToArray();
			return newRecipe;
		}

		private Requirement createReq(string name, int amount, int amountPerLevel, GameObject commonReference = null)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			object obj2;
			if (!((Object)(object)commonReference != (Object)null))
			{
				GameObject obj = FindItem(name);
				obj2 = ((obj != null) ? obj.GetComponent<ItemDrop>() : null);
			}
			else
			{
				obj2 = commonReference.GetComponent<ItemDrop>();
			}
			ItemDrop val = (ItemDrop)obj2;
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("createReq failed: ItemDrop missing for \"" + name + "\""));
				return null;
			}
			return new Requirement
			{
				m_resItem = val,
				m_amount = amount,
				m_amountPerLevel = amountPerLevel,
				m_recover = true
			};
		}

		private GameObject FindItem(string name)
		{
			if (_itemCache.TryGetValue(name, out var value))
			{
				return value;
			}
			GameObject val = ObjectDB.instance.GetItemPrefab(name);
			if ((Object)(object)val == (Object)null && newItems != null)
			{
				val = newItems.Find((GameObject x) => ((Object)x).name == name);
			}
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("FindItem: \"" + name + "\" not found, using fallback \"Wood\""));
				val = ObjectDB.instance.GetItemPrefab("Wood");
			}
			if ((Object)(object)val != (Object)null)
			{
				_itemCache[name] = val;
			}
			return val;
		}

		private Recipe AddRecipe(Recipe newRecipe, int amount, CraftingStation station, int stationLevel, List<Tuple<string, int, int>> ingredients)
		{
			newRecipe.m_craftingStation = station;
			newRecipe.m_minStationLevel = stationLevel;
			newRecipe.m_amount = amount;
			List<Requirement> list = new List<Requirement>();
			HashSet<ItemDrop> hashSet = new HashSet<ItemDrop>();
			foreach (Tuple<string, int, int> ingredient in ingredients)
			{
				Requirement val = createReq(ingredient.Item1, ingredient.Item2, ingredient.Item3);
				if (val == null)
				{
					Debug.LogWarning((object)("Requirement skipped: " + ingredient.Item1 + " is null or invalid."));
					continue;
				}
				if (hashSet.Contains(val.m_resItem))
				{
					Debug.LogWarning((object)("Duplicate ingredient skipped: " + ((Object)val.m_resItem).name));
					continue;
				}
				list.Add(val);
				hashSet.Add(val.m_resItem);
			}
			newRecipe.m_resources = list.ToArray();
			if (list.Count == 0)
			{
				Debug.LogWarning((object)("No valid requirements found for recipe: " + ((Object)newRecipe).name));
				return null;
			}
			return newRecipe;
		}
	}
	public class Resource
	{
		public int amount = 1;

		public int amountPerLevel = 0;

		public bool recovery = true;

		public ItemDrop itemDrop;

		public Requirement pieceConfig;

		public string item = "Wood";

		public Resource()
		{
		}

		public Resource(string item, int amount, int amountPerLevel = 0, bool recovery = true)
		{
			this.item = item;
			this.amount = amount;
			this.amountPerLevel = amountPerLevel;
			this.recovery = recovery;
		}

		public void setItemDrop(GameObject prefab)
		{
			if ((Object)(object)prefab.GetComponent<ItemDrop>() != (Object)null)
			{
				itemDrop = prefab.GetComponent<ItemDrop>();
			}
			else
			{
				Debug.LogWarning((object)("DVERGER FURNITURE: NO ITEM DROP FOUND on prefab name: " + ((Object)prefab).name));
			}
		}

		public Requirement getPieceConfig()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_003e: Expected O, but got Unknown
			Requirement val = new Requirement
			{
				m_resItem = itemDrop,
				m_amount = amount,
				m_amountPerLevel = amountPerLevel,
				m_recover = recovery
			};
			Requirement result = val;
			pieceConfig = val;
			return result;
		}
	}
	public class NatureGrowth
	{
		public void setupNewSaplings(ZNetScene zNetScene)
		{
			GameObject val = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "sapling_BirchAtumn_bal");
			GameObject item = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Birch1_aut");
			GameObject item2 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Birch2_aut");
			GameObject val2 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "sapling_Ygg_bal");
			GameObject item3 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "YggaShoot1");
			GameObject item4 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "YggaShoot2");
			GameObject item5 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "YggaShoot3");
			List<GameObject> list = new List<GameObject>();
			list.Add(item3);
			list.Add(item4);
			list.Add(item5);
			val2.GetComponent<Plant>().m_grownPrefabs = list.ToArray();
			GameObject val3 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "sapling_Ashtree2_bal");
			GameObject item6 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "AshlandsTree1");
			GameObject item7 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "AshlandsTree3");
			GameObject item8 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "AshlandsTree4");
			GameObject item9 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "AshlandsTree5");
			List<GameObject> list2 = new List<GameObject>();
			list2.Add(item6);
			list2.Add(item7);
			list2.Add(item8);
			list2.Add(item9);
			val3.GetComponent<Plant>().m_grownPrefabs = list2.ToArray();
			GameObject val4 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "sapling_Ashtree1_bal");
			Plant component = val4.GetComponent<Plant>();
			GameObject item10 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "AshlandsTree6");
			List<GameObject> list3 = new List<GameObject>();
			list3.Add(item10);
			component.m_grownPrefabs = list3.ToArray();
			GameObject val5 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "sapling_Swamp_bal");
			Plant component2 = val5.GetComponent<Plant>();
			GameObject item11 = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "SwampTree1");
			List<GameObject> list4 = new List<GameObject>();
			list4.Add(item11);
			component2.m_grownPrefabs = list4.ToArray();
			Plant component3 = val.GetComponent<Plant>();
			List<GameObject> list5 = new List<GameObject>();
			list5.Add(item);
			list5.Add(item2);
			component3.m_grownPrefabs = list5.ToArray();
		}
	}
	public class VegetationBuilder
	{
		public static List<ZoneVegetation> ZoneVegetations = new List<ZoneVegetation>();

		public static List<string> vegNames = new List<string>
		{
			"HeathRockPillar", "AshCrow", "MineRock_Obsidian", "MineRock_Tin", "ice1", "ice1_0", "FirTree", "FirTree_small", "Pinetree_01", "Pinetree",
			"Birch1", "Birch2", "Oak1", "Bush01", "Bush02_en", "rock4_coast", "SwampTree1", "SwampTree2", "Rock_7", "Rock_3",
			"rock1_mountain", "rock2_mountain", "rock3_mountain", "Dolmen01", "Dolmen02", "Dolmen03", "ShipSetting01", "Crow", "Pickable_BogIronOre", "YggdrasilRoot"
		};

		public Destructible fromRoot = null;

		private string[] exceptionList = new string[2] { "BirchAutStub_bal", "BlackberryBush2_bal" };

		public void createVegetationObjects(List<GameObject> vegetationList)
		{
			foreach (GameObject vegetation in vegetationList)
			{
				prepareVegetation(vegetation);
			}
		}

		public void editVege(List<ZoneVegetation> vegs)
		{
			foreach (string vegName in vegNames)
			{
				List<ZoneVegetation> list = vegs.FindAll((ZoneVegetation x) => ((Object)x.m_prefab).name == vegName);
				foreach (ZoneVegetation item in list)
				{
					if (item != null && (Object)(object)item.m_prefab.GetComponent<ZNetView>() != (Object)null)
					{
						EditVegetation(item);
					}
				}
			}
			string[] array = new string[6] { "FirTree_Sapling", "Oak_Sapling", "PineTree_Sapling", "Beech_Sapling", "Birch_Sapling", "Pickable_MountainCaveObsidian" };
			ZNetScene instance = ZNetScene.instance;
			if (instance == null || !(instance.m_namedPrefabs?.Count > 0))
			{
				return;
			}
			string[] array2 = array;
			foreach (string name in array2)
			{
				GameObject val = ZNetScene.instance?.m_prefabs.Find((GameObject x) => ((Object)x).name == name);
				if ((Object)(object)val != (Object)null)
				{
					CreateNewVegetationFromVanillaPrefab(val);
				}
			}
		}

		private void EditVegetation(ZoneVegetation veg)
		{
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0746: Unknown result type (might be due to invalid IL or missing references)
			//IL_0747: Unknown result type (might be due to invalid IL or missing references)
			//IL_0779: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d4: Unknown result type (might be due to invalid IL or missing references)
			switch (((Object)veg.m_prefab).name)
			{
			case "HeathRockPillar":
				veg.m_biome = (Biome)16;
				veg.m_groundOffset = -2.5f;
				break;
			case "MineRock_Obsidian":
				veg.m_biome = (Biome)612;
				veg.m_minAltitude = 50f;
				veg.m_maxAltitude = 1000f;
				veg.m_groundOffset = -0.5f;
				break;
			case "MineRock_Tin":
				veg.m_biome = (Biome)76;
				veg.m_minAltitude = -1.5f;
				veg.m_maxAltitude = 10f;
				veg.m_groundOffset = -0.75f;
				break;
			case "rock3_ice":
				veg.m_enable = true;
				veg.m_biome = (Biome)64;
				veg.m_min *= 1.25f;
				veg.m_max *= 1.25f;
				break;
			case "ice1":
			case "ice1_0":
				if (Object.op_Implicit((Object)(object)veg.m_prefab.GetComponent<DropOnDestroyed>()))
				{
					DropOnDestroyed val = veg.m_prefab.AddComponent<DropOnDestroyed>();
				}
				veg.m_biome = (Biome)68;
				veg.m_min *= 2f;
				veg.m_max *= 2f;
				veg.m_groupRadius = 100f;
				veg.m_groupSizeMax = 4;
				veg.m_groupSizeMin = 1;
				veg.m_scaleMin = 0.5f;
				veg.m_scaleMax = 2f;
				break;
			case "SwampTree2":
			case "SwampTree1":
				veg.m_min *= 0.75f;
				veg.m_max *= 0.75f;
				veg.m_enable = true;
				break;
			case "YggdrasilRoot":
			{
				ResourceRoot component = veg.m_prefab.GetComponent<ResourceRoot>();
				component.m_regenPerSec = 5f;
				break;
			}
			case "FirTree":
			case "FirTree_small":
			case "Pinetree_01":
			case "Pinetree":
			case "Birch1":
			case "Birch2":
				veg.m_min *= 0.75f;
				veg.m_max *= 0.75f;
				veg.m_enable = true;
				break;
			case "Pickable_BogIronOre":
				veg.m_enable = true;
				veg.m_biome = (Biome)534;
				break;
			case "Oak1":
				veg.m_min *= 1.5f;
				veg.m_max *= 1.5f;
				veg.m_groupSizeMin = 3;
				veg.m_groupSizeMax = 6;
				veg.m_minAltitude = 20f;
				veg.m_biome = (Biome)5;
				break;
			case "Bush01":
			case "Bush02_en":
				veg.m_biome = (Biome)(veg.m_biome | 4);
				break;
			case "Rock_3":
				veg.m_enable = true;
				veg.m_biome = (Biome)27;
				veg.m_minAltitude = -1f;
				veg.m_maxAltitude = 1000f;
				veg.m_groundOffset = -1f;
				veg.m_groupSizeMin = 1;
				veg.m_groupSizeMax = 1;
				veg.m_min = 1f;
				veg.m_max = 1f;
				veg.m_minOceanDepth = 0f;
				veg.m_maxOceanDepth = 3f;
				break;
			case "rock4_coast":
			case "Rock_7":
			case "rock1_mountain":
			case "rock2_mountain":
			case "rock3_mountain":
				veg.m_enable = true;
				veg.m_biome = (Biome)(veg.m_biome | 0x40);
				break;
			case "rock3_silver":
				veg.m_enable = true;
				veg.m_min = 0.01f;
				veg.m_max = 0.15f;
				veg.m_groundOffset = -2.5f;
				veg.m_biome = (Biome)64;
				break;
			case "Dolmen01":
			case "Dolmen02":
			case "Dolmen03":
			case "ShipSetting01":
				veg.m_enable = true;
				veg.m_biome = (Biome)64;
				break;
			}
		}

		private void CreateNewVegetationFromVanillaPrefab(GameObject obj)
		{
			switch (((Object)obj).name)
			{
			case "Pickable_Obsidian":
				setupVegetation(obj, 1f, 3f, 1, 2, 0f, 10f, 0f, 0f, 75f, 1000f, (Biome)100, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "Pickable_MountainCaveObsidian":
				setupVegetation(obj, 1f, 3f, 1, 2, 0f, 10f, 0f, 0f, 75f, 1000f, (Biome)36, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "Oak_Sapling":
				setupVegetation(obj, 1f, 1f, 1, 1, 0f, 10f, 0f, 5f, 0f, 1000f, (Biome)1, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "FirTree_Sapling":
			case "PineTree_Sapling":
				setupVegetation(obj, 1f, 1f, 1, 1, 0f, 10f, 0f, 5f, 0f, 1000f, (Biome)12, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "Birch_Sapling":
				setupVegetation(obj, 1f, 1f, 1, 1, 0f, 10f, 0f, 5f, 0f, 1000f, (Biome)1, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "Beech_Sapling":
				setupVegetation(obj, 1f, 1f, 1, 1, 0f, 10f, 0f, 5f, 0f, 1000f, (Biome)1, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			}
		}

		private void prepareVegetation(GameObject obj)
		{
			switch (((Object)obj).name)
			{
			case "coal_rock1_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -3f, 0f, 0f, 0f, 20f, 1000f, (Biome)528, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "coal_rock_nomoss_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -3.5f, 0f, 0f, 0f, 20f, 1000f, (Biome)96, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "gold_Rock_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -3.5f, 200f, 0f, 30f, -50f, 1000f, (Biome)96, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "ChitinDeposit_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 2, -1f, 50f, 0f, 0f, -5f, 10f, (Biome)578, isScaled: false, inForest: false, 33f, 33f, (BiomeArea)3);
				break;
			case "Poplar_bal":
				setupVegetation(obj, 0.75f, 1.5f, 4, 8, -2f, 100f, 0f, 5f, 0f, 1000f, (Biome)4, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "sapling_Poplar_bal":
				setupVegetation(obj, 0.5f, 0.75f, 3, 6, -2f, 100f, 0f, 5f, 50f, 1000f, (Biome)4, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "WetTree1_bal":
			case "WetTree2_bal":
			case "WetTree3_bal":
				setupVegetation(obj, 0.75f, 2f, 1, 1, 0f, 0f, 0f, 5f, -2f, 1000f, (Biome)2, isScaled: true, inForest: true, 15f, 15f, (BiomeArea)3);
				break;
			case "LinedSwampTreeLarge_bal":
			case "LinedSwampTreeLarge2_bal":
				setupVegetation(obj, 1f, 1f, 1, 1, 0f, 0f, 0f, 5f, 0f, 1000f, (Biome)2, isScaled: true, inForest: true, 11f, 22f, (BiomeArea)3);
				break;
			case "SeekerBroodSpawner_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -0.5f, 0f, 0f, 0f, 10f, 100f, (Biome)512, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "DeathsquitoHive_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -0.5f, 0f, 0f, 0f, -2f, 10f, (Biome)16, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_MeadowsMeatPile01_bal":
				setupVegetation(obj, 0.05f, 0.1f, 0, 1, 0f, 100f, 0f, 0f, -2f, 10000f, (Biome)11, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_MeadowsMeatPile02_bal":
				setupVegetation(obj, 0.05f, 0.1f, 0, 1, 0f, 100f, 0f, 0f, -2f, 10000f, (Biome)20, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "Pickable_Straw_bal":
				setupVegetation(obj, 2f, 6f, 2, 4, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)17, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "Pickable_Straw_DeepNorth_bal":
				setupVegetation(obj, 2f, 6f, 2, 4, -0.5f, 30f, 0f, 0f, 5f, 1000f, (Biome)66, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "Pickable_Mushroom_Inkcap_bal":
				setupVegetation(obj, 0.05f, 0.25f, 2, 4, 0f, 10f, 0f, 0f, 5f, 60f, (Biome)16, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "icePlate_bal":
			case "Pickable_Mushroom_Icecap_bal":
				setupVegetation(obj, 0.25f, 0.75f, 1, 3, 0f, 100f, 0f, 0f, 1f, 1000f, (Biome)64, isScaled: true, inForest: false, 0f, 0f, (BiomeArea)3);
				break;
			case "IceberryBush_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 3, 0f, 100f, 0f, 0f, 1f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 33f, (BiomeArea)3);
				break;
			case "BlackberryBush_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, 0f, 50f, 0f, 0f, 1f, 1000f, (Biome)10, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Lingonberry_shrub_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, 0f, 50f, 0f, 0f, 1f, 1000f, (Biome)68, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_SeedGarlic_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, 0f, 10f, 0f, 0f, 1f, 1000f, (Biome)16, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_SeedCabbage_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, 0f, 10f, 0f, 0f, 1f, 1000f, (Biome)4, isScaled: true, inForest: false, 33f, 33f, (BiomeArea)2);
				break;
			case "ElderMushroom_bal":
				setupVegetation(obj, 2f, 4f, 1, 2, -1f, 10f, 0f, 5f, 5f, 100f, (Biome)512, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "SeekerEgg_bal":
				setupVegetation(obj, 2f, 4f, 3, 9, -0.1f, 5f, 0f, 0f, 15f, 500f, (Biome)512, isScaled: true, inForest: true, 11f, 22f, (BiomeArea)3);
				break;
			case "AshlandsDryBush_bal":
				setupVegetation(obj, 1f, 3f, 1, 2, -0.25f, 10f, 0f, 5f, 10f, 1000f, (Biome)32, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "DryBush1_bal":
			case "DryBush2_bal":
				setupVegetation(obj, 1f, 3f, 1, 2, -0.25f, 10f, 0f, 5f, 0f, 1000f, (Biome)64, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "shrub_bal":
			case "BushDark_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.25f, 10f, 0f, 5f, 0f, 1000f, (Biome)522, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				setupVegetation(obj, 5f, 10f, 2, 4, -0.25f, 10f, 0f, 5f, 0f, 1000f, (Biome)64, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "sapling_Willow_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 1, 0f, 10f, 0f, 5f, -1f, 40f, (Biome)1, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "sapling_BirchAtumn_bal":
				setupVegetation(obj, 1f, 1f, 1, 3, 0f, 10f, 0f, 5f, 0f, 1000f, (Biome)16, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				break;
			case "Oak_Swamp_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, -1f, 0f, 0f, 5f, 0f, 1000f, (Biome)2, isScaled: true, inForest: true, 11f, 30f, (BiomeArea)3);
				setupVegetation(obj, 0.01f, 0.05f, 1, 2, -2.5f, 0f, 0f, 0f, 10f, 1000f, (Biome)68, isScaled: true, inForest: true, 33f, 66f, (BiomeArea)3);
				break;
			case "widestone_bal":
				setupVegetation(obj, 0.1f, 0.2f, 1, 2, -2.5f, 0f, 0f, 0f, 10f, 1000f, (Biome)68, isScaled: true, inForest: true, 33f, 66f, (BiomeArea)3);
				break;
			case "Willow_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, -1.5f, 50f, 0f, 5f, 0f, 40f, (Biome)1, isScaled: true, inForest: false, 11f, 22f, (BiomeArea)3);
				break;
			case "sapling_bushPlains2_bal":
			case "sapling_bushPlains_bal":
				setupVegetation(obj, 0.5f, 1f, 2, 4, -2f, 100f, 0f, 5f, 20f, 1000f, (Biome)16, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "sapling_bush_blackberry_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -2f, 100f, 0f, 5f, 20f, 1000f, (Biome)10, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "sapling_bush_blueberry_bal":
			case "sapling_bush_raspberry_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -2f, 100f, 0f, 5f, 20f, 1000f, (Biome)9, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "sapling_bush_bal":
				setupVegetation(obj, 0.5f, 1f, 2, 4, -2f, 100f, 0f, 5f, 20f, 1000f, (Biome)25, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "sapling_Swamp_bal":
				setupVegetation(obj, 0.25f, 0.5f, 2, 4, -2f, 100f, 0f, 5f, 20f, 1000f, (Biome)2, isScaled: true, inForest: true, 22f, 30f, (BiomeArea)3);
				break;
			case "HugeRoot1_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -1.5f, 100f, 0f, 0f, 2f, 1000f, (Biome)586, isScaled: true, inForest: true, 20f, 35f, (BiomeArea)3);
				break;
			case "FallenTreeDeepNorth_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -1.5f, 100f, 0f, 0f, -10f, 1000f, (Biome)64, isScaled: true, inForest: true, 20f, 35f, (BiomeArea)3);
				break;
			case "AncientSkullRock_bal":
				setupVegetation(obj, 0.01f, 0.03f, 1, 1, -1f, 100f, 0f, 0f, -1000f, 1000f, (Biome)626, isScaled: false, inForest: false, 75f, 90f, (BiomeArea)3);
				break;
			case "loxSkeleton_bal":
				setupVegetation(obj, 0.1f, 0.25f, 1, 1, -1.5f, 100f, 0f, 0f, -1000f, 20f, (Biome)86, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				setupVegetation(obj, 0.5f, 1f, 1, 3, -1f, 100f, 0f, 0f, -1000f, 20f, (Biome)80, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "WhaleSkull_bal":
			case "WhaleRibs_bal":
			case "WhaleSpine_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -2.5f, 500f, 0f, 0f, -1000f, 30f, (Biome)630, isScaled: false, inForest: false, 99f, 99f, (BiomeArea)3);
				break;
			case "MammothRibcage_bal":
			case "MammothSpine_bal":
			case "DragonRibcage_bal":
				setupVegetation(obj, 0.005f, 0.02f, 1, 1, -2f, 100f, 0f, 0f, -50f, 1000f, (Biome)630, isScaled: false, inForest: false, 75f, 90f, (BiomeArea)3);
				break;
			case "DrakeSpawner_bal":
				setupVegetation(obj, 0.05f, 0.1f, 0, 1, -0.5f, 50f, 0f, 0f, 20f, 1000f, (Biome)4, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "RockGolemSpawn_bal":
				setupVegetation(obj, 0.001f, 0.01f, 0, 1, -0.5f, 50f, 0f, 0f, 20f, 1000f, (Biome)4, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				setupVegetation(obj, 0.01f, 0.05f, 1, 1, -0.5f, 50f, 0f, 0f, 20f, 1000f, (Biome)64, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "SurtlingSpawner_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -0.5f, 50f, 0f, 0f, 15f, 1000f, (Biome)32, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "bloodshard_deposit_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -0.2f, 50f, 0f, 0f, -10f, 1000f, (Biome)32, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "MineRock_MeteoriteNew_bal":
				setupVegetation(obj, 0.1f, 0.1f, 1, 1, -0.5f, 50f, 0f, 0f, -10f, 1000f, (Biome)32, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "MineRock_Lead_bal":
				setupVegetation(obj, 0.75f, 1f, 1, 2, -1f, 50f, 0f, 0f, 25f, 1000f, (Biome)84, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "MineRock_Zinc_bal":
				setupVegetation(obj, 0.75f, 1f, 1, 2, -1f, 50f, 0f, 0f, 25f, 1000f, (Biome)589, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "rock_silver_small_bal":
				setupVegetation(obj, 0.75f, 1f, 1, 2, -3f, 80f, 0f, 0f, 75f, 1000f, (Biome)68, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "MineRock_DarkIron_bal":
				setupVegetation(obj, 0.75f, 1f, 1, 1, -1f, 80f, 0f, 0f, 0f, 1000f, (Biome)512, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "MineRock_Borax_bal":
				setupVegetation(obj, 0.75f, 1f, 1, 1, -0.5f, 80f, 0f, 0f, 5f, 1000f, (Biome)512, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "MineRock_Blackmetal_bal":
				setupVegetation(obj, 0.75f, 1f, 1, 1, -1f, 50f, 0f, 0f, 15f, 1000f, (Biome)528, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "flowstone_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -0.35f, 50f, 0f, 0f, 10f, 1000f, (Biome)18, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "flowstone_ice_bal":
				setupVegetation(obj, 0.25f, 0.75f, 1, 1, -0.5f, 50f, 0f, 0f, 10f, 1000f, (Biome)64, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "stalagmite_ice_bal":
				setupVegetation(obj, 0.25f, 0.5f, 2, 4, -1f, 50f, 0f, 0f, 10f, 1000f, (Biome)64, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "stalagmite_ash_bal":
				setupVegetation(obj, 0.25f, 0.5f, 2, 4, -1f, 50f, 0f, 0f, 10f, 1000f, (Biome)32, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "MineRock_Cobalt_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -0.25f, 50f, 0f, 0f, 10f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "MineRock_CoalSnow_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -1f, 50f, 0f, 0f, 30f, 1000f, (Biome)68, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "MineRock_Coal_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -1f, 50f, 0f, 0f, 40f, 1000f, (Biome)520, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -1f, 50f, 0f, 0f, 10f, 1000f, (Biome)34, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "MineRock_Nickel_bal":
				setupVegetation(obj, 0.1f, 0.25f, 1, 1, -3f, 50f, 0f, 0f, 40f, 1000f, (Biome)16, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				setupVegetation(obj, 0.1f, 0.2f, 1, 1, -3.5f, 50f, 0f, 0f, 40f, 1000f, (Biome)9, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				setupVegetation(obj, 0.1f, 0.2f, 1, 2, -3f, 50f, 0f, 0f, 60f, 1000f, (Biome)68, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "MineRock_Copper_bal":
				setupVegetation(obj, 0.1f, 0.25f, 1, 2, -1.25f, 50f, 0f, 0f, 20f, 1000f, (Biome)24, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				setupVegetation(obj, 0.5f, 0.75f, 1, 2, -2f, 50f, 0f, 0f, 20f, 1000f, (Biome)68, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "MineRock_IronSnow_bal":
				setupVegetation(obj, 0.1f, 0.25f, 1, 1, -4f, 50f, 0f, 0f, 66f, 1000f, (Biome)68, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "MineRock_IronNew_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -2.5f, 50f, 0f, 0f, 0f, 1000f, (Biome)2, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				setupVegetation(obj, 0.15f, 0.25f, 1, 1, -3f, 50f, 0f, 0f, 33f, 1000f, (Biome)16, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "FloatingDebris_bal":
				setupVegetation(obj, 0.05f, 0.05f, 1, 1, -1f, 100f, 0f, 0f, -1000f, -3f, (Biome)256, isScaled: false, inForest: false, 11f, 22f, (BiomeArea)2);
				break;
			case "rock_nickel_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 1, -4f, 100f, 0f, 0f, 45f, 1000f, (Biome)513, isScaled: true, inForest: false, 22f, 99f, (BiomeArea)3);
				break;
			case "rock_nickel_nomoss_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -4f, 100f, 0f, 0f, 45f, 1000f, (Biome)68, isScaled: true, inForest: false, 22f, 99f, (BiomeArea)3);
				break;
			case "iceLump_bal":
				setupVegetation(obj, 0.1f, 0.3f, 1, 3, -1f, 10f, 2f, 30f, -2f, -0.5f, (Biome)64, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "Pickable_TinNew_bal":
				setupVegetation(obj, 0.5f, 1f, 3, 6, -0.25f, 2f, 0f, 5f, -10f, 1000f, (Biome)68, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "Pickable_MeteoriteNew_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 3, -0.25f, 10f, 0f, 0f, -3f, 1000f, (Biome)32, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "Pickable_MagmaStone_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, -0.25f, 10f, 0f, 0f, -3f, 1000f, (Biome)32, isScaled: false, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "deposit_jotunfinger_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, 0f, 10f, 0f, 10f, 1f, 1000f, (Biome)64, isScaled: true, inForest: false, 15f, 33f, (BiomeArea)2);
				break;
			case "Pickable_MountainCaveCrystal_bal":
			case "caverockIce_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, 0f, 10f, 0f, 0f, 1f, 1000f, (Biome)64, isScaled: true, inForest: false, 5f, 15f, (BiomeArea)2);
				break;
			case "cliff_mistlands_Arch_bal":
				setupVegetation(obj, 0.05f, 0.25f, 1, 1, -1f, 10f, 0f, 0f, -500f, 1000f, (Biome)512, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)3);
				break;
			case "cliff_deepnorth_Arch_bal":
				setupVegetation(obj, 0.05f, 0.25f, 1, 3, -2f, 10f, 0f, 0f, -500f, 1000f, (Biome)64, isScaled: true, inForest: true, 5f, 15f, (BiomeArea)1);
				break;
			case "cliff_deepnorth_bal":
				setupVegetation(obj, 0.001f, 0.01f, 1, 1, -3f, 0f, 0f, 0f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)3);
				break;
			case "basaltCliff_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -2f, 0f, 0f, 0f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 66f, (BiomeArea)2);
				break;
			case "iceblock_rock_bal":
				setupVegetation(obj, 0.05f, 0.25f, 1, 1, -1f, 0f, 0f, 20f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 33f, (BiomeArea)2);
				break;
			case "rock2_ice_bal":
			case "rock3_ice_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -2f, 0f, 0f, 50f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)2);
				break;
			case "SnowyRockPillar_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 2, -2.5f, 0f, 0f, 50f, -500f, 1000f, (Biome)68, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)3);
				break;
			case "IceCliff1_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -3f, 0f, 0f, 50f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)3);
				break;
			case "IceCliff2_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -3f, 0f, 0f, 50f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)1);
				break;
			case "IceCliff3_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -3f, 0f, 0f, 50f, -500f, 1000f, (Biome)64, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)1);
				break;
			case "ClayDeposit_bal":
				setupVegetation(obj, 1.25f, 1.75f, 1, 2, -1f, 50f, 0f, 4f, -3.5f, 15f, (Biome)19, isScaled: true, inForest: false, 33f, 99f, (BiomeArea)3);
				break;
			case "cliff_deepnorth2_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -3.5f, 0f, 0f, 20f, -500f, 1000f, (Biome)64, isScaled: true, inForest: true, 11f, 33f, (BiomeArea)1);
				break;
			case "RockDolmenSnow_bal":
			case "RockDolmenSnow2_bal":
			case "RockDolmenSnow3_bal":
			case "RockDolmenSnow4_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 3, -0.25f, 0f, 0f, 0f, -500f, 1000f, (Biome)68, isScaled: true, inForest: true, 77f, 77f, (BiomeArea)3);
				break;
			case "AshRock1_bal":
			case "AshRockPillar_bal":
				setupVegetation(obj, 0.25f, 0.5f, 1, 2, -2f, 0f, 0f, 5f, -10f, 1000f, (Biome)32, isScaled: true, inForest: true, 0f, 90f, (BiomeArea)3);
				break;
			case "RockDolmenLava1_bal":
			case "RockDolmenLava2_bal":
			case "RockDolmenLava3_bal":
			case "RockDolmenLava4_bal":
				setupVegetation(obj, 2f, 4f, 1, 3, -0.25f, 0f, 0f, 30f, -50f, 1000f, (Biome)32, isScaled: true, inForest: true, 77f, 77f, (BiomeArea)3);
				break;
			case "RockDolmenIce1_bal":
			case "RockDolmenIce2_bal":
			case "RockDolmenIce3_bal":
			case "RockDolmenIce4_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, -0.25f, 0f, 0f, 30f, -50f, 1000f, (Biome)64, isScaled: true, inForest: true, 77f, 77f, (BiomeArea)3);
				break;
			case "RockDolmenAshlands_1_bal":
			case "RockDolmenAshlands_2_bal":
			case "RockDolmenAshlands_3_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, -0.25f, 0f, 0f, 30f, -50f, 1000f, (Biome)96, isScaled: true, inForest: true, 0f, 90f, (BiomeArea)3);
				break;
			case "cliff_deepnorth_rock_bal":
				setupVegetation(obj, 1f, 2f, 1, 1, -0.5f, 10f, 0f, 30f, -5f, 200f, (Biome)64, isScaled: true, inForest: true, 33f, 90f, (BiomeArea)3);
				break;
			case "cliff_mistlands_rock_bal":
				setupVegetation(obj, 1f, 2f, 1, 1, -0.5f, 10f, 0f, 30f, -5f, 200f, (Biome)512, isScaled: true, inForest: true, 0f, 90f, (BiomeArea)3);
				break;
			case "caverock_magma_stalagmite_broken_bal":
				setupVegetation(obj, 0.1f, 0.2f, 1, 3, -0.2f, 0f, 0f, 30f, -50f, 1000f, (Biome)32, isScaled: true, inForest: true, 0f, 90f, (BiomeArea)3);
				break;
			case "DragonSkull2_bal":
			case "DragonSkull_bal":
				setupVegetation(obj, 0.01f, 0.03f, 0, 1, -1.5f, 500f, 0f, 0f, -1000f, 1000f, (Biome)32, isScaled: true, inForest: true, 77f, 77f, (BiomeArea)3);
				break;
			case "MammothSkull_bal":
				setupVegetation(obj, 0.05f, 0.1f, 1, 1, -2f, 10f, 0f, 0f, -1000f, 1000f, (Biome)64, isScaled: true, inForest: true, 11f, 33f, (BiomeArea)3);
				break;
			case "rock_ashlands_bal":
				setupVegetation(obj, 1f, 2f, 1, 3, -0.25f, 0f, 0f, 30f, -50f, 1000f, (Biome)32, isScaled: true, inForest: true, 0f, 90f, (BiomeArea)3);
				break;
			case "Pickable_Mushroom_grayNew_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.05f, 90f, 0f, 0f, 25f, 1000f, (Biome)520, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Mushroom_blue_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.05f, 90f, 0f, 0f, 50f, 1000f, (Biome)4, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Mycelium_bal":
				setupVegetation(obj, 1f, 1f, 1, 1, -0.1f, 90f, 0f, 0f, -1f, 1000f, (Biome)2, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Mushroom_Darkbul_bal":
				setupVegetation(obj, 1.5f, 1.75f, 2, 3, -0.05f, 90f, 0f, 0f, -1f, 55f, (Biome)2, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Mushroom_blueNew_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.05f, 90f, 0f, 0f, 50f, 1000f, (Biome)4, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Nettle_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.5f, 90f, 0f, 0f, 15f, 1000f, (Biome)512, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Sage_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)8, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Lavender_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)16, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_RottenVegetable_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 1, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)542, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Mint_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)1, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Plantain_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, -0.5f, 90f, 0f, 0f, 0f, 1000f, (Biome)2, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Mugwort_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, -0.5f, 90f, 0f, 0f, -1f, 1000f, (Biome)2, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Seaberry_bal":
				setupVegetation(obj, 1f, 3f, 1, 2, -0.5f, 90f, 0f, 0f, 15f, 1000f, (Biome)512, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Bloodvine_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)32, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Snowleaf_bal":
				setupVegetation(obj, 1f, 2f, 1, 2, -0.5f, 90f, 0f, 0f, 5f, 1000f, (Biome)64, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_Ignicap_bal":
				setupVegetation(obj, 1f, 1.5f, 1, 2, 0f, 10f, 0f, 0f, 10f, 1000f, (Biome)32, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)2);
				break;
			case "Pickable_waterlily_bal":
				setupVegetation(obj, 0.5f, 1f, 1, 2, 0f, 10f, 1f, 5f, -50f, 1f, (Biome)531, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			case "Pickable_Kelp_bal":
				setupVegetation(obj, 1.25f, 1.75f, 1, 2, 0f, 10f, 3f, 5f, -50f, -4f, (Biome)562, isScaled: true, inForest: false, 0f, 90f, (BiomeArea)3);
				break;
			}
		}

		private void setupVegetation(GameObject obj, float min, float max, int groupMin, int groupMax, float groundOffset, float groupRadius, float minOcean, float maxOcean, float minAlt, float maxAlt, Biome biome = 1, bool isScaled = true, bool inForest = false, float randTilt = 0f, float maxTilt = 90f, BiomeArea area = 3, bool forceplacment = true)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			ZoneVegetation val = new ZoneVegetation();
			val.m_prefab = obj;
			val.m_name = ((Object)obj).name;
			val.m_enable = true;
			val.m_min = min;
			val.m_max = max;
			val.m_groundOffset = groundOffset;
			val.m_groupSizeMin = groupMin;
			val.m_groupSizeMax = groupMax;
			val.m_groupRadius = groupRadius;
			val.m_scaleMin = (isScaled ? 0.75f : 0.9f);
			val.m_scaleMax = (isScaled ? 1.5f : 1.1f);
			val.m_minOceanDepth = minOcean;
			val.m_maxOceanDepth = maxOcean;
			val.m_minAltitude = minAlt;
			val.m_maxAltitude = maxAlt;
			val.m_minTilt = 0f;
			val.m_maxTilt = maxTilt;
			val.m_randTilt = randTilt;
			if (maxTilt > 0f)
			{
				val.m_chanceToUseGroundTilt = 0.3f;
			}
			else
			{
				val.m_chanceToUseGroundTilt = 0f;
			}
			val.m_terrainDeltaRadius = 0f;
			val.m_minTerrainDelta = 0.1f;
			val.m_maxTerrainDelta = 2f;
			val.m_forestTresholdMin = (inForest ? 0 : 0);
			val.m_forestTresholdMax = (inForest ? 50 : 2);
			val.m_foldout = true;
			val.m_blockCheck = true;
			val.m_snapToWater = false;
			val.m_inForest = inForest;
			val.m_forcePlacement = forceplacment;
			val.m_surroundCheckDistance = 3f;
			val.m_surroundCheckVegetation = true;
			val.m_biome = biome;
			val.m_biomeArea = (BiomeArea)3;
			ZoneVegetations.Add(val);
		}

		public string PrepareVegetationName(string prefabName, string note)
		{
			return prefabName + "-" + note;
		}
	}
	public class VegetationDropFix
	{
		public List<GameObject> items;

		private readonly Dictionary<string, GameObject> _itemCache = new Dictionary<string, GameObject>();

		public void fixDrops(List<GameObject> list, ZNetScene zNetScene)
		{
			items = list;
			_itemCache.Clear();
			foreach (GameObject item in list)
			{
				Pickable component = item.GetComponent<Pickable>();
				if ((Object)(object)component != (Object)null)
				{
					fixPlant(component);
				}
				DropOnDestroyed component2 = item.GetComponent<DropOnDestroyed>();
				if ((Object)(object)component2 != (Object)null)
				{
					fixPDestructable(component2);
				}
				TreeLog component3 = item.GetComponent<TreeLog>();
				if ((Object)(object)component3 != (Object)null)
				{
					fixTreeLog(component3);
				}
				TreeBase component4 = item.GetComponent<TreeBase>();
				if ((Object)(object)component4 != (Object)null)
				{
					fixTreeBase(component4, zNetScene);
				}
				MineRock5 component5 = item.GetComponent<MineRock5>();
				if ((Object)(object)component5 != (Object)null)
				{
					fixMineRock5(component5);
				}
			}
		}

		private GameObject FindItem(List<GameObject> list, string name)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Debug.LogWarning((object)("BalrondPapayonPack: Item Not Found:" + name));
			return null;
		}

		public string editZnetName(string name)
		{
			name = name.Replace("(Clone)", "");
			int num = name.IndexOf("(");
			if (num >= 0)
			{
				name = name.Substring(0, num);
			}
			return name.Trim();
		}

		private void AddDrop(List<DropData> dropList, string itemName, int min, int max, float weight, bool dontScale = false)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (!_itemCache.TryGetValue(itemName, out var value))
			{
				value = FindItem(items, itemName);
				if ((Object)(object)value != (Object)null)
				{
					_itemCache[itemName] = value;
				}
			}
			if ((Object)(object)value != (Object)null)
			{
				dropList.Add(new DropData
				{
					m_item = value,
					m_stackMin = min,
					m_stackMax = max,
					m_weight = weight,
					m_dontScale = dontScale
				});
			}
		}

		private void AddDropsToList(List<DropData> dropList, params (string itemName, int min, int max, float weight, bool dontScale)[] drops)
		{
			for (int i = 0; i < drops.Length; i++)
			{
				var (itemName, min, max, weight, dontScale) = drops[i];
				AddDrop(dropList, itemName, min, max, weight, dontScale);
			}
		}

		private void AddDropToDropOnDestroyed(TreeLog treeLog, string itemName, int min, int max, float weight, bool dontScale = false)
		{
			AddDrop(treeLog.m_dropWhenDestroyed.m_drops, itemName, min, max, weight, dontScale);
		}

		private void InitDropOnDestroyed(TreeLog treeLog, int dropMin, int dropMax)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (!((Object)(object)treeLog == (Object)null))
			{
				if (treeLog.m_dropWhenDestroyed == null)
				{
					treeLog.m_dropWhenDestroyed = new DropTable();
				}
				if (treeLog.m_dropWhenDestroyed.m_drops == null)
				{
					treeLog.m_dropWhenDestroyed.m_drops = new List<DropData>();
				}
				treeLog.m_dropWhenDestroyed.m_oneOfEach = true;
				treeLog.m_dropWhenDestroyed.m_dropMin = dropMin;
				treeLog.m_dropWhenDestroyed.m_dropMax = dropMax;
				treeLog.m_dropWhenDestroyed.m_drops.Clear();
			}
		}

		private void AddDropToDropOnDestroyed(MineRock5 rock, string itemName, int min, int max, float weight, bool dontScale = false)
		{
			AddDrop(rock.m_dropItems.m_drops, itemName, min, max, weight, dontScale);
		}

		private void InitDropOnDestroyed(MineRock5 rock, int dropMin, int dropMax)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if ((Object)(object)rock == (Object)null)
			{
				Debug.LogWarning((object)"BalrondPapayonPack: MineRock5 is null");
				return;
			}
			if (rock.m_dropItems == null)
			{
				Debug.LogWarning((object)("BalrondPapayonPack: MineRock5.m_dropItems was null on " + ((Object)((Component)rock).gameObject).name));
				rock.m_dropItems = new DropTable();
			}
			if (rock.m_dropItems.m_drops == null)
			{
				Debug.LogWarning((object)("BalrondPapayonPack: MineRock5.m_dropItems.m_drops was null on " + ((Object)((Component)rock).gameObject).name));
				rock.m_dropItems.m_drops = new List<DropData>();
			}
			rock.m_dropItems.m_oneOfEach = true;
			rock.m_dropItems.m_dropMin = dropMin;
			rock.m_dropItems.m_dropMax = dropMax;
			rock.m_dropItems.m_drops.Clear();
		}

		private void AddGemDrops(MineRock5 minerock5)
		{
			AddDropToDropOnDestroyed(minerock5, "Amethyst_bal", 0, 1, 0.01f);
			AddDropToDropOnDestroyed(minerock5, "Sapphire_bal", 0, 1, 0.02f);
			AddDropToDropOnDestroyed(minerock5, "Emerald_bal", 0, 1, 0.03f);
			AddDropToDropOnDestroyed(minerock5, "Opal_bal", 0, 1, 0.04f);
			AddDropToDropOnDestroyed(minerock5, "Onyx_bal", 0, 1, 0.05f);
			AddDropToDropOnDestroyed(minerock5, "Ruby", 0, 1, 0.06f);
		}

		private void AddDropToPickable(Pickable pickable, string itemName, int min, int max, float weight, bool dontScale = false)
		{
			AddDrop(pickable.m_extraDrops.m_drops, itemName, min, max, weight, dontScale);
		}

		private void AddDropToDropOnDestroyed(DropOnDestroyed dropable, string itemName, int min, int max, float weight, bool dontScale = false)
		{
			AddDrop(dropable.m_dropWhenDestroyed.m_drops, itemName, min, max, weight, dontScale);
		}

		private void InitDropOnDestroyed(DropOnDestroyed dropable, int dropMin, int dropMax)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if ((Object)(object)dropable == (Object)null)
			{
				Debug.LogWarning((object)"BalrondPapayonPack: DropOnDestroyed is null");
				return;
			}
			if (dropable.m_dropWhenDestroyed == null)
			{
				Debug.LogWarning((object)("BalrondPapayonPack: DropOnDestroyed.m_dropWhenDestroyed was null on " + ((Object)((Component)dropable).gameObject).name));
				dropable.m_dropWhenDestroyed = new DropTable();
			}
			if (dropable.m_dropWhenDestroyed.m_drops == null)
			{
				Debug.LogWarning((object)("BalrondPapayonPack: DropOnDestroyed.m_dropWhenDestroyed.m_drops was null on " + ((Object)((Component)dropable).gameObject).name));
				dropable.m_dropWhenDestroyed.m_drops = new List<DropData>();
			}
			dropable.m_dropWhenDestroyed.m_oneOfEach = true;
			dropable.m_dropWhenDestroyed.m_dropMin = dropMin;
			dropable.m_dropWhenDestroyed.m_dropMax = dropMax;
			dropable.m_dropWhenDestroyed.m_drops.Clear();
		}

		private void AddGemDrops(DropOnDestroyed dropOnDestroyed)
		{
			AddDropToDropOnDestroyed(dropOnDestroyed, "Amethyst_bal", 0, 1, 0.01f);
			AddDropToDropOnDestroyed(dropOnDestroyed, "Sapphire_bal", 0, 1, 0.02f);
			AddDropToDropOnDestroyed(dropOnDestroyed, "Emerald_bal", 0, 1, 0.03f);
			AddDropToDropOnDestroyed(dropOnDestroyed, "Opal_bal", 0, 1, 0.04f);
			AddDropToDropOnDestroyed(dropOnDestroyed, "Onyx_bal", 0, 1, 0.05f);
			AddDropToDropOnDestroyed(dropOnDestroyed, "Ruby", 0, 1, 0.06f);
			AddDropToDropOnDestroyed(dropOnDestroyed, "GemChunks_bal", 0, 1, 0.07f);
		}

		private void AddDropToDropOnDestroyed(TreeBase treeBase, string itemName, int min, int max, float weight, bool dontScale = false)
		{
			AddDrop(treeBase.m_dropWhenDestroyed.m_drops, itemName, min, max, weight, dontScale);
		}

		private void InitDropOnDestroyed(TreeBase treeBase, int dropMin, int dropMax)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if ((Object)(object)treeBase == (Object)null)
			{
				Debug.LogWarning((object)"BalrondPapayonPack: TreeBase is null");
				return;
			}
			if (treeBase.m_dropWhenDestroyed == null)
			{
				Debug.LogWarning((object)("BalrondPapayonPack: TreeBase.m_dropWhenDestroyed was null on " + ((Object)((Component)treeBase).gameObject).name));
				treeBase.m_dropWhenDestroyed = new DropTable();
			}
			if (treeBase.m_dropWhenDestroyed.m_drops == null)
			{
				Debug.LogWarning((object)("BalrondPapayonPack: TreeBase.m_dropWhenDestroyed.m_drops was null on " + ((Object)((Component)treeBase).gameObject).name));
				treeBase.m_dropWhenDestroyed.m_drops = new List<DropData>();
			}
			treeBase.m_dropWhenDestroyed.m_oneOfEach = true;
			treeBase.m_dropWhenDestroyed.m_dropMin = dropMin;
			treeBase.m_dropWhenDestroyed.m_dropMax = dropMax;
			treeBase.m_dropWhenDestroyed.m_drops.Clear();
		}

		public void fixPlant(Pickable pickable)
		{
			switch (editZnetName(((Object)pickable).name))
			{
			case "Pickable_Mint_bal":
				pickable.m_itemPrefab = FindItem(items, "Mint_bal");
				break;
			case "Pickable_Sage_bal":
				pickable.m_itemPrefab = FindItem(items, "Sage_bal");
				break;
			case "Pickable_Mushroom_blue_bal":
				pickable.m_itemPrefab = FindItem(items, "MushroomBlue");
				break;
			case "Pickable_Lavender_bal":
				pickable.m_itemPrefab = FindItem(items, "Lavender_bal");
				break;
			case "BlueberryBush_bal":
				pickable.m_itemPrefab = FindItem(items, "Blueberries");
				break;
			case "RaspberryBush_bal":
				pickable.m_itemPrefab = FindItem(items, "Raspberry");
				break;
			case "Pickable_MountainCaveCrystal_bal":
				pickable.m_itemPrefab = FindItem(items, "Crystal");
				break;
			case "Pickable_Snowleaf_bal":
				pickable.m_itemPrefab = FindItem(items, "Snowleaf_bal");
				break;
			case "Pickable_AppleTree_bal":
				pickable.m_itemPrefab = FindItem(items, "Apple_bal");
				break;
			case "Pickable_Clay_bal":
				pickable.m_itemPrefab = FindItem(items, "Clay_bal");
				break;
			case "Pickable_Potato_bal":
				pickable.m_itemPrefab = FindItem(items, "Potato_bal");
				break;
			case "Pickable_Straw_DeepNorth_bal":
			case "Pickable_Straw_bal":
				pickable.m_itemPrefab = FindItem(items, "Straw_bal");
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_StrawPlant_bal":
				pickable.m_itemPrefab = FindItem(items, "Straw_bal");
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_Kelp_bal":
				pickable.m_itemPrefab = FindItem(items, "RedKelp_bal");
				break;
			case "Pickable_Mushroom_Darkbul_bal":
				pickable.m_itemPrefab = FindItem(items, "Darkbul_bal");
				break;
			case "Pickable_Nettle_bal":
				pickable.m_itemPrefab = FindItem(items, "Nettle_bal");
				break;
			case "Pickable_Plantain_bal":
				pickable.m_itemPrefab = FindItem(items, "Plantain_bal");
				break;
			case "Pickable_Mugwort_bal":
				pickable.m_itemPrefab = FindItem(items, "Mugwort_bal");
				break;
			case "Pickable_Seaberry_bal":
				pickable.m_itemPrefab = FindItem(items, "Seaberries_bal");
				break;
			case "Pickable_Yarrow_bal":
				pickable.m_itemPrefab = FindItem(items, "Yarrow_bal");
				break;
			case "Pickable_Bloodvine_bal":
				pickable.m_itemPrefab = FindItem(items, "Bloodfruit_bal");
				break;
			case "Pickable_MeteoriteNew_bal":
				pickable.m_itemPrefab = FindItem(items, "FlametalOre");
				break;
			case "Pickable_Mycelium_bal":
				pickable.m_itemPrefab = FindItem(items, "Mycelium_bal");
				break;
			case "Pickable_Ignicap_bal":
				pickable.m_itemPrefab = FindItem(items, "Ignicap_bal");
				break;
			case "Pickable_MagmaStone_bal":
				pickable.m_itemPrefab = FindItem(items, "MagmaStone_bal");
				break;
			case "Pickable_Lija_bal":
				pickable.m_itemPrefab = FindItem(items, "Lija_bal");
				break;
			case "Pickable_Mushroom_yellow_bal":
				pickable.m_itemPrefab = FindItem(items, "MushroomYellow");
				break;
			case "Pickable_Mushroom_grayNew_bal":
				pickable.m_itemPrefab = FindItem(items, "GrayMushroom_bal");
				break;
			case "Pickable_Mushroom_blueNew_bal":
				pickable.m_itemPrefab = FindItem(items, "MushroomBlue");
				break;
			case "Pickable_TinNew_bal":
				pickable.m_itemPrefab = FindItem(items, "TinOre");
				break;
			case "Lingonberry_shrub_bal":
				pickable.m_itemPrefab = FindItem(items, "Lingonberry_bal");
				break;
			case "BlackberryBush2_bal":
			case "BlackberryBush_bal":
				pickable.m_itemPrefab = FindItem(items, "Blackberries_bal");
				break;
			case "IceberryBush_bal":
				pickable.m_itemPrefab = FindItem(items, "Iceberry_bal");
				break;
			case "Pickable_Mushroom_yellowFarm_bal":
				pickable.m_itemPrefab = FindItem(items, "MushroomYellow");
				break;
			case "Pickable_Mushroom_blueFarm_bal":
				pickable.m_itemPrefab = FindItem(items, "MushroomBlue");
				break;
			case "Pickable_MushroomFarm_bal":
				pickable.m_itemPrefab = FindItem(items, "Mushroom");
				break;
			case "Pickable_Mushroom_grayFarm_bal":
				pickable.m_itemPrefab = FindItem(items, "GrayMushroom_bal");
				break;
			case "Pickable_DandelionFarm_bal":
				pickable.m_itemPrefab = FindItem(items, "Dandelion");
				break;
			case "Pickable_ThistleFarm_bal":
				pickable.m_itemPrefab = FindItem(items, "Thistle");
				break;
			case "BlueberryBush":
			case "Pickable_BlueberryBush_bal":
				pickable.m_itemPrefab = FindItem(items, "Blueberries");
				break;
			case "RaspberryBush":
			case "Pickable_RaspberryBush_bal":
				pickable.m_itemPrefab = FindItem(items, "Raspberry");
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_MeadowsMeatPile01_bal":
				pickable.m_itemPrefab = FindItem(items, "RottenMeat");
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_MeadowsMeatPile02_bal":
				pickable.m_itemPrefab = FindItem(items, "RottenMeat");
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_Mushroom_Random_bal":
				pickable.m_itemPrefab = FindItem(items, "Moss_bal");
				pickable.m_amount = 1;
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_SeedGarlic_bal":
				pickable.m_itemPrefab = FindItem(items, "GarlicSeeds_bal");
				pickable.m_amount = 2;
				makeAditionalDropForPickup(pickable);
				break;
			case "Pickable_Garlic_bal":
				pickable.m_amount = 1;
				pickable.m_itemPrefab = FindItem(items, "Garlic_bal");
				break;
			case "Pickable_SeedCabbage_bal":
				pickable.m_itemPrefab = FindItem(items, "CabbageSeeds_bal");
				makeAditionalDropForPickup(pickable);
				pickable.m_amount = 2;
				break;
			case "Pickable_Cabbage_bal":
				pickable.m_amount = 1;
				pickable.m_itemPrefab = FindItem(items, "Cabbage_bal");
				break;
			}
		}

		private void makeAditionalDropForPickup(Pickable pickable)
		{
			pickable.m_extraDrops.m_drops.Clear();
			addItemToPickable(pickable);
		}

		private void setPickableSeedSetup(Pickable pickable)
		{
			pickable.m_extraDrops.m_dropMin = 1;
			pickable.m_extraDrops.m_dropMax = 1;
			pickable.m_extraDrops.m_dropChance = 1f;
			pickable.m_extraDrops.m_oneOfEach = true;
			pickable.m_extraDrops.m_dropChance = 0.8f;
		}

		private void setPickablPlantSetup(Pickable pickable)
		{
			pickable.m_extraDrops.m_dropMin = 1;
			pickable.m_extraDrops.m_dropMax = 1;
			pickable.m_extraDrops.m_dropChance = 1f;
			pickable.m_extraDrops.m_oneOfEach = true;
		}

		private void addItemToPickable(Pickable pickable)
		{
			switch (editZnetName(((Object)pickable).name))
			{
			case "Pickable_Flax":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "Straw_bal", 1, 1, 0.2f);
				AddDropToPickable(pickable, "Flax", 1, 2, 0.8f);
				break;
			case "Pickable_Barley":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "Straw_bal", 1, 1, 0.2f);
				AddDropToPickable(pickable, "Barley", 1, 2, 0.8f);
				break;
			case "Pickable_Straw_DeepNorth_bal":
			case "Pickable_Straw_bal":
			case "Pickable_StrawPlant_bal":
				setPickablPlantSetup(pickable);
				pickable.m_extraDrops.m_dropChance = 0.75f;
				AddDropToPickable(pickable, "Straw_bal", 1, 1, 0.65f);
				break;
			case "Pickable_Mushroom_Random_bal":
				setPickablPlantSetup(pickable);
				AddDropToPickable(pickable, "MushroomBlue", 2, 3, 1f);
				AddDropToPickable(pickable, "MushroomYellow", 2, 3, 1f);
				AddDropToPickable(pickable, "Mushroom", 2, 3, 1f);
				break;
			case "Pickable_SeedCarrot":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "CarrotSeeds", 1, 2, 0.95f);
				break;
			case "Pickable_SeedTurnip":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "TurnipSeeds", 1, 2, 0.95f);
				break;
			case "Pickable_SeedOnion":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "OnionSeeds", 1, 2, 0.95f);
				break;
			case "Pickable_SeedCabbage_bal":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "CabbageSeeds_bal", 1, 2, 0.95f);
				break;
			case "Pickable_SeedGarlic_bal":
				setPickableSeedSetup(pickable);
				AddDropToPickable(pickable, "GarlicSeeds_bal", 1, 2, 0.95f);
				break;
			case "Pickable_Onion":
				setPickablPlantSetup(pickable);
				pickable.m_overrideName = "$item_onion";
				AddDropToPickable(pickable, "Onion", 1, 1, 0.95f);
				break;
			case "Pickable_Garlic_bal":
				setPickablPlantSetup(pickable);
				pickable.m_overrideName = "$tag_garlic_bal";
				AddDropToPickable(pickable, "Garlic_bal", 1, 1, 0.95f);
				break;
			case "Pickable_Carrot":
				setPickablPlantSetup(pickable);
				pickable.m_overrideName = "$item_carrot";
				AddDropToPickable(pickable, "Carrot", 1, 1, 0.95f);
				break;
			case "Pickable_Turnip":
				setPickablPlantSetup(pickable);
				pickable.m_overrideName = "$item_turnip";
				AddDropToPickable(pickable, "Turnip", 1, 1, 0.95f);
				break;
			case "Pickable_Cabbage_bal":
				setPickablPlantSetup(pickable);
				pickable.m_overrideName = "$tag_cabbage_bal";
				AddDropToPickable(pickable, "RottenVegetable_bal", 1, 1, 0.05f);
				AddDropToPickable(pickable, "Cabbage_bal", 1, 1, 0.95f);
				break;
			case "BlackberryBush_bal":
			case "BlackberryBush2_bal":
			case "BlueberryBush":
			case "RaspberryBush":
			case "Pickable_BlueberryBush_bal":
			case "Pickable_RaspberryBush_bal":
			case "RaspberryBush_bal":
			case "BlueberryBush_bal":
				pickable.m_extraDrops.m_dropMin = 1;
				pickable.m_extraDrops.m_dropMax = 1;
				pickable.m_extraDrops.m_dropChance = 0.5f;
				pickable.m_extraDrops.m_oneOfEach = true;
				AddDropToPickable(pickable, "Moss_bal", 1, 1, 0.3f);
				break;
			case "Pickable_MeadowsMeatPile01_bal":
				pickable.m_extraDrops.m_dropMin = 1;
				pickable.m_extraDrops.m_dropMax = 2;
				pickable.m_extraDrops.m_oneOfEach = true;
				AddDropToPickable(pickable, "DeerMeat", 1, 1, 0.1f);
				AddDropToPickable(pickable, "RawMeat", 1, 1, 0.12f);
				AddDropToPickable(pickable, "LeatherScraps", 1, 2, 0.25f);
				AddDropToPickable(pickable, "RottenMeat", 1, 1, 0.25f);
				AddDropToPickable(pickable, "Feathers", 1, 2, 0.3f);
				AddDropToPickable(pickable, "BoneFragments", 1, 2, 0.4f);
				break;
			case "Pickable_MeadowsMeatPile02_bal":
				pickable.m_extraDrops.m_dropMin = 1;
				pickable.m_extraDrops.m_dropMax = 3;
				pickable.m_extraDrops.m_oneOfEach = true;
				AddDropToPickable(pickable, "WolfMeat", 1, 1, 0.12f);
				AddDropToPickable(pickable, "WitheredBone", 1, 1, 0.14f);
				AddDropToPickable(pickable, "Bloodbag", 1, 1, 0.2f);
				AddDropToPickable(pickable, "Entrails", 1, 1, 0.22f);
				AddDropToPickable(pickable, "RottenMeat", 1, 2, 0.25f);
				AddDropToPickable(pickable, "RawMeat", 1, 1, 0.3f);
				AddDropToPickable(pickable, "BoneFragments", 1, 2, 0.32f);
				AddDropToPickable(pickable, "LeatherScraps", 1, 2, 0.34f);
				AddDropToPickable(pickable, "Feathers", 1, 2, 0.36f);
				AddDropToPickable(pickable, "Coins", 10, 30, 0.48f);
				break;
			}
		}

		public void fixPDestructable(DropOnDestroyed dropable = null)
		{
			if ((Object)(object)dropable == (Object)null)
			{
				return;
			}
			Destructible component = ((Component)dropable).GetComponent<Destructible>();
			switch (editZnetName(((Object)dropable).name))
			{
			case "SnowyRockPillar_bal":
				component.m_minToolTier = 2;
				break;
			case "coal_rock1_bal":
			case "coal_rock_nomoss_bal":
				component.m_minToolTier = 2;
				AddDropToDropOnDestroyed(dropable, "Coal", 2, 3, 1f);
				break;
			case "MineRock_Obsidian":
				component.m_minToolTier = 3;
				InitDropOnDestroyed(dropable, 1, 3);
				AddDropToDropOnDestroyed(dropable, "Coal", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 2, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 2, 1f);
				break;
			case "DryBush1_bal":
			case "DryBush2_bal":
			case "AshlandsDryBush_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Blackwood", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(dropable, "ElderBark", 1, 1, 0.35f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 2, 0.5f);
				break;
			case "stalagmite_ice_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 2, 0.35f);
				break;
			case "stalagmite_ash_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 1, 0.35f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.7f);
				break;
			case "flowstone_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Flint", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.65f);
				break;
			case "iceLump_bal":
				component.m_minToolTier = 3;
				dropable.m_dropWhenDestroyed.m_drops.Clear();
				break;
			case "flowstone_ice_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 2, 0.4f);
				break;
			case "BigShootStump_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "Sap", 1, 2, 0.3f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.45f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.75f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 2, 0.9f);
				break;
			case "Pickable_Lavender_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Lavender_bal", 1, 2, 1f);
				break;
			case "Pickable_Mint_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Mint_bal", 1, 2, 1f);
				break;
			case "Pickable_Sage_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Sage_bal", 1, 2, 1f);
				break;
			case "Pickable_MountainCaveCrystal_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 1, 0.4f);
				break;
			case "ice1":
				break;
			case "ice1_0":
				break;
			case "ShootStump":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "YggdrasilWood", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.45f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.75f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 0.9f);
				break;
			case "HugeRoot1_bal":
			case "HugeRoot1":
				InitDropOnDestroyed(dropable, 1, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "ElderBark", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(dropable, "RoundLog", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 0.8f);
				break;
			case "Pickable_Mushroom_grayNew_bal":
				break;
			case "GlowingMushroom":
				break;
			case "web_vertical_bal":
			case "web_horizontal_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "BoneFragments", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(dropable, "LeatherScraps", 1, 2, 0.3f);
				break;
			case "BlueberryBush_bal":
			case "BlueberryBush":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(dropable, "Straw_bal", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Blueberries", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 0.9f);
				break;
			case "RaspberryBush":
			case "RaspberryBush_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(dropable, "Straw_bal", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Raspberry", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 0.9f);
				break;
			case "BushDark_bal":
			case "Bush01_heath":
			case "Bush02_en":
			case "Bush01":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(dropable, "Straw_bal", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 0.6f);
				break;
			case "loxSkeleton_bal":
			case "WhaleSkeleton_bal":
			case "monsterSpine_bal":
			case "DragonRibcage_bal":
			case "MammothRibcage_bal":
			case "MammothSpine_bal":
			case "DragonSkull_bal":
			case "DragonSkull2_bal":
				InitDropOnDestroyed(dropable, 1, 3);
				AddDropToDropOnDestroyed(dropable, "WitheredBone", 1, 1, 0.05f);
				AddDropToDropOnDestroyed(dropable, "RottenMeat", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "LeatherScraps", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "BoneFragments", 2, 3, 0.6f);
				break;
			case "caverockIce_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 2, 0.25f);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 1, 0.9f);
				break;
			case "deposit_jotunfinger_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 3, 0.3f);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 2, 0.45f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.65f);
				break;
			case "caverock_magma_stalagmite_broken_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.9f);
				break;
			case "MineRock_MeteoriteNew_bal":
				component.m_minToolTier = 5;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 2, 0.1f);
				AddDropToDropOnDestroyed(dropable, "BlackMarble", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 3, 0.3f);
				AddDropToDropOnDestroyed(dropable, "FlametalOre", 1, 3, 0.6f);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 2, 0.8f);
				AddDropToDropOnDestroyed(dropable, "FlametalOre", 1, 1, 1f);
				break;
			case "RockDolmenIce1_bal":
			case "RockDolmenIce2_bal":
			case "RockDolmenIce3_bal":
			case "RockDolmenIce4_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 1, 0.2f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 3, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 2, 1f);
				break;
			case "RockDolmenSnow_bal":
			case "RockDolmenSnow2_bal":
			case "RockDolmenSnow3_bal":
			case "RockDolmenSnow4_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 1, 0.01f);
				AddDropToDropOnDestroyed(dropable, "SilverOre", 1, 1, 0.03f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.4f);
				break;
			case "RockDolmenLava1_bal":
			case "RockDolmenLava2_bal":
			case "RockDolmenLava3_bal":
			case "RockDolmenLava4_bal":
			case "RockDolmenAshlands_1_bal":
			case "RockDolmenAshlands_2_bal":
			case "RockDolmenAshlands_3_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Ruby", 1, 1, 0.01f);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "BlackMarble", 1, 2, 0.25f);
				AddDropToDropOnDestroyed(dropable, "Grausten", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 3, 0.9f);
				break;
			case "RockDolmen_1":
			case "RockDolmen_2":
			case "RockDolmen_3":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 3, 1f);
				break;
			case "rock2_heath":
			case "rock4_heath":
			{
				HoverText val = ((Component)component).GetComponent<HoverText>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)component).gameObject.AddComponent<HoverText>();
				}
				val.m_text = "$tag_limeStone_deposit_bal";
				((Component)component).GetComponent<HoverText>();
				component.m_minToolTier = 2;
				break;
			}
			case "rock1_mountain":
			case "rock4_coast":
			case "rock2_mountain":
			case "rock3_mountain":
			case "rock2_ice_bal":
			case "rock3_ice_bal":
			case "rock4_forest":
				component.m_minToolTier = 1;
				break;
			case "rock_silver_small_bal":
			case "silvervein":
			case "rock3_silver":
				component.m_minToolTier = 4;
				break;
			case "rock4_copper":
				component.m_minToolTier = 1;
				break;
			case "mudpile2":
			case "mudpile_beacon":
			case "mudpile":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "IronScrap", 1, 1, 1f);
				break;
			case "FallenTreeDeepNorth_bal":
				component.m_minToolTier = 3;
				InitDropOnDestroyed(dropable, 3, 6);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.2f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "cliff_mistlands_Arch_bal":
			case "cliff_mistlands_Arch_frac_bal":
			case "cliff_mistlands_rock_bal":
			case "cliff_mistlands_rock_frac_bal":
				component.m_minToolTier = 2;
				break;
			case "cliff_deepnorth_rock_bal":
			case "cliff_deepnorth_rock_frac_bal":
			case "cliff_deepnorth_bal":
			case "cliff_deepnorth_frac_bal":
			case "basaltCliff_bal1":
			case "iceblock_rock_bal":
			case "basaltCliff_frac_bal":
			case "iceblock_rock_frac_bal":
				component.m_minToolTier = 4;
				break;
			case "widestone_frac_bal":
				component.m_minToolTier = 1;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Flint", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 1, 0.9f);
				break;
			case "IceCliff1_bal":
			case "IceCliff2_bal":
			case "IceCliff3_bal":
			case "cliff_deepnorth2_bal":
			case "IceCliff1_frac_bal":
			case "IceCliff2_frac_bal":
			case "IceCliff3_frac_bal":
			case "cliff_deepnorth2_frac_bal":
				component.m_minToolTier = 3;
				break;
			case "MineRock_Lead_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "CopperOre", 1, 1, 0.08f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.8f);
				break;
			case "MineRock_Zinc_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "CopperOre", 1, 1, 0.08f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.8f);
				break;
			case "MineRock_Nickel_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "CopperOre", 1, 1, 0.08f);
				AddDropToDropOnDestroyed(dropable, "Coal", 1, 1, 0.09f);
				AddDropToDropOnDestroyed(dropable, "Stone", 2, 2, 0.8f);
				break;
			case "MineRock_Copper_bal":
				component.m_minToolTier = 1;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "Coal", 1, 1, 0.15f);
				AddDropToDropOnDestroyed(dropable, "CopperOre", 1, 1, 0.95f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 1f);
				break;
			case "MineRock_CoalSnow_bal":
			case "MineRock_Coal_bal":
				component.m_minToolTier = 1;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "Coal", 3, 5, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Coal", 2, 4, 1f);
				AddDropToDropOnDestroyed(dropable, "Flint", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 0.8f);
				break;
			case "MineRock_Tin":
				component.m_minToolTier = 1;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "TinOre", 1, 3, 0.9f);
				AddDropToDropOnDestroyed(dropable, "TinOre", 1, 1, 0.95f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 3, 1f);
				break;
			case "ClayDeposit_bal":
				component.m_minToolTier = 1;
				InitDropOnDestroyed(dropable, 3, 5);
				AddDropToDropOnDestroyed(dropable, "Flint", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 1, 0.2f);
				break;
			case "MineRock_Blackmetal_bal":
				component.m_minToolTier = 3;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 3, 0.4f);
				AddDropToDropOnDestroyed(dropable, "BlackMetalOre_bal", 1, 3, 0.9f);
				AddDropToDropOnDestroyed(dropable, "BlackMetalOre_bal", 1, 1, 0.95f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 1f);
				break;
			case "MineRock_Borax_bal":
				component.m_minToolTier = 4;
				InitDropOnDestroyed(dropable, 1, 3);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 3, 0.4f);
				AddDropToDropOnDestroyed(dropable, "BlackMarble", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(dropable, "BoraxCrystal_bal", 1, 1, 0.95f);
				break;
			case "MineRock_Cobalt_bal":
				component.m_minToolTier = 4;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(dropable, "Obsidian", 1, 3, 0.6f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 3, 1f);
				break;
			case "MineRock_IronSnow_bal":
			case "MineRock_IronNew_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "IronOre", 1, 3, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 1, 0.85f);
				AddDropToDropOnDestroyed(dropable, "IronOre", 2, 3, 0.95f);
				AddDropToDropOnDestroyed(dropable, "IronOre", 2, 3, 0.97f);
				break;
			case "AncientSkullRock_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 4);
				AddDropToDropOnDestroyed(dropable, "BoneFragments", 1, 3, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 2, 1f);
				break;
			case "ChitinDeposit_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Stone", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(dropable, "Chitin", 3, 6, 1f);
				break;
			case "ElderMushroom_Stub_bal":
				component.m_minToolTier = 4;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Bloodbag", 1, 1, 0.91f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.92f);
				AddDropToDropOnDestroyed(dropable, "Mushroom", 1, 1, 0.93f);
				AddDropToDropOnDestroyed(dropable, "BlackTissue_bal", 1, 1, 1f);
				break;
			case "IcedTree_Stub_bal":
				component.m_minToolTier = 4;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Crystal", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.52f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "WetTree_Stub_bal":
				component.m_minToolTier = 3;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(dropable, "ElderBark", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 2, 1f);
				break;
			case "AcaiTree_Stub_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "AshlandsTreeStump1":
			case "AshlandsTreeStump2":
			case "AshlandsTreeStump3":
				component.m_minToolTier = 3;
				break;
			case "Acai_Dead_Stub_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "Lingonberry_shrub_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(dropable, "Straw_bal", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Lingonberry_bal", 1, 2, 1f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "BlackberryBush_bal":
			case "BlackberryBush2_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(dropable, "Straw_bal", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(dropable, "Blackberries_bal", 1, 1, 1f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "Pickable_SeedGarlic_bal":
				InitDropOnDestroyed(dropable, 1, 2);
				AddDropToDropOnDestroyed(dropable, "GarlicSeeds_bal", 1, 2, 1f);
				break;
			case "Pickable_Garlic_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Garlic_bal", 1, 1, 1f);
				break;
			case "Pickable_Cabbage_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Cabbage_bal", 1, 1, 1f);
				break;
			case "Pickable_SeedCabbage_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "CabbageSeeds_bal", 1, 1, 1f);
				break;
			case "Pickable_Ignicap_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Ignicap_bal", 1, 1, 1f);
				break;
			case "Pickable_Bloodvine_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Bloodfruit_bal", 1, 1, 1f);
				break;
			case "Pickable_Mushroom_Darkbul_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Darkbul_bal", 1, 1, 1f);
				break;
			case "Pickable_Plantain_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Plantain_bal", 1, 1, 1f);
				break;
			case "Pickable_Mugwort_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Mugwort_bal", 1, 1, 1f);
				break;
			case "Pickable_Seaberry_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Seaberries_bal", 1, 1, 1f);
				break;
			case "Pickable_Yarrow_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Yarrow_bal", 1, 1, 1f);
				break;
			case "Pickable_StrawPlant_bal":
			case "Pickable_Straw_bal":
				InitDropOnDestroyed(dropable, 2, 2);
				AddDropToDropOnDestroyed(dropable, "Straw_bal", 2, 2, 1f);
				break;
			case "Pickable_Clay_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Clay_bal", 1, 1, 1f);
				break;
			case "Pickable_MagmaStone_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "MagmaStone_bal", 1, 1, 1f);
				break;
			case "Pickable_MeteoriteNew_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "FlametalOre", 1, 1, 1f);
				break;
			case "Pickable_TinNew_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "TinOre", 1, 1, 1f);
				break;
			case "Pickable_Kelp_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "RedKelp_bal", 1, 1, 1f);
				break;
			case "Pickable_Snowleaf_bal":
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Snowleaf_bal", 1, 1, 1f);
				break;
			case "root07":
			case "root08":
			case "root11":
			case "root12":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 1, 1);
				AddDropToDropOnDestroyed(dropable, "Acorn", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "BirchSeeds", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "BeechSeeds", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 3, 0.3f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 3, 0.8f);
				break;
			case "BirchAutStub_bal":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "BirchStub":
				component.m_minToolTier = 2;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			case "OakStub":
				component.m_minToolTier = 3;
				InitDropOnDestroyed(dropable, 2, 3);
				AddDropToDropOnDestroyed(dropable, "Root", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(dropable, "FineWood", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(dropable, "Moss_bal", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(dropable, "Wood", 1, 1, 1f);
				break;
			}
		}

		public void fixTreeBase(TreeBase treeBase, ZNetScene zNetScene)
		{
			switch (editZnetName(((Object)treeBase).name))
			{
			case "YggaBigShoot_bal":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "Sap", 1, 1, 0.05f);
				AddDropToDropOnDestroyed(treeBase, "AncientSeed", 1, 1, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.3f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "ElderMushroom_bal":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "Ooze", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Mushroom", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Guck", 1, 3, 1f);
				break;
			case "YggaShoot1":
			case "YggaShoot2":
			case "YggaShoot3":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "Sap", 1, 1, 0.05f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "AshlandsTree1_0":
			case "AshlandsTree3":
			case "AshlandsTree4":
			case "AshlandsTree5":
			case "AshlandsTree6_0":
			case "AshlandsTree6_big":
				treeBase.m_minToolTier = 3;
				break;
			case "IcedTree_bal":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 2, 1f);
				break;
			case "AcaiTree_New_bal":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "AcaiSeeds_bal", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "Willow_bal":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "WillowSeeds_bal", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "Poplar_bal":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "PoplarSeeds_bal", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "Cypress_bal":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 3);
				AddDropToDropOnDestroyed(treeBase, "CypressSeeds_bal", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "Maple_bal":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 3);
				AddDropToDropOnDestroyed(treeBase, "MapleSeeds_bal", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "Acai_Dead_bal":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 2, 1f);
				break;
			case "SwampTree1":
				treeBase.m_minToolTier = 2;
				InitDropOnDestroyed(treeBase, 1, 3);
				AddDropToDropOnDestroyed(treeBase, "SwampTreeSeeds_bal", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 1, 1f);
				break;
			case "Oak_Swamp_bal":
				treeBase.m_minToolTier = 3;
				treeBase.m_stubPrefab = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "OakStub");
				treeBase.m_logPrefab = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Oak_log");
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 1f);
				break;
			case "Oak3_bal":
				treeBase.m_minToolTier = 3;
				treeBase.m_stubPrefab = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "OakStub");
				treeBase.m_logPrefab = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "Oak_log");
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 1f);
				break;
			case "WetTree1_bal":
			case "WetTree2_bal":
			case "WetTree3_bal":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Wood", 1, 2, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.8f);
				AddDropToDropOnDestroyed(treeBase, "Moss_bal", 1, 2, 1f);
				break;
			case "Birch1_aut":
			case "Birch2_aut":
				treeBase.m_stubPrefab = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == "BirchAutStub_bal");
				break;
			case "Oak2_bal":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 2);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Acorn", 1, 2, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "Oak1":
				treeBase.m_health = 350f;
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 3);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Acorn", 1, 2, 0.5f);
				AddDropToDropOnDestroyed(treeBase, "Resin", 1, 3, 1f);
				break;
			case "ElderTree_bal":
				treeBase.m_minToolTier = 3;
				InitDropOnDestroyed(treeBase, 1, 3);
				AddDropToDropOnDestroyed(treeBase, "Guck", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "Feathers", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeBase, "ElderBark", 1, 1, 1f);
				break;
			}
		}

		public void fixMineRock5(MineRock5 minerock5)
		{
			switch (editZnetName(((Object)minerock5).name))
			{
			case "iceLump_frac_bal":
				minerock5.m_minToolTier = 2;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Crystal", 1, 1, 0.01f);
				break;
			case "SnowyRockPillar_frac_bal":
				minerock5.m_minToolTier = 1;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Crystal", 1, 1, 0.01f);
				AddDropToDropOnDestroyed(minerock5, "Flint", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 0.9f);
				break;
			case "rock2_ice_frac_bal":
			case "rock3_ice_frac_bal":
			case "ice_rock1_frac":
				minerock5.m_minToolTier = 1;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Crystal", 1, 1, 0.01f);
				AddDropToDropOnDestroyed(minerock5, "Flint", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 0.9f);
				break;
			case "rock_nickel_frac_bal":
				minerock5.m_minToolTier = 2;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Ruby", 0, 1, 0.01f);
				AddDropToDropOnDestroyed(minerock5, "Flint", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 1f);
				break;
			case "cliff_mistlands_rock_frac_bal":
			case "cliff_mistlands_Arch_frac_bal":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Obsidian", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(minerock5, "BlackMarble", 1, 1, 1f);
				break;
			case "cliff_deepnorth_rock_frac_bal":
			case "cliff_deepnorth_frac_bal":
			case "basaltCliff_frac_bal":
			case "iceblock_rock_frac_bal":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Crystal", 1, 1, 0.02f);
				AddDropToDropOnDestroyed(minerock5, "Obsidian", 1, 1, 0.9f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 0.9f);
				break;
			case "giant_helmet1_destruction":
			case "giant_helmet2_destruction":
			case "giant_sword1_destruction":
			case "giant_sword2_destruction":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "BlackMetalScrap", 1, 1, 0.3f);
				AddDropToDropOnDestroyed(minerock5, "IronScrap", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(minerock5, "BronzeScrap", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(minerock5, "CopperScrap", 1, 1, 0.6f);
				break;
			case "IceCliff1_frac_bal":
			case "IceCliff2_frac_bal":
			case "IceCliff3_frac_bal":
			case "cliff_deepnorth2_frac_bal":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Crystal", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(minerock5, "FreezeGland", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 0.9f);
				break;
			case "rock4_heath_frac":
			case "rock2_heath_frac":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Flint", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 0.8f);
				break;
			case "rock4_coast_frac":
			case "rock4_forest_frac":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Flint", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 1f);
				break;
			case "Rock_3_frac":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "Flint", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 1f);
				break;
			case "rock1_mountain_frac":
			case "rock2_mountain_frac":
			case "rock3_mountain_frac":
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "TinOre", 1, 1, 0.05f);
				AddDropToDropOnDestroyed(minerock5, "CopperOre", 1, 1, 0.05f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 0.75f);
				break;
			case "silvervein_frac":
			case "rock3_silver_frac":
				minerock5.m_minToolTier = 3;
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_oneOfEach = true;
				AddDropToDropOnDestroyed(minerock5, "TinOre", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(minerock5, "SilverOre", 1, 2, 0.8f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(minerock5, "SilverOre", 1, 1, 1f);
				break;
			case "blackmetal_rock_frac_bal":
				minerock5.m_minToolTier = 3;
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_oneOfEach = true;
				AddDropToDropOnDestroyed(minerock5, "IronOre", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(minerock5, "BlackMetalOre_bal", 1, 2, 0.7f);
				AddDropToDropOnDestroyed(minerock5, "Coal", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(minerock5, "BlackMetalOre_bal", 1, 1, 0.9f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 1f);
				break;
			case "AshRock1_frac_bal":
			case "AshRockPillar_frac_bal":
			case "rock_ashlands_frac_bal":
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_dropChance = 1f;
				AddDropToDropOnDestroyed(minerock5, "Grausten", 1, 3, 0.7f);
				AddDropToDropOnDestroyed(minerock5, "Coal", 3, 5, 0.85f);
				AddDropToDropOnDestroyed(minerock5, "BlackMarble", 1, 3, 0.7f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 3, 1f);
				break;
			case "coal_rock_nomoss_frac_bal":
				minerock5.m_dropItems.m_dropChance = 1f;
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_oneOfEach = true;
				AddDropToDropOnDestroyed(minerock5, "Obsidian", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(minerock5, "Coal", 3, 5, 0.85f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 0.95f);
				AddDropToDropOnDestroyed(minerock5, "Coal", 2, 4, 1f);
				break;
			case "coal_rock1_frac_bal":
				minerock5.m_minToolTier = 1;
				minerock5.m_dropItems.m_dropChance = 1f;
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_oneOfEach = true;
				AddDropToDropOnDestroyed(minerock5, "Obsidian", 1, 1, 0.25f);
				AddDropToDropOnDestroyed(minerock5, "Coal", 3, 5, 0.85f);
				AddDropToDropOnDestroyed(minerock5, "Coal", 2, 4, 0.85f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 1f);
				break;
			case "magma_Rock_frac_bal":
				minerock5.m_minToolTier = 2;
				minerock5.m_dropItems.m_dropChance = 1f;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "BlackMarble", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(minerock5, "Grausten", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 1f);
				break;
			case "gold_Rock_frac_bal":
				minerock5.m_minToolTier = 2;
				minerock5.m_dropItems.m_dropChance = 1f;
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_oneOfEach = true;
				AddDropToDropOnDestroyed(minerock5, "Coal", 1, 2, 0.95f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 1, 1f);
				break;
			case "rock_silver_small_frac_bal":
				minerock5.m_minToolTier = 3;
				minerock5.m_dropItems.m_dropChance = 1f;
				minerock5.m_dropItems.m_oneOfEach = true;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "SilverOre", 1, 2, 0.95f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 1f);
				break;
			case "rock4_copper_frac":
				minerock5.m_minToolTier = 1;
				InitDropOnDestroyed(minerock5, 1, 2);
				minerock5.m_dropItems.m_oneOfEach = true;
				AddDropToDropOnDestroyed(minerock5, "Coal", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(minerock5, "CopperOre", 1, 1, 0.9f);
				AddDropToDropOnDestroyed(minerock5, "Stone", 1, 2, 1f);
				break;
			case "mudpile2":
			case "mudpile_beacon":
			case "mudpile":
				minerock5.m_minToolTier = 2;
				break;
			case "mudpile2_frac":
			case "mudpile_frac":
				minerock5.m_minToolTier = 2;
				InitDropOnDestroyed(minerock5, 1, 2);
				AddDropToDropOnDestroyed(minerock5, "BoneFragments", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(minerock5, "IronScrap", 1, 2, 0.8f);
				AddDropToDropOnDestroyed(minerock5, "IronScrap", 1, 1, 0.9f);
				break;
			}
		}

		public void fixTreeLog(TreeLog treeLog)
		{
			switch (editZnetName(((Object)treeLog).name))
			{
			case "ElderMushroomCap_bal":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 1, 2);
				AddDropToDropOnDestroyed(treeLog, "BlackTissue_bal", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(treeLog, "Guck", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Sap", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "Ooze", 1, 1, 0.8f);
				break;
			case "bigyggashoot_log_bal":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 1, 2);
				AddDropToDropOnDestroyed(treeLog, "BlackTissue_bal", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(treeLog, "Guck", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Sap", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "Ooze", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 1, 1f);
				break;
			case "bigyggashoot_log_half_bal":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 2, 4);
				AddDropToDropOnDestroyed(treeLog, "BlackTissue_bal", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(treeLog, "Ooze", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "Guck", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Sap", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 1, 1f);
				break;
			case "bigyggashoot_log_quarter_bal":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 6, 6);
				AddDropToDropOnDestroyed(treeLog, "BlackTissue_bal", 1, 1, 0.1f);
				AddDropToDropOnDestroyed(treeLog, "Ooze", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "Guck", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Sap", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 1, 1f);
				break;
			case "ElderMushroomLog_bal":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 6, 6);
				AddDropToDropOnDestroyed(treeLog, "Mushroom", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Bloodbag", 1, 1, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 1, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "Ooze", 1, 1, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "BlackTissue_bal", 1, 1, 1f);
				break;
			case "yggashoot_log":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 1, 2);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(treeLog, "YggdrasilWood", 1, 2, 1f);
				break;
			case "yggashoot_log_half":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 9, 9);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.9f);
				AddDropToDropOnDestroyed(treeLog, "YggdrasilWood", 1, 2, 1f);
				break;
			case "AshlandsTreeLog1":
			case "AshlandsTreeLog2":
			case "AshlandsTreeLogHalf1":
			case "AshlandsTreeLogHalf2":
				treeLog.m_minToolTier = 3;
				break;
			case "IcedTree_log_bal":
				treeLog.m_minToolTier = 4;
				InitDropOnDestroyed(treeLog, 9, 10);
				AddDropToDropOnDestroyed(treeLog, "Blackwood", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "Crystal", 1, 2, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 1f);
				break;
			case "Acai_log_bal":
				treeLog.m_minToolTier = 2;
				InitDropOnDestroyed(treeLog, 1, 2);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 2, 1f);
				break;
			case "Maple_log_bal":
				treeLog.m_minToolTier = 2;
				InitDropOnDestroyed(treeLog, 7, 8);
				AddDropToDropOnDestroyed(treeLog, "Resin", 4, 8, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.7f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 2, 0.9f);
				break;
			case "Cypress_log_bal":
				treeLog.m_minToolTier = 2;
				InitDropOnDestroyed(treeLog, 7, 8);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "RoundLog", 1, 2, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 2, 1f);
				break;
			case "Poplar_log_bal":
				treeLog.m_minToolTier = 2;
				InitDropOnDestroyed(treeLog, 8, 9);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 2, 1f);
				break;
			case "Willow_log_bal":
				treeLog.m_minToolTier = 2;
				InitDropOnDestroyed(treeLog, 7, 8);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 1, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 1, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 2, 1f);
				break;
			case "Acai_log_half_bal":
				treeLog.m_minToolTier = 2;
				InitDropOnDestroyed(treeLog, 7, 8);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 2, 0.5f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 2, 1f);
				break;
			case "Wet_log_bal":
				treeLog.m_minToolTier = 3;
				InitDropOnDestroyed(treeLog, 1, 1);
				AddDropToDropOnDestroyed(treeLog, "ElderBark", 1, 2, 0.2f);
				AddDropToDropOnDestroyed(treeLog, "RoundLog", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 3, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 3, 1f);
				break;
			case "Wet_log_half_bal":
				treeLog.m_minToolTier = 3;
				InitDropOnDestroyed(treeLog, 5, 6);
				AddDropToDropOnDestroyed(treeLog, "ElderBark", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeLog, "RoundLog", 1, 2, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 1, 2, 0.8f);
				AddDropToDropOnDestroyed(treeLog, "Wood", 1, 3, 1f);
				break;
			case "YewTreeLog_bal":
				treeLog.m_minToolTier = 3;
				InitDropOnDestroyed(treeLog, 7, 8);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeLog, "ElderBark", 1, 3, 0.3f);
				AddDropToDropOnDestroyed(treeLog, "RoundLog", 2, 4, 0.6f);
				AddDropToDropOnDestroyed(treeLog, "Moss_bal", 2, 4, 0.8f);
				break;
			case "Oak2_log_bal":
			case "Oak_log":
				treeLog.m_minToolTier = 3;
				InitDropOnDestroyed(treeLog, 1, 2);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 1, 3, 0.2f);
				AddDropToDropOnDestroyed(treeLog, "RoundLog", 2, 4, 0.4f);
				break;
			case "Oak2_log_half_bal":
			case "Oak_log_half":
				treeLog.m_minToolTier = 3;
				InitDropOnDestroyed(treeLog, 7, 8);
				AddDropToDropOnDestroyed(treeLog, "Wood", 2, 4, 0.3f);
				AddDropToDropOnDestroyed(treeLog, "RoundLog", 1, 3, 0.4f);
				AddDropToDropOnDestroyed(treeLog, "FineWood", 2, 4, 0.5f);
				break;
			}
		}
	}
	public class VendorBuilder
	{
		private List<GameObject> _prefabs;

		public void EditVendors(List<GameObject> prefabList)
		{
			_prefabs = prefabList;
			EditTrader("Haldor", GetHaldorItems());
			EditTrader("Hildir", GetHildirItems());
			EditTrader("BogWitch", GetBogwitchItems());
		}

		private void EditTrader(string traderName, List<TradeItem> itemsToAdd)
		{
			GameObject val = _prefabs.Find((GameObject x) => ((Object)x).name == traderName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("Trader '" + traderName + "' not found."));
				return;
			}
			Trader component = val.GetComponent<Trader>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("Trader component missing on '" + traderName + "'."));
				return;
			}
			component.m_items.AddRange(itemsToAdd);
			component.m_items.RemoveAll((TradeItem x) => x == null);
		}

		private List<TradeItem> GetBogwitchItems()
		{
			return new List<TradeItem>
			{
				CreateTradeItem("DeadAcaiSeeds_bal", 100, 1, "defeated_gdking"),
				CreateTradeItem("HangingMossSeeds_bal", 100, 1, "defeated_gdking"),
				CreateTradeItem("BlackTissue_bal", 800, 1, "defeated_gdking"),
				CreateTradeItem("ElderTreeSeeds_bal", 300, 1, "defeated_gdking"),
				CreateTradeItem("SwampTreeSeeds_bal", 100, 1, "defeated_gdking"),
				CreateTradeItem("YggTreeSeed_bal", 800, 1, "defeated_qeen")
			};
		}

		private List<TradeItem> GetHaldorItems()
		{
			return new List<TradeItem>
			{
				CreateTradeItem("CypressSeeds_bal", 200, 1, "defeated_gdking"),
				CreateTradeItem("WillowSeeds_bal", 200, 1, "defeated_gdking"),
				CreateTradeItem("PoplarSeeds_bal", 200, 1, "defeated_gdking"),
				CreateTradeItem("GiantOakSeeds_bal", 800, 1, "defeated_gdking"),
				CreateTradeItem("OrangeOakSeeds_bal", 800, 1, "defeated_gdking"),
				CreateTradeItem("MapleSeeds_bal", 800, 1, "defeated_gdking")
			};
		}

		private List<TradeItem> GetHildirItems()
		{
			return new List<TradeItem>
			{
				CreateTradeItem("YewSeeds_bal", 500, 1, "defeated_gdking"),
				CreateTradeItem("RedwoodSeeds_bal", 900, 1, "defeated_gdking"),
				CreateTradeItem("AcaiSeeds_bal", 50, 1, "defeated_gdking"),
				CreateTradeItem("CrystalTreeSeeds_bal", 900, 1, "defeated_gdking"),
				CreateTradeItem("AshtreeSeeds_bal", 900, 1, "defeated_fader")
			};
		}

		private void EditTradeItem(string traderName, string itemName, int price = 100, int amount = 1, string globalKey = "", string checkObject = "")
		{
			GameObject val = _prefabs.Find((GameObject x) => ((Object)x).name == traderName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("Trader '" + traderName + "' not found."));
				return;
			}
			Trader component = val.GetComponent<Trader>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("Trader component missing on '" + traderName + "'."));
				return;
			}
			TradeItem val2 = component.m_items.Find((TradeItem x) => ((Object)x.m_prefab).name == itemName);
			val2.m_stack = amount;
			val2.m_price = price;
			val2.m_requiredGlobalKey = globalKey;
		}

		private TradeItem CreateTradeItem(string itemName, int price = 100, int amount = 1, string globalKey = "", string checkObject = "")
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			if (checkObject != "")
			{
				GameObject val = FindItem(checkObject);
				if ((Object)(object)val != (Object)null && ((Object)val).name != "Wood")
				{
					return null;
				}
			}
			GameObject val2 = FindItem(itemName);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			return new TradeItem
			{
				m_price = price,
				m_stack = amount,
				m_requiredGlobalKey = globalKey,
				m_prefab = val2.GetComponent<ItemDrop>()
			};
		}

		private GameObject FindItem(string name)
		{
			GameObject val = _prefabs.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
			return _prefabs.Find((GameObject x) => ((Object)x).name == "Wood");
		}
	}
}
namespace BalrondTreesNDecor.Services
{
	public static class ItemUtils
	{
		public static GameObject FindItem(List<GameObject> list, string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
			if ((Object)(object)itemPrefab != (Object)null)
			{
				return itemPrefab;
			}
			Debug.LogWarning((object)("[ItemUtils] Missing prefab: " + name));
			return null;
		}

		public static void EditKey(ItemDrop item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_maxStackSize = 20;
			}
		}

		public static void AddAttackStatusEffect(ItemDrop item, string effectName)
		{
			if (!((Object)(object)item == (Object)null) && !string.IsNullOrEmpty(effectName))
			{
				StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(BalrondHashCompat.StableHash(effectName));
				if ((Object)(object)statusEffect == (Object)null)
				{
					Debug.LogWarning((object)("[ItemUtils] Missing StatusEffect: " + effectName));
				}
				else
				{
					item.m_itemData.m_shared.m_attackStatusEffect = statusEffect;
				}
			}
		}

		public static void EditSkeletonStaff(ItemDrop item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_attack.m_attackEitr = 44f;
			}
		}

		public static void EditItemName(ItemDrop item, string newName)
		{
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_name = newName;
			}
		}

		public static void EditSpiritDamage(ItemDrop item, int spiritDamage)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				shared.m_damages.m_spirit = spiritDamage;
				string name = ((Object)((Component)item).gameObject).name;
				if (name == "skeleton_mace" || name == "imp_fireball_attack")
				{
					shared.m_damages.m_blunt += spiritDamage;
				}
			}
		}

		public static void EditSurtlingDamage(ItemDrop item, int fireDamage)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				shared.m_damages.m_fire = fireDamage;
				shared.m_damages.m_blunt += fireDamage;
			}
		}

		public static void EditToolTier(ItemDrop item, int level)
		{
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_toolTier = level;
			}
		}

		public static void EditWolfCapeResistance(ItemDrop item)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_damageModifiers.Clear();
				DamageModPair val = default(DamageModPair);
				val.m_type = (DamageType)64;
				val.m_modifier = (DamageModifier)0;
				DamageModPair item2 = val;
				item.m_itemData.m_shared.m_damageModifiers.Add(item2);
			}
		}

		public static void EditLoxCapeResistance(ItemDrop item)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_damageModifiers.Clear();
				DamageModPair val = default(DamageModPair);
				val.m_type = (DamageType)64;
				val.m_modifier = (DamageModifier)0;
				DamageModPair item2 = val;
				val = default(DamageModPair);
				val.m_type = (DamageType)32;
				val.m_modifier = (DamageModifier)0;
				DamageModPair item3 = val;
				item.m_itemData.m_shared.m_damageModifiers.Add(item2);
				item.m_itemData.m_shared.m_damageModifiers.Add(item3);
			}
		}

		public static void EditLevel(ItemDrop item, int level, bool hasUpgrade)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (hasUpgrade && shared.m_maxQuality > 1)
				{
					shared.m_maxQuality = level;
				}
				else
				{
					shared.m_maxQuality = level;
				}
			}
		}

		public static void EditPickaxeStone(ItemDrop item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				shared.m_name = "Flint Pickaxe";
				shared.m_maxDurability = 70f;
				shared.m_weight = 4f;
			}
		}

		public static void EditWolfFang(ItemDrop item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				shared.m_name = "Bone Spear";
				shared.m_description = "A clever usage of boar tusk";
				shared.m_damages.m_pierce = 26f;
			}
		}

		public static void EditRemoveStatusEffect(ItemDrop item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				item.m_itemData.m_shared.m_consumeStatusEffect = null;
			}
		}

		public static void EditFoodStats(ItemDrop item, int hp = -99, int stam = -99, int eitr = -99, int time = -99, float regen = -99f)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (hp != -99)
				{
					shared.m_food = hp;
				}
				if (stam != -99)
				{
					shared.m_foodStamina = stam;
				}
				if (eitr != -99)
				{
					shared.m_foodEitr = eitr;
				}
				if (time != -99)
				{
					shared.m_foodBurnTime = time;
				}
				if (regen != -99f)
				{
					shared.m_foodRegen = regen;
				}
			}
		}

		public static void EditStackAndWeight(ItemDrop item, float weight = -1f, int stack = 1)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (weight != -1f)
				{
					shared.m_weight = weight;
				}
				shared.m_autoStack = true;
				shared.m_maxStackSize = stack;
			}
		}

		public static void EditArmorSetEffect(ItemDrop item, int setSize, string statusName, string setName)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				shared.m_setName = setName;
				shared.m_setSize = setSize;
				shared.m_setStatusEffect = ObjectDB.instance.m_StatusEffects.Find((StatusEffect x) => ((Object)x).name == statusName);
			}
		}

		public static void EditQualityValues(ItemDrop item, float weightRatio = 0f, int quality = 4, float weight = -1f, float speedDebuff = 0f, float equipSpeed = -1f)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (weight != -1f)
				{
					shared.m_weight = weight;
				}
				if (weightRatio != 0f)
				{
					shared.m_scaleWeightByQuality = weightRatio;
				}
				if (equipSpeed != -1f)
				{
					shared.m_equipDuration = equipSpeed;
				}
				shared.m_movementModifier = speedDebuff;
				shared.m_maxQuality = quality;
			}
		}

		public static void EditDefense(ItemDrop item, float blockPower = -1f, float blockPowerPerLevel = -1f, float deflectionForce = -1f, float deflectionForcePerLevel = -1f, float blockBonus = -1f)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (blockPower != -1f)
				{
					shared.m_blockPower = blockPower;
				}
				if (blockPowerPerLevel != -1f)
				{
					shared.m_blockPowerPerLevel = blockPowerPerLevel;
				}
				if (deflectionForce != -1f)
				{
					shared.m_deflectionForce = deflectionForce;
				}
				if (deflectionForcePerLevel != -1f)
				{
					shared.m_deflectionForcePerLevel = deflectionForcePerLevel;
				}
				if (blockBonus != -1f)
				{
					shared.m_timedBlockBonus = blockBonus;
				}
			}
		}

		public static void EditArmor(ItemDrop item, float armor = -1f, float armorPerLevel = -1f)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (armor != -1f)
				{
					shared.m_armor = armor;
				}
				if (armorPerLevel != -1f)
				{
					shared.m_armorPerLevel = armorPerLevel;
				}
			}
		}

		public static void EditDurability(ItemDrop item, float durability = -1f, float durabilityPerLevel = -1f, float useDrain = -1f)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (durability != -1f)
				{
					item.m_itemData.m_durability = durability;
				}
				if (durabilityPerLevel != -1f)
				{
					shared.m_durabilityPerLevel = durabilityPerLevel;
				}
				if (useDrain != -1f)
				{
					shared.m_useDurabilityDrain = useDrain;
				}
			}
		}

		public static void EditValueAndTeleport(ItemDrop item, int newValue = -1, bool teleportable = true)
		{
			if (!((Object)(object)item == (Object)null))
			{
				SharedData shared = item.m_itemData.m_shared;
				if (newValue != -1)
				{
					shared.m_value = newValue;
				}
				shared.m_teleportable = teleportable;
			}
		}
	}
	public static class RequirementFactory
	{
		private static readonly Dictionary<string, ItemDrop> _cache = new Dictionary<string, ItemDrop>();

		private static readonly HashSet<string> _missing = new HashSet<string>();

		public static Requirement Create(List<GameObject> items, string name, int amount, int perLevel = 0)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			if (string.IsNullOrEmpty(name))
			{
				return new Requirement();
			}
			if (_cache.TryGetValue(name, out var value))
			{
				return BuildRequirement(value, amount, perLevel);
			}
			if (_missing.Contains(name))
			{
				return new Requirement();
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				Debug.LogWarning((object)("[RequirementFactory] Missing prefab: " + name));
				_missing.Add(name);
				return new Requirement();
			}
			value = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)value == (Object)null)
			{
				Debug.LogWarning((object)("[RequirementFactory] Missing ItemDrop on prefab: " + name));
				_missing.Add(name);
				return new Requirement();
			}
			_cache[name] = value;
			return BuildRequirement(value, amount, perLevel);
		}

		private static Requirement BuildRequirement(ItemDrop item, int amount, int perLevel)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return new Requirement();
			}
			return new Requirement
			{
				m_resItem = item,
				m_amount = amount,
				m_amountPerLevel = perLevel,
				m_recover = true
			};
		}

		public static void ClearCache()
		{
			_cache.Clear();
			_missing.Clear();
		}
	}
}
namespace LitJson2
{
	internal enum JsonType
	{
		None,
		Object,
		Array,
		String,
		Int,
		Long,
		Double,
		Boolean
	}
	internal interface IJsonWrapper : IList, IOrderedDictionary, IDictionary, ICollection, IEnumerable
	{
		bool IsArray { get; }

		bool IsBoolean { get; }

		bool IsDouble { get; }

		bool IsInt { get; }

		bool IsLong { get; }

		bool IsObject { get; }

		bool IsString { get; }

		bool GetBoolean();

		double GetDouble();

		int GetInt();

		JsonType GetJsonType();

		long GetLong();

		string GetString();

		void SetBoolean(bool val);

		void SetDouble(double val);

		void SetInt(int val);

		void SetJsonType(JsonType type);

		void SetLong(long val);

		void SetString(string val);

		string ToJson();

		void ToJson(JsonWriter writer);
	}
	internal class JsonData : IJsonWrapper, IList, IOrderedDictionary, IDictionary, ICollection, IEnumerable, IEquatable<JsonData>
	{
		private IList<JsonData> inst_array;

		private bool inst_boolean;

		private double inst_double;

		private int inst_int;

		private long inst_long;

		private IDictionary<string, JsonData> inst_object;

		private string inst_string;

		private string json;

		private JsonType type;

		private IList<KeyValuePair<string, JsonData>> object_list;

		public int Count => EnsureCollection().Count;

		public bool IsArray => type == JsonType.Array;

		public bool IsBoolean => type == JsonType.Boolean;

		public bool IsDouble => type == JsonType.Double;

		public bool IsInt => type == JsonType.Int;

		public bool IsLong => type == JsonType.Long;

		public bool IsObject => type == JsonType.Object;

		public bool IsString => type == JsonType.String;

		public ICollection<string> Keys
		{
			get
			{
				EnsureDictionary();
				return inst_object.Keys;
			}
		}

		int ICollection.Count => Count;

		bool ICollection.IsSynchronized => EnsureCollection().IsSynchronized;

		object ICollection.SyncRoot => EnsureCollection().SyncRoot;

		bool IDictionary.IsFixedSize => EnsureDictionary().IsFixedSize;

		bool IDictionary.IsReadOnly => EnsureDictionary().IsReadOnly;

		ICollection IDictionary.Keys
		{
			get
			{
				EnsureDictionary();
				IList<string> list = new List<string>();
				foreach (KeyValuePair<string, JsonData> item in object_list)
				{
					list.Add(item.Key);
				}
				return (ICollection)list;
			}
		}

		ICollection IDictionary.Values
		{
			get
			{
				EnsureDictionary();
				IList<JsonData> list = new List<JsonData>();
				foreach (KeyValuePair<string, JsonData> item in object_list)
				{
					list.Add(item.Value);
				}
				return (ICollection)list;
			}
		}

		bool IJsonWrapper.IsArray => IsArray;

		bool IJsonWrapper.IsBoolean => IsBoolean;

		bool IJsonWrapper.IsDouble => IsDouble;

		bool IJsonWrapper.IsInt => IsInt;

		bool IJsonWrapper.IsLong => IsLong;

		bool IJsonWrapper.IsObject => IsObject;

		bool IJsonWrapper.IsString => IsString;

		bool IList.IsFixedSize => EnsureList().IsFixedSize;

		bool IList.IsReadOnly => EnsureList().IsReadOnly;

		object IDictionary.this[object key]
		{
			get
			{
				return EnsureDictionary()[key];
			}
			set
			{
				if (!(key is string))
				{
					throw new ArgumentException("The key has to be a string");
				}
				JsonData value2 = ToJsonData(value);
				this[(string)key] = value2;
			}
		}

		object IOrderedDictionary.this[int idx]
		{
			get
			{
				EnsureDictionary();
				return object_list[idx].Value;
			}
			set
			{
				EnsureDictionary();
				JsonData value2 = ToJsonData(value);
				KeyValuePair<string, JsonData> keyValuePair = object_list[idx];
				inst_object[keyValuePair.Key] = value2;
				KeyValuePair<string, JsonData> value3 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value2);
				object_list[idx] = value3;
			}
		}

		object IList.this[int index]
		{
			get
			{
				return EnsureList()[index];
			}
			set
			{
				EnsureList();
				JsonData value2 = ToJsonData(value);
				this[index] = value2;
			}
		}

		public JsonData this[string prop_name]
		{
			get
			{
				EnsureDictionary();
				return inst_object[prop_name];
			}
			set
			{
				EnsureDictionary();
				KeyValuePair<string, JsonData> keyValuePair = new KeyValuePair<string, JsonData>(prop_name, value);
				if (inst_object.ContainsKey(prop_name))
				{
					for (int i = 0; i < object_list.Count; i++)
					{
						if (object_list[i].Key == prop_name)
						{
							object_list[i] = keyValuePair;
							break;
						}
					}
				}
				else
				{
					object_list.Add(keyValuePair);
				}
				inst_object[prop_name] = value;
				json = null;
			}
		}

		public JsonData this[int index]
		{
			get
			{
				EnsureCollection();
				if (type == JsonType.Array)
				{
					return inst_array[index];
				}
				return object_list[index].Value;
			}
			set
			{
				EnsureCollection();
				if (type == JsonType.Array)
				{
					inst_array[index] = value;
				}
				else
				{
					KeyValuePair<string, JsonData> keyValuePair = object_list[index];
					KeyValuePair<string, JsonData> value2 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value);
					object_list[index] = value2;
					inst_object[keyValuePair.Key] = value;
				}
				json = null;
			}
		}

		public JsonData()
		{
		}

		public JsonData(bool boolean)
		{
			type = JsonType.Boolean;
			inst_boolean = boolean;
		}

		public JsonData(double number)
		{
			type = JsonType.Double;
			inst_double = number;
		}

		public JsonData(int number)
		{
			type = JsonType.Int;
			inst_int = number;
		}

		public JsonData(long number)
		{
			type = JsonType.Long;
			inst_long = number;
		}

		public JsonData(object obj)
		{
			if (obj is bool)
			{
				type = JsonType.Boolean;
				inst_boolean = (bool)obj;
				return;
			}
			if (obj is double)
			{
				type = JsonType.Double;
				inst_double = (double)obj;
				return;
			}
			if (obj is int)
			{
				type = JsonType.Int;
				inst_int = (int)obj;
				return;
			}
			if (obj is long)
			{
				type = JsonType.Long;
				inst_long = (long)obj;
				return;
			}
			if (obj is string)
			{
				type = JsonType.String;
				inst_string = (string)obj;
				return;
			}
			throw new ArgumentException("Unable to wrap the given object with JsonData");
		}

		public JsonData(string str)
		{
			type = JsonType.String;
			inst_string = str;
		}

		public static implicit operator JsonData(bool data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(double data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(int data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(long data)
		{
			return new JsonData(data);
		}

		public static implicit operator JsonData(string data)
		{
			return new JsonData(data);
		}

		public static explicit operator bool(JsonData data)
		{
			if (data.type != JsonType.Boolean)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a double");
			}
			return data.inst_boolean;
		}

		public static explicit operator double(JsonData data)
		{
			if (data.type != JsonType.Double)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a double");
			}
			return data.inst_double;
		}

		public static explicit operator int(JsonData data)
		{
			if (data.type != JsonType.Int)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold an int");
			}
			return data.inst_int;
		}

		public static explicit operator long(JsonData data)
		{
			if (data.type != JsonType.Long)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold an int");
			}
			return data.inst_long;
		}

		public static explicit operator string(JsonData data)
		{
			if (data.type != JsonType.String)
			{
				throw new InvalidCastException("Instance of JsonData doesn't hold a string");
			}
			return data.inst_string;
		}

		void ICollection.CopyTo(Array array, int index)
		{
			EnsureCollection().CopyTo(array, index);
		}

		void IDictionary.Add(object key, object value)
		{
			JsonData value2 = ToJsonData(value);
			EnsureDictionary().Add(key, value2);
			KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>((string)key, value2);
			object_list.Add(item);
			json = null;
		}

		void IDictionary.Clear()
		{
			EnsureDictionary().Clear();
			object_list.Clear();
			json = null;
		}

		bool IDictionary.Contains(object key)
		{
			return EnsureDictionary().Contains(key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return ((IOrderedDictionary)this).GetEnumerator();
		}

		void IDictionary.Remove(object key)
		{
			EnsureDictionary().Remove(key);
			for (int i = 0; i < object_list.Count; i++)
			{
				if (object_list[i].Key == (string)key)
				{
					object_list.RemoveAt(i);
					break;
				}
			}
			json = null;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return EnsureCollection().GetEnumerator();
		}

		bool IJsonWrapper.GetBoolean()
		{
			if (type != JsonType.Boolean)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a boolean");
			}
			return inst_boolean;
		}

		double IJsonWrapper.GetDouble()
		{
			if (type != JsonType.Double)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a double");
			}
			return inst_double;
		}

		int IJsonWrapper.GetInt()
		{
			if (type != JsonType.Int)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold an int");
			}
			return inst_int;
		}

		long IJsonWrapper.GetLong()
		{
			if (type != JsonType.Long)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a long");
			}
			return inst_long;
		}

		string IJsonWrapper.GetString()
		{
			if (type != JsonType.String)
			{
				throw new InvalidOperationException("JsonData instance doesn't hold a string");
			}
			return inst_string;
		}

		void IJsonWrapper.SetBoolean(bool val)
		{
			type = JsonType.Boolean;
			inst_boolean = val;
			json = null;
		}

		void IJsonWrapper.SetDouble(double val)
		{
			type = JsonType.Double;
			inst_double = val;
			json = null;
		}

		void IJsonWrapper.SetInt(int val)
		{
			type = JsonType.Int;
			inst_int = val;
			json = null;
		}

		void IJsonWrapper.SetLong(long val)
		{
			type = JsonType.Long;
			inst_long = val;
			json = null;
		}

		void IJsonWrapper.SetString(string val)
		{
			type = JsonType.String;
			inst_string = val;
			json = null;
		}

		string IJsonWrapper.ToJson()
		{
			return ToJson();
		}

		void IJsonWrapper.ToJson(JsonWriter writer)
		{
			ToJson(writer);
		}

		int IList.Add(object value)
		{
			return Add(value);
		}

		void IList.Clear()
		{
			EnsureList().Clear();
			json = null;
		}

		bool IList.Contains(object value)
		{
			return EnsureList().Contains(value);
		}

		int IList.IndexOf(object value)
		{
			return EnsureList().IndexOf(value);
		}

		void IList.Insert(int index, object value)
		{
			EnsureList().Insert(index, value);
			json = null;
		}

		void IList.Remove(object value)
		{
			EnsureList().Remove(value);
			json = null;
		}

		void IList.RemoveAt(int index)
		{
			EnsureList().RemoveAt(index);
			json = null;
		}

		IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
		{
			EnsureDictionary();
			return new OrderedDictionaryEnumerator(object_list.GetEnumerator());
		}

		void IOrderedDictionary.Insert(int idx, object key, object value)
		{
			string text = (string)key;
			JsonData value2 = (this[text] = ToJsonData(value));
			KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>(text, value2);
			object_list.Insert(idx, item);
		}

		void IOrderedDictionary.RemoveAt(int idx)
		{
			EnsureDictionary();
			inst_object.Remove(object_list[idx].Key);
			object_list.RemoveAt(idx);
		}

		private ICollection EnsureCollection()
		{
			if (type == JsonType.Array)
			{
				return (ICollection)inst_array;
			}
			if (type == JsonType.Object)
			{
				return (ICollection)inst_object;
			}
			throw new InvalidOperationException("The JsonData instance has to be initialized first");
		}

		private IDictionary EnsureDictionary()
		{
			if (type == JsonType.Object)
			{
				return (IDictionary)inst_object;
			}
			if (type != 0)
			{
				throw new InvalidOperationException("Instance of JsonData is not a dictionary");
			}
			type = JsonType.Object;
			inst_object = new Dictionary<string, JsonData>();
			object_list = new List<KeyValuePair<string, JsonData>>();
			return (IDictionary)inst_object;
		}

		private IList EnsureList()
		{
			if (type == JsonType.Array)
			{
				return (IList)inst_array;
			}
			if (type != 0)
			{
				throw new InvalidOperationException("Instance of JsonData is not a list");
			}
			type = JsonType.Array;
			inst_array = new List<JsonData>();
			return (IList)inst_array;
		}

		private JsonData ToJsonData(object obj)
		{
			if (obj == null)
			{
				return null;
			}
			if (obj is JsonData)
			{
				return (JsonData)obj;
			}
			return new JsonData(obj);
		}

		private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
		{
			if (obj == null)
			{
				writer.Write(null);
			}
			else if (obj.IsString)
			{
				writer.Write(obj.GetString());
			}
			else if (obj.IsBoolean)
			{
				writer.Write(obj.GetBoolean());
			}
			else if (obj.IsDouble)
			{
				writer.Write(obj.GetDouble());
			}
			else if (obj.IsInt)
			{
				writer.Write(obj.GetInt());
			}
			else if (obj.IsLong)
			{
				writer.Write(obj.GetLong());
			}
			else if (obj.IsArray)
			{
				writer.WriteArrayStart();
				foreach (object item in (IEnumerable)obj)
				{
					WriteJson((JsonData)item, writer);
				}
				writer.WriteArrayEnd();
			}
			else
			{
				if (!obj.IsObject)
				{
					return;
				}
				writer.WriteObjectStart();
				foreach (DictionaryEntry item2 in (IDictionary)obj)
				{
					writer.WritePropertyName((string)item2.Key);
					WriteJson((JsonData)item2.Value, writer);
				}
				writer.WriteObjectEnd();
			}
		}

		public int Add(object value)
		{
			JsonData value2 = ToJsonData(value);
			json = null;
			return EnsureList().Add(value2);
		}

		public void Clear()
		{
			if (IsObject)
			{
				((IDictionary)this).Clear();
			}
			else if (IsArray)
			{
				((IList)this).Clear();
			}
		}

		public bool Equals(JsonData x)
		{
			if (x == null)
			{
				return false;
			}
			if (x.type != type)
			{
				return false;
			}
			return type switch
			{
				JsonType.None => true, 
				JsonType.Object => inst_object.Equals(x.inst_object), 
				JsonType.Array => inst_array.Equals(x.inst_array), 
				JsonType.String => inst_string.Equals(x.inst_string), 
				JsonType.Int => inst_int.Equals(x.inst_int), 
				JsonType.Long => inst_long.Equals(x.inst_long), 
				JsonType.Double => inst_double.Equals(x.inst_double), 
				JsonType.Boolean => inst_boolean.Equals(x.inst_boolean), 
				_ => false, 
			};
		}

		public JsonType GetJsonType()
		{
			return type;
		}

		public void SetJsonType(JsonType type)
		{
			if (this.type != type)
			{
				switch (type)
				{
				case JsonType.Object:
					inst_object = new Dictionary<string, JsonData>();
					object_list = new List<KeyValuePair<string, JsonData>>();
					break;
				case JsonType.Array:
					inst_array = new List<JsonData>();
					break;
				case JsonType.String:
					inst_string = null;
					break;
				case JsonType.Int:
					inst_int = 0;
					break;
				case JsonType.Long:
					inst_long = 0L;
					break;
				case JsonType.Double:
					inst_double = 0.0;
					break;
				case JsonType.Boolean:
					inst_boolean = false;
					break;
				}
				this.type = type;
			}
		}

		public string ToJson()
		{
			if (json != null)
			{
				return json;
			}
			StringWriter stringWriter = new StringWriter();
			JsonWriter jsonWriter = new JsonWriter(stringWriter);
			jsonWriter.Validate = false;
			WriteJson(this, jsonWriter);
			json = stringWriter.ToString();
			return json;
		}

		public void ToJson(JsonWriter writer)
		{
			bool validate = writer.Validate;
			writer.Validate = false;
			WriteJson(this, writer);
			writer.Validate = validate;
		}

		public override string ToString()
		{
			return type switch
			{
				JsonType.Array => "JsonData array", 
				JsonType.Boolean => inst_boolean.ToString(), 
				JsonType.Double => inst_double.ToString(), 
				JsonType.Int => inst_int.ToString(), 
				JsonType.Long => inst_long.ToString(), 
				JsonType.Object => "JsonData object", 
				JsonType.String => inst_string, 
				_ => "Uninitialized JsonData", 
			};
		}
	}
	internal class OrderedDictionaryEnumerator : IDictionaryEnumerator, IEnumerator
	{
		private IEnumerator<KeyValuePair<string, JsonData>> list_enumerator;

		public object Current => Entry;

		public DictionaryEntry Entry
		{
			get
			{
				KeyValuePair<string, JsonData> current = list_enumerator.Current;
				return new DictionaryEntry(current.Key, current.Value);
			}
		}

		public object Key => list_enumerator.Current.Key;

		public object Value => list_enumerator.Current.Value;

		public OrderedDictionaryEnumerator(IEnumerator<KeyValuePair<string, JsonData>> enumerator)
		{
			list_enumerator = enumerator;
		}

		public bool MoveNext()
		{
			return list_enumerator.MoveNext();
		}

		public void Reset()
		{
			list_enumerator.Reset();
		}
	}
	internal class JsonException : ApplicationException
	{
		public JsonException()
		{
		}

		internal JsonException(ParserToken token)
			: base($"Invalid token '{token}' in input string")
		{
		}

		internal JsonException(ParserToken token, Exception inner_exception)
			: base($"Invalid token '{token}' in input string", inner_exception)
		{
		}

		internal JsonException(int c)
			: base($"Invalid character '{(char)c}' in input string")
		{
		}

		internal JsonException(int c, Exception inner_exception)
			: base($"Invalid character '{(char)c}' in input string", inner_exception)
		{
		}

		public JsonException(string message)
			: base(message)
		{
		}

		public JsonException(string message, Exception inner_exception)
			: base(message, inner_exception)
		{
		}
	}
	internal struct PropertyMetadata
	{
		public MemberInfo Info;

		public bool IsField;

		public Type Type;
	}
	internal struct ArrayMetadata
	{
		private Type element_type;

		private bool is_array;

		private bool is_list;

		public Type ElementType
		{
			get
			{
				if (element_type == null)
				{
					return typeof(JsonData);
				}
				return element_type;
			}
			set
			{
				element_type = value;
			}
		}

		public bool IsArray
		{
			get
			{
				return is_array;
			}
			set
			{
				is_array = value;
			}
		}

		public bool IsList
		{
			get
			{
				return is_list;
			}
			set
			{
				is_list = value;
			}
		}
	}
	internal struct ObjectMetadata
	{
		private Type element_type;

		private bool is_dictionary;

		private IDictionary<string, PropertyMetadata> properties;

		public Type ElementType
		{
			get
			{
				if (element_type == null)
				{
					return typeof(JsonData);
				}
				return element_type;
			}
			set
			{
				element_type = value;
			}
		}

		public bool IsDictionary
		{
			get
			{
				return is_dictionary;
			}
			set
			{
				is_dictionary = value;
			}
		}

		public IDictionary<string, PropertyMetadata> Properties
		{
			get
			{
				return properties;
			}
			set
			{
				properties = value;
			}
		}
	}
	internal delegate void ExporterFunc(object obj, JsonWriter writer);
	internal delegate void ExporterFunc<T>(T obj, JsonWriter writer);
	internal delegate object ImporterFunc(object input);
	internal delegate TValue ImporterFunc<TJson, TValue>(TJson input);
	internal delegate IJsonWrapper WrapperFactory();
	internal class JsonMapper
	{
		private static int max_nesting_depth;

		private static IFormatProvider datetime_format;

		private static IDictionary<Type, ExporterFunc> base_exporters_table;

		private static IDictionary<Type, ExporterFunc> custom_exporters_table;

		private static IDictionary<Type, IDictionary<Type, ImporterFunc>> base_importers_table;

		private static IDictionary<Type, IDictionary<Type, ImporterFunc>> custom_importers_table;

		private static IDictionary<Type, ArrayMetadata> array_metadata;

		private static readonly object array_metadata_lock;

		private static IDictionary<Type, IDictionary<Type, MethodInfo>> conv_ops;

		private static readonly object conv_ops_lock;

		private static IDictionary<Type, ObjectMetadata> object_metadata;

		private static readonly object object_metadata_lock;

		private static IDictionary<Type, IList<PropertyMetadata>> type_properties;

		private static readonly object type_properties_lock;

		private static JsonWriter static_writer;

		private static readonly object static_writer_lock;

		static JsonMapper()
		{
			array_metadata_lock = new object();
			conv_ops_lock = new object();
			object_metadata_lock = new object();
			type_properties_lock = new object();
			static_writer_lock = new object();
			max_nesting_depth = 100;
			array_metadata = new Dictionary<Type, ArrayMetadata>();
			conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
			object_metadata = new Dictionary<Type, ObjectMetadata>();
			type_properties = new Dictionary<Type, IList<PropertyMetadata>>();
			static_writer = new JsonWriter();
			datetime_format = DateTimeFormatInfo.InvariantInfo;
			base_exporters_table = new Dictionary<Type, ExporterFunc>();
			custom_exporters_table = new Dictionary<Type, ExporterFunc>();
			base_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
			custom_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
			RegisterBaseExporters();
			RegisterBaseImporters();
		}

		private static void AddArrayMetadata(Type type)
		{
			if (array_metadata.ContainsKey(type))
			{
				return;
			}
			ArrayMetadata value = default(ArrayMetadata);
			value.IsArray = type.IsArray;
			if (type.GetInterface("System.Collections.IList") != null)
			{
				value.IsList = true;
			}
			PropertyInfo[] properties = type.GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (!(propertyInfo.Name != "Item"))
				{
					ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
					if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(int))
					{
						value.ElementType = propertyInfo.PropertyType;
					}
				}
			}
			lock (array_metadata_lock)
			{
				try
				{
					array_metadata.Add(type, value);
				}
				catch (ArgumentException)
				{
				}
			}
		}

		private static void AddObjectMetadata(Type type)
		{
			if (object_metadata.ContainsKey(type))
			{
				return;
			}
			ObjectMetadata value = default(ObjectMetadata);
			if (type.GetInterface("System.Collections.IDictionary") != null)
			{
				value.IsDictionary = true;
			}
			value.Properties = new Dictionary<string, PropertyMetadata>();
			PropertyInfo[] properties = type.GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.Name == "Item")
				{
					ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
					if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(string))
					{
						value.ElementType = propertyInfo.PropertyType;
					}
				}
				else
				{
					PropertyMetadata value2 = default(PropertyMetadata);
					value2.Info = propertyInfo;
					value2.Type = propertyInfo.PropertyType;
					value.Properties.Add(propertyInfo.Name, value2);
				}
			}
			FieldInfo[] fields = type.GetFields();
			foreach (FieldInfo fieldInfo in fields)
			{
				PropertyMetadata value3 = default(PropertyMetadata);
				value3.Info = fieldInfo;
				value3.IsField = true;
				value3.Type = fieldInfo.FieldType;
				value.Properties.Add(fieldInfo.Name, value3);
			}
			lock (object_metadata_lock)
			{
				try
				{
					object_metadata.Add(type, value);
				}
				catch (ArgumentException)
				{
				}
			}
		}

		private static void AddTypeProperties(Type type)
		{
			if (type_properties.ContainsKey(type))
			{
				return;
			}
			IList<PropertyMetadata> list = new List<PropertyMetadata>();
			PropertyInfo[] properties = type.GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (!(propertyInfo.Name == "Item"))
				{
					PropertyMetadata item = default(PropertyMetadata);
					item.Info = propertyInfo;
					item.IsField = false;
					list.Add(item);
				}
			}
			FieldInfo[] fields = type.GetFields();
			foreach (FieldInfo info in fields)
			{
				PropertyMetadata item2 = default(PropertyMetadata);
				item2.Info = info;
				item2.IsField = true;
				list.Add(item2);
			}
			lock (type_properties_lock)
			{
				try
				{
					type_properties.Add(type, list);
				}
				catch (ArgumentException)
				{
				}
			}
		}

		private static MethodInfo GetConvOp(Type t1, Type t2)
		{
			lock (conv_ops_lock)
			{
				if (!conv_ops.ContainsKey(t1))
				{
					conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
				}
			}
			if (conv_ops[t1].ContainsKey(t2))
			{
				return conv_ops[t1][t2];
			}
			MethodInfo method = t1.GetMethod("op_Implicit", new Type[1] { t2 });
			lock (conv_ops_lock)
			{
				try
				{
					conv_ops[t1].Add(t2, method);
					return method;
				}
				catch (ArgumentException)
				{
					return conv_ops[t1][t2];
				}
			}
		}

		private static object ReadValue(Type inst_type, JsonReader reader)
		{
			reader.Read();
			if (reader.Token == JsonToken.ArrayEnd)
			{
				return null;
			}
			Type underlyingType = Nullable.GetUnderlyingType(inst_type);
			Type type = underlyingType ?? inst_type;
			if (reader.Token == JsonToken.Null)
			{
				if (inst_type.IsClass || underlyingType != null)
				{
					return null;
				}
				throw new JsonException($"Can't assign null to an instance of type {inst_type}");
			}
			if (reader.Token == JsonToken.Double || reader.Token == JsonToken.Int || reader.Token == JsonToken.Long || reader.Token == JsonToken.String || reader.Token == JsonToken.Boolean)
			{
				Type type2 = reader.Value.GetType();
				if (type.IsAssignableFrom(type2))
				{
					return reader.Value;
				}
				if (custom_importers_table.ContainsKey(type2) && custom_importers_table[type2].ContainsKey(type))
				{
					ImporterFunc importerFunc = custom_importers_table[type2][type];
					return importerFunc(reader.Value);
				}
				if (base_importers_table.ContainsKey(type2) && base_importers_table[type2].ContainsKey(type))
				{
					ImporterFunc importerFunc2 = base_importers_table[type2][type];
					return importerFunc2(reader.Value);
				}
				if (type.IsEnum)
				{
					return Enum.ToObject(type, reader.Value);
				}
				MethodInfo convOp = GetConvOp(type, type2);
				if (convOp != null)
				{
					return convOp.Invoke(null, new object[1] { reader.Value });
				}
				throw new JsonException($"Can't assign value '{reader.Value}' (type {type2}) to type {inst_type}");
			}
			object obj = null;
			if (reader.Token == JsonToken.ArrayStart)
			{
				AddArrayMetadata(inst_type);
				ArrayMetadata arrayMetadata = array_metadata[inst_type];
				if (!arrayMetadata.IsArray && !arrayMetadata.IsList)
				{
					throw new JsonException($"Type {inst_type} can't act as an array");
				}
				IList list;
				Type elementType;
				if (!arrayMetadata.IsArray)
				{
					list = (IList)Activator.CreateInstance(inst_type);
					elementType = arrayMetadata.ElementType;
				}
				else
				{
					list = new ArrayList();
					elementType = inst_type.GetElementType();
				}
				while (true)
				{
					object obj2 = ReadValue(elementType, reader);
					if (obj2 == null && reader.Token == JsonToken.ArrayEnd)
					{
						break;
					}
					list.Add(obj2);
				}
				if (arrayMetadata.IsArray)
				{
					int count = list.Count;
					obj = Array.CreateInstance(elementType, count);
					for (int i = 0; i < count; i++)
					{
						((Array)obj).SetValue(list[i], i);
					}
				}
				else
				{
					obj = list;
				}
			}
			else if (reader.Token == JsonToken.ObjectStart)
			{
				AddObjectMetadata(type);
				ObjectMetadata objectMetadata = object_metadata[type];
				obj = Activator.CreateInstance(type);
				while (true)
				{
					reader.Read();
					if (reader.Token == JsonToken.ObjectEnd)
					{
						break;
					}
					string text = (string)reader.Value;
					if (objectMetadata.Properties.ContainsKey(text))
					{
						PropertyMetadata propertyMetadata = objectMetadata.Properties[text];
						if (propertyMetadata.IsField)
						{
							((FieldInfo)propertyMetadata.Info).SetValue(obj, ReadValue(propertyMetadata.Type, reader));
							continue;
						}
						PropertyInfo propertyInfo = (PropertyInfo)propertyMetadata.Info;
						if (propertyInfo.CanWrite)
						{
							propertyInfo.SetValue(obj, ReadValue(propertyMetadata.Type, reader), null);
						}
						else
						{
							ReadValue(propertyMetadata.Type, reader);
						}
					}
					else if (!objectMetadata.IsDictionary)
					{
						if (!reader.SkipNonMembers)
						{
							throw new JsonException($"The type {inst_type} doesn't have the property '{text}'");
						}
						ReadSkip(reader);
					}
					else
					{
						((IDictionary)obj).Add(text, ReadValue(objectMetadata.ElementType, reader));
					}
				}
			}
			return obj;
		}

		private static IJsonWrapper ReadValue(WrapperFactory factory, JsonReader reader)
		{
			reader.Read();
			if (reader.Token == JsonToken.ArrayEnd || reader.Token == JsonToken.Null)
			{
				return null;
			}
			IJsonWrapper jsonWrapper = factory();
			if (reader.Token == JsonToken.String)
			{
				jsonWrapper.SetString((string)reader.Value);
				return jsonWrapper;
			}
			if (reader.Token == JsonToken.Double)
			{
				jsonWrapper.SetDouble((double)reader.Value);
				return jsonWrapper;
			}
			if (reader.Token == JsonToken.Int)
			{
				jsonWrapper.SetInt((int)reader.Value);
				return jsonWrapper;
			}
			if (reader.Token == JsonToken.Long)
			{
				jsonWrapper.SetLong((long)reader.Value);
				return jsonWrapper;
			}
			if (reader.Token == JsonToken.Boolean)
			{
				jsonWrapper.SetBoolean((bool)reader.Value);
				return jsonWrapper;
			}
			if (reader.Token == JsonToken.ArrayStart)
			{
				jsonWrapper.SetJsonType(JsonType.Array);
				while (true)
				{
					IJsonWrapper jsonWrapper2 = ReadValue(factory, reader);
					if (jsonWrapper2 == null && reader.Token == JsonToken.ArrayEnd)
					{
						break;
					}
					jsonWrapper.Add(jsonWrapper2);
				}
			}
			else if (reader.Token == JsonToken.ObjectStart)
			{
				jsonWrapper.SetJsonType(JsonType.Object);
				while (true)
				{
					reader.Read();
					if (reader.Token == JsonToken.ObjectEnd)
					{
						break;
					}
					string key = (string)reader.Value;
					jsonWrapper[key] = ReadValue(factory, reader);
				}
			}
			return jsonWrapper;
		}

		private static void ReadSkip(JsonReader reader)
		{
			ToWrapper(() => new JsonMockWrapper(), reader);
		}

		private static void RegisterBaseExporters()
		{
			base_exporters_table[typeof(byte)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToInt32((byte)obj));
			};
			base_exporters_table[typeof(char)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToString((char)obj));
			};
			base_exporters_table[typeof(DateTime)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToString((DateTime)obj, datetime_format));
			};
			base_exporters_table[typeof(decimal)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write((decimal)obj);
			};
			base_exporters_table[typeof(sbyte)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToInt32((sbyte)obj));
			};
			base_exporters_table[typeof(short)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToInt32((short)obj));
			};
			base_exporters_table[typeof(ushort)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToInt32((ushort)obj));
			};
			base_exporters_table[typeof(uint)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write(Convert.ToUInt64((uint)obj));
			};
			base_exporters_table[typeof(ulong)] = delegate(object obj, JsonWriter writer)
			{
				writer.Write((ulong)obj);
			};
		}

		private static void RegisterBaseImporters()
		{
			ImporterFunc importer = (object input) => Convert.ToByte((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(byte), importer);
			importer = (object input) => Convert.ToUInt64((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(ulong), importer);
			importer = (object input) => Convert.ToSByte((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(sbyte), importer);
			importer = (object input) => Convert.ToInt16((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(short), importer);
			importer = (object input) => Convert.ToUInt16((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(ushort), importer);
			importer = (object input) => Convert.ToUInt32((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(uint), importer);
			importer = (object input) => Convert.ToSingle((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(float), importer);
			importer = (object input) => Convert.ToDouble((int)input);
			RegisterImporter(base_importers_table, typeof(int), typeof(double), importer);
			importer = (object input) => Convert.ToDecimal((double)input);
			RegisterImporter(base_importers_table, typeof(double), typeof(decimal), importer);
			importer = (object input) => Convert.ToUInt32((long)input);
			RegisterImporter(base_importers_table, typeof(long), typeof(uint), importer);
			importer = (object input) => Convert.ToChar((string)input);
			RegisterImporter(base_importers_table, typeof(string), typeof(char), importer);
			importer = (object input) => Convert.ToDateTime((string)input, datetime_format);
			RegisterImporter(base_importers_table, typeof(string), typeof(DateTime), importer);
		}

		private static void RegisterImporter(IDictionary<Type, IDictionary<Type, ImporterFunc>> table, Type json_type, Type value_type, ImporterFunc importer)
		{
			if (!table.ContainsKey(json_type))
			{
				table.Add(json_type, new Dictionary<Type, ImporterFunc>());
			}
			table[json_type][value_type] = importer;
		}

		private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth)
		{
			if (depth > max_nesting_depth)
			{
				throw new JsonException($"Max allowed object depth reached while trying to export from type {obj.GetType()}");
			}
			if (obj == null)
			{
				writer.Write(null);
				return;
			}
			if (obj is IJsonWrapper)
			{
				if (writer_is_private)
				{
					writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
				}
				else
				{
					((IJsonWrapper)obj).ToJson(writer);
				}
				return;
			}
			if (obj is string)
			{
				writer.Write((string)obj);
				return;
			}
			if (obj is double)
			{
				writer.Write((double)obj);
				return;
			}
			if (obj is int)
			{
				writer.Write((int)obj);
				return;
			}
			if (obj is bool)
			{
				writer.Write((bool)obj);
				return;
			}
			if (obj is long)
			{
				writer.Write((long)obj);
				return;
			}
			if (obj is Array)
			{
				writer.WriteArrayStart();
				foreach (object item in (Array)obj)
				{
					WriteValue(item, writer, writer_is_private, depth + 1);
				}
				writer.WriteArrayEnd();
				return;
			}
			if (obj is IList)
			{
				writer.WriteArrayStart();
				foreach (object item2 in (IList)obj)
				{
					WriteValue(item2, writer, writer_is_private, depth + 1);
				}
				writer.WriteArrayEnd();
				return;
			}
			if (obj is IDictionary)
			{
				writer.WriteObjectStart();
				foreach (DictionaryEntry item3 in (IDictionary)obj)
				{
					writer.WritePropertyName((string)item3.Key);
					WriteValue(item3.Value, writer, writer_is_private, depth + 1);
				}
				writer.WriteObjectEnd();
				return;
			}
			Type type = obj.GetType();
			if (custom_exporters_table.ContainsKey(type))
			{
				ExporterFunc exporterFunc = custom_exporters_table[type];
				exporterFunc(obj, writer);
				return;
			}
			if (base_exporters_table.ContainsKey(type))
			{
				ExporterFunc exporterFunc2 = base_exporters_table[type];
				exporterFunc2(obj, writer);
				return;
			}
			if (obj is Enum)
			{
				Type underlyingType = Enum.GetUnderlyingType(type);
				if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong))
				{
					writer.Write((ulong)obj);
				}
				else
				{
					writer.Write((int)obj);
				}
				return;
			}
			AddTypeProperties(type);
			IList<PropertyMetadata> list = type_properties[type];
			writer.WriteObjectStart();
			foreach (PropertyMetadata item4 in list)
			{
				if (item4.IsField)
				{
					writer.WritePropertyName(item4.Info.Name);
					WriteValue(((FieldInfo)item4.Info).GetValue(obj), writer, writer_is_private, depth + 1);
					continue;
				}
				PropertyInfo propertyInfo = (PropertyInfo)item4.Info;
				if (propertyInfo.CanRead)
				{
					writer.WritePropertyName(item4.Info.Name);
					WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1);
				}
			}
			writer.WriteObjectEnd();
		}

		public static string ToJson(object obj)
		{
			lock (static_writer_lock)
			{
				static_writer.Reset();
				WriteValue(obj, static_writer, writer_is_private: true, 0);
				return static_writer.ToString();
			}
		}

		public static void ToJson(object obj, JsonWriter writer)
		{
			WriteValue(obj, writer, writer_is_private: false, 0);
		}

		public static JsonData ToObject(JsonReader reader)
		{
			return (JsonData)ToWrapper(() => new JsonData(), reader);
		}

		public static JsonData ToObject(TextReader reader)
		{
			JsonReader reader2 = new JsonReader(reader);
			return (JsonData)ToWrapper(() => new JsonData(), reader2);
		}

		public static JsonData ToObject(string json)
		{
			return (JsonData)ToWrapper(() => new JsonData(), json);
		}

		public static T ToObject<T>(JsonReader reader)
		{
			return (T)ReadValue(typeof(T), reader);
		}

		public static T ToObject<T>(TextReader reader)
		{
			JsonReader reader2 = new JsonReader(reader);
			return (T)ReadValue(typeof(T), reader2);
		}

		public static T ToObject<T>(string json)
		{
			JsonReader reader = new JsonReader(json);
			return (T)ReadValue(typeof(T), reader);
		}

		public static IJsonWrapper ToWrapper(WrapperFactory factory, JsonReader reader)
		{
			return ReadValue(factory, reader);
		}

		public static IJsonWrapper ToWrapper(WrapperFactory factory, string json)
		{
			JsonReader reader = new JsonReader(json);
			return ReadValue(factory, reader);
		}

		public static void RegisterExporter<T>(ExporterFunc<T> exporter)
		{
			ExporterFunc value = delegate(object obj, JsonWriter writer)
			{
				exporter((T)obj, writer);
			};
			custom_exporters_table[typeof(T)] = value;
		}

		public static void RegisterImporter<TJson, TValue>(ImporterFunc<TJson, TValue> importer)
		{
			ImporterFunc importer2 = (object input) => importer((TJson)input);
			RegisterImporter(custom_importers_table, typeof(TJson), typeof(TValue), importer2);
		}

		public static void UnregisterExporters()
		{
			custom_exporters_table.Clear();
		}

		public static void UnregisterImporters()
		{
			custom_importers_table.Clear();
		}
	}
	internal class JsonMockWrapper : IJsonWrapper, IList, IOrderedDictionary, IDictionary, ICollection, IEnumerable
	{
		public bool IsArray => false;

		public bool IsBoolean => false;

		public bool IsDouble => false;

		public bool IsInt => false;

		public bool IsLong => false;

		public bool IsObject => false;

		public bool IsString => false;

		bool IList.IsFixedSize => true;

		bool IList.IsReadOnly => true;

		object IList.this[int index]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		int ICollection.Count => 0;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => null;

		bool IDictionary.IsFixedSize => true;

		bool IDictionary.IsReadOnly => true;

		ICollection IDictionary.Keys => null;

		ICollection IDictionary.Values => null;

		object IDictionary.this[object key]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		object IOrderedDictionary.this[int idx]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public bool GetBoolean()
		{
			return false;
		}

		public double GetDouble()
		{
			return 0.0;
		}

		public int GetInt()
		{
			return 0;
		}

		public JsonType GetJsonType()
		{
			return JsonType.None;
		}

		public long GetLong()
		{
			return 0L;
		}

		public string GetString()
		{
			return "";
		}

		public void SetBoolean(bool val)
		{
		}

		public void SetDouble(double val)
		{
		}

		public void SetInt(int val)
		{
		}

		public void SetJsonType(JsonType type)
		{
		}

		public void SetLong(long val)
		{
		}

		public void SetString(string val)
		{
		}

		public string ToJson()
		{
			return "";
		}

		public void ToJson(JsonWriter writer)
		{
		}

		int IList.Add(object value)
		{
			return 0;
		}

		void IList.Clear()
		{
		}

		bool IList.Contains(object value)
		{
			return false;
		}

		int IList.IndexOf(object value)
		{
			return -1;
		}

		void IList.Insert(int i, object v)
		{
		}

		void IList.Remove(object value)
		{
		}

		void IList.RemoveAt(int index)
		{
		}

		void ICollection.CopyTo(Array array, int index)
		{
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}

		void IDictionary.Add(object k, object v)
		{
		}

		void IDictionary.Clear()
		{
		}

		bool IDictionary.Contains(object key)
		{
			return false;
		}

		void IDictionary.Remove(object key)
		{
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return null;
		}

		IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
		{
			return null;
		}

		void IOrderedDictionary.Insert(int i, object k, object v)
		{
		}

		void IOrderedDictionary.RemoveAt(int i)
		{
		}
	}
	internal enum JsonToken
	{
		None,
		ObjectStart,
		PropertyName,
		ObjectEnd,
		ArrayStart,
		ArrayEnd,
		Int,
		Long,
		Double,
		String,
		Boolean,
		Null
	}
	internal class JsonReader
	{
		private static IDictionary<int, IDictionary<int, int[]>> parse_table;

		private Stack<int> automaton_stack;

		private int current_input;

		private int current_symbol;

		private bool end_of_json;

		private bool end_of_input;

		private Lexer lexer;

		private bool parser_in_string;

		private bool parser_return;

		private bool read_started;

		private TextReader reader;

		private bool reader_is_owned;

		private bool skip_non_members;

		private object token_value;

		private JsonToken token;

		public bool AllowComments
		{
			get
			{
				return lexer.AllowComments;
			}
			set
			{
				lexer.AllowComments = value;
			}
		}

		public bool AllowSingleQuotedStrings
		{
			get
			{
				return lexer.AllowSingleQuotedStrings;
			}
			set
			{
				lexer.AllowSingleQuotedStrings = value;
			}
		}

		public bool SkipNonMembers
		{
			get
			{
				return skip_non_members;
			}
			set
			{
				skip_non_members = value;
			}
		}

		public bool EndOfInput => end_of_input;

		public bool EndOfJson => end_of_json;

		public JsonToken Token => token;

		public object Value => token_value;

		static JsonReader()
		{
			PopulateParseTable();
		}

		public JsonReader(string json_text)
			: this(new StringReader(json_text), owned: true)
		{
		}

		public JsonReader(TextReader reader)
			: this(reader, owned: false)
		{
		}

		private JsonReader(TextReader reader, bool owned)
		{
			if (reader == null)
			{
				throw new ArgumentNullException("reader");
			}
			parser_in_string = false;
			parser_return = false;
			read_started = false;
			automaton_stack = new Stack<int>();
			automaton_stack.Push(65553);
			automaton_stack.Push(65543);
			lexer = new Lexer(reader);
			end_of_input = false;
			end_of_json = false;
			skip_non_members = true;
			this.reader = reader;
			reader_is_owned = owned;
		}

		private static void PopulateParseTable()
		{
			parse_table = new Dictionary<int, IDictionary<int, int[]>>();
			TableAddRow(ParserToken.Array);
			TableAddCol(ParserToken.Array, 91, 91, 65549);
			TableAddRow(ParserToken.ArrayPrime);
			TableAddCol(ParserToken.ArrayPrime, 34, 65550, 65551, 93);
			TableAddCol(ParserToken.ArrayPrime, 91, 65550, 65551, 93);
			TableAddCol(ParserToken.ArrayPrime, 93, 93);
			TableAddCol(ParserToken.ArrayPrime, 123, 65550, 65551, 93);
			TableAddCol(ParserToken.ArrayPrime, 65537, 65550, 65551, 93);
			TableAddCol(ParserToken.ArrayPrime, 65538, 65550, 65551, 93);
			TableAddCol(ParserToken.ArrayPrime, 65539, 65550, 65551, 93);
			TableAddCol(ParserToken.ArrayPrime, 65540, 65550, 65551, 93);
			TableAddRow(ParserToken.Object);
			TableAddCol(ParserToken.Object, 123, 123, 65545);
			TableAddRow(ParserToken.ObjectPrime);
			TableAddCol(ParserToken.ObjectPrime, 34, 65546, 65547, 125);
			TableAddCol(ParserToken.ObjectPrime, 125, 125);
			TableAddRow(ParserToken.Pair);
			TableAddCol(ParserToken.Pair, 34, 65552, 58, 65550);
			TableAddRow(ParserToken.PairRest);
			TableAddCol(ParserToken.PairRest, 44, 44, 65546, 65547);
			TableAddCol(ParserToken.PairRest, 125, 65554);
			TableAddRow(ParserToken.String);
			TableAddCol(ParserToken.String, 34, 34, 65541, 34);
			TableAddRow(ParserToken.Text);
			TableAddCol(ParserToken.Text, 91, 65548);
			TableAddCol(ParserToken.Text, 123, 65544);
			TableAddRow(ParserToken.Value);
			TableAddCol(ParserToken.Value, 34, 65552);
			TableAddCol(ParserToken.Value, 91, 65548);
			TableAddCol(ParserToken.Value, 123, 65544);
			TableAddCol(ParserToken.Value, 65537, 65537);
			TableAddCol(ParserToken.Value, 65538, 65538);
			TableAddCol(ParserToken.Value, 65539, 65539);
			TableAddCol(ParserToken.Value, 65540, 65540);
			TableAddRow(ParserToken.ValueRest);
			TableAddCol(ParserToken.ValueRest, 44, 44, 65550, 65551);
			TableAddCol(ParserToken.ValueRest, 93, 65554);
		}

		private static void TableAddCol(ParserToken row, int col, params int[] symbols)
		{
			parse_table[(int)row].Add(col, symbols);
		}

		private static void TableAddRow(ParserToken rule)
		{
			parse_table.Add((int)rule, new Dictionary<int, int[]>());
		}

		private void ProcessNumber(string number)
		{
			int result2;
			long result3;
			ulong result4;
			if ((number.IndexOf('.') != -1 || number.IndexOf('e') != -1 || number.IndexOf('E') != -1) && double.TryParse(number, out var result))
			{
				token = JsonToken.Double;
				token_value = result;
			}
			else if (int.TryParse(number, out result2))
			{
				token = JsonToken.Int;
				token_value = result2;
			}
			else if (long.TryParse(number, out result3))
			{
				token = JsonToken.Long;
				token_value = result3;
			}
			else if (ulong.TryParse(number, out result4))
			{
				token = JsonToken.Long;
				token_value = result4;
			}
			else
			{
				token = JsonToken.Int;
				token_value = 0;
			}
		}

		private void ProcessSymbol()
		{
			if (current_symbol == 91)
			{
				token = JsonToken.ArrayStart;
				parser_return = true;
			}
			else if (current_symbol == 93)
			{
				token = JsonToken.ArrayEnd;
				parser_return = true;
			}
			else if (current_symbol == 123)
			{
				token = JsonToken.ObjectStart;
				parser_return = true;
			}
			else if (current_symbol == 125)
			{
				token = JsonToken.ObjectEnd;
				parser_return = true;
			}
			else if (current_symbol == 34)
			{
				if (parser_in_string)
				{
					parser_in_string = false;
					parser_return = true;
					return;
				}
				if (token == JsonToken.None)
				{
					token = JsonToken.String;
				}
				parser_in_string = true;
			}
			else if (current_symbol == 65541)
			{
				token_value = lexer.StringValue;
			}
			else if (current_symbol == 65539)
			{
				token = JsonToken.Boolean;
				token_value = false;
				parser_return = true;
			}
			else if (current_symbol == 65540)
			{
				token = JsonToken.Null;
				parser_return = true;
			}
			else if (current_symbol == 65537)
			{
				ProcessNumber(lexer.StringValue);
				parser_return = true;
			}
			else if (current_symbol == 65546)
			{
				token = JsonToken.PropertyName;
			}
			else if (current_symbol == 65538)
			{
				token = JsonToken.Boolean;
				token_value = true;
				parser_return = true;
			}
		}

		private bool ReadToken()
		{
			if (end_of_input)
			{
				return false;
			}
			lexer.NextToken();
			if (lexer.EndOfInput)
			{
				Close();
				return false;
			}
			current_input = lexer.Token;
			return true;
		}

		public void Close()
		{
			if (!end_of_input)
			{
				end_of_input = true;
				end_of_json = true;
				if (reader_is_owned)
				{
					reader.Close();
				}
				reader = null;
			}
		}

		public bool Read()
		{
			if (end_of_input)
			{
				return false;
			}
			if (end_of_json)
			{
				end_of_json = false;
				automaton_stack.Clear();
				automaton_stack.Push(65553);
				automaton_stack.Push(65543);
			}
			parser_in_string = false;
			parser_return = false;
			token = JsonToken.None;
			token_value = null;
			if (!read_started)
			{
				read_started = true;
				if (!ReadToken())
				{
					return false;
				}
			}
			while (true)
			{
				if (parser_return)
				{
					if (automaton_stack.Peek() == 65553)
					{
						end_of_json = true;
					}
					return true;
				}
				current_symbol = automaton_stack.Pop();
				ProcessSymbol();
				if (current_symbol == current_input)
				{
					if (!ReadToken())
					{
						break;
					}
					continue;
				}
				int[] array;
				try
				{
					array = parse_table[current_symbol][current_input];
				}
				catch (KeyNotFoundException inner_exception)
				{
					throw new JsonException((ParserToken)current_input, inner_exception);
				}
				if (array[0] != 65554)
				{
					for (int num = array.Length - 1; num >= 0; num--)
					{
						automaton_stack.Push(array[num]);
					}
				}
			}
			if (automaton_stack.Peek() != 65553)
			{
				throw new JsonException("Input doesn't evaluate to proper JSON text");
			}
			if (parser_return)
			{
				return true;
			}
			return false;
		}
	}
	internal enum Condition
	{
		InArray,
		InObject,
		NotAProperty,
		Property,
		Value
	}
	internal class WriterContext
	{
		public int Count;

		public bool InArray;

		public bool InObject;

		public bool ExpectingValue;

		public int Padding;
	}
	internal class JsonWriter
	{
		private static NumberFormatInfo number_format;

		private WriterContext context;

		private Stack<WriterContext> ctx_stack;

		private bool has_reached_end;

		private char[] hex_seq;

		private int indentation;

		private int indent_value;

		private StringBuilder inst_string_builder;

		private bool pretty_print;

		private bool validate;

		private TextWriter writer;

		public int IndentValue
		{
			get
			{
				return indent_value;
			}
			set
			{
				indentation = indentation / indent_value * value;
				indent_value = value;
			}
		}

		public bool PrettyPrint
		{
			get
			{
				return pretty_print;
			}
			set
			{
				pretty_print = value;
			}
		}

		public TextWriter TextWriter => writer;

		public bool Validate
		{
			get
			{
				return validate;
			}
			set
			{
				validate = value;
			}
		}

		static JsonWriter()
		{
			number_format = NumberFormatInfo.InvariantInfo;
		}

		public JsonWriter()
		{
			inst_string_builder = new StringBuilder();
			writer = new StringWriter(inst_string_builder);
			Init();
		}

		public JsonWriter(StringBuilder sb)
			: this(new StringWriter(sb))
		{
		}

		public JsonWriter(TextWriter writer)
		{
			if (writer == null)
			{
				throw new ArgumentNullException("writer");
			}
			this.writer = writer;
			Init();
		}

		private void DoValidation(Condition cond)
		{
			if (!context.ExpectingValue)
			{
				context.Count++;
			}
			if (!validate)
			{
				return;
			}
			if (has_reached_end)
			{
				throw new JsonException("A complete JSON symbol has already been written");
			}
			switch (cond)
			{
			case Condition.InArray:
				if (!context.InArray)
				{
					throw new JsonException("Can't close an array here");
				}
				break;
			case Condition.InObject:
				if (!context.InObject || context.ExpectingValue)
				{
					throw new JsonException("Can't close an object here");
				}
				break;
			case Condition.NotAProperty:
				if (context.InObject && !context.ExpectingValue)
				{
					throw new JsonException("Expected a property");
				}
				break;
			case Condition.Property:
				if (!context.InObject || context.ExpectingValue)
				{
					throw new JsonException("Can't add a property here");
				}
				break;
			case Condition.Value:
				if (!context.InArray && (!context.InObject || !context.ExpectingValue))
				{
					throw new JsonException("Can't add a value here");
				}
				break;
			}
		}

		private void Init()
		{
			has_reached_end = false;
			hex_seq = new char[4];
			indentation = 0;
			indent_value = 4;
			pretty_print = false;
			validate = true;
			ctx_stack = new Stack<WriterContext>();
			context = new WriterContext();
			ctx_stack.Push(context);
		}

		private static void IntToHex(int n, char[] hex)
		{
			for (int i = 0; i < 4; i++)
			{
				int num = n % 16;
				if (num < 10)
				{
					hex[3 - i] = (char)(48 + num);
				}
				else
				{
					hex[3 - i] = (char)(65 + (num - 10));
				}
				n >>= 4;
			}
		}

		private void Indent()
		{
			if (pretty_print)
			{
				indentation += indent_value;
			}
		}

		private void Put(string str)
		{
			if (pretty_print && !context.ExpectingValue)
			{
				for (int i = 0; i < indentation; i++)
				{
					writer.Write(' ');
				}
			}
			writer.Write(str);
		}

		private void PutNewline()
		{
			PutNewline(add_comma: true);
		}

		private void PutNewline(bool add_comma)
		{
			if (add_comma && !context.ExpectingValue && context.Count > 1)
			{
				writer.Write(',');
			}
			if (pretty_print && !context.ExpectingValue)
			{
				writer.Write('\n');
			}
		}

		private void PutString(string str)
		{
			Put(string.Empty);
			writer.Write('"');
			int length = str.Length;
			for (int i = 0; i < length; i++)
			{
				switch (str[i])
				{
				case '\n':
					writer.Write("\\n");
					continue;
				case '\r':
					writer.Write("\\r");
					continue;
				case '\t':
					writer.Write("\\t");
					continue;
				case '"':
				case '\\':
					writer.Write('\\');
					writer.Write(str[i]);
					continue;
				case '\f':
					writer.Write("\\f");
					continue;
				case '\b':
					writer.Write("\\b");
					continue;
				}
				if (str[i] >= ' ' && str[i] <= '~')
				{
					writer.Write(str[i]);
					continue;
				}
				IntToHex(str[i], hex_seq);
				writer.Write("\\u");
				writer.Write(hex_seq);
			}
			writer.Write('"');
		}

		private void Unindent()
		{
			if (pretty_print)
			{
				indentation -= indent_value;
			}
		}

		public override string ToString()
		{
			if (inst_string_builder == null)
			{
				return string.Empty;
			}
			return inst_string_builder.ToString();
		}

		public void Reset()
		{
			has_reached_end = false;
			ctx_stack.Clear();
			context = new WriterContext();
			ctx_stack.Push(context);
			if (inst_string_builder != null)
			{
				inst_string_builder.Remove(0, inst_string_builder.Length);
			}
		}

		public void Write(bool boolean)
		{
			DoValidation(Condition.Value);
			PutNewline();
			Put(boolean ? "true" : "false");
			context.ExpectingValue = false;
		}

		public void Write(decimal number)
		{
			DoValidation(Condition.Value);
			PutNewline();
			Put(Convert.ToString(number, number_format));
			context.ExpectingValue = false;
		}

		public void Write(double number)
		{
			DoValidation(Condition.Value);
			PutNewline();
			string text = Convert.ToString(number, number_format);
			Put(text);
			if (text.IndexOf('.') == -1 && text.IndexOf('E') == -1)
			{
				writer.Write(".0");
			}
			context.ExpectingValue = false;
		}

		public void Write(int number)
		{
			DoValidation(Condition.Value);
			PutNewline();
			Put(Convert.ToString(number, number_format));
			context.ExpectingValue = false;
		}

		public void Write(long number)
		{
			DoValidation(Condition.Value);
			PutNewline();
			Put(Convert.ToString(number, number_format));
			context.ExpectingValue = false;
		}

		public void Write(string str)
		{
			DoValidation(Condition.Value);
			PutNewline();
			if (str == null)
			{
				Put("null");
			}
			else
			{
				PutString(str);
			}
			context.ExpectingValue = false;
		}

		[CLSCompliant(false)]
		public void Write(ulong number)
		{
			DoValidation(Condition.Value);
			PutNewline();
			Put(Convert.ToString(number, number_format));
			context.ExpectingValue = false;
		}

		public void WriteArrayEnd()
		{
			DoValidation(Condition.InArray);
			PutNewline(add_comma: false);
			ctx_stack.Pop();
			if (ctx_stack.Count == 1)
			{
				has_reached_end = true;
			}
			else
			{
				context = ctx_stack.Peek();
				context.ExpectingValue = false;
			}
			Unindent();
			Put("]");
		}

		public void WriteArrayStart()
		{
			DoValidation(Condition.NotAProperty);
			PutNewline();
			Put("[");
			context = new WriterContext();
			context.InArray = true;
			ctx_stack.Push(context);
			Indent();
		}

		public void WriteObjectEnd()
		{
			DoValidation(Condition.InObject);
			PutNewline(add_comma: false);
			ctx_stack.Pop();
			if (ctx_stack.Count == 1)
			{
				has_reached_end = true;
			}
			else
			{
				context = ctx_stack.Peek();
				context.ExpectingValue = false;
			}
			Unindent();
			Put("}");
		}

		public void WriteObjectStart()
		{
			DoValidation(Condition.NotAProperty);
			PutNewline();
			Put("{");
			context = new WriterContext();
			context.InObject = true;
			ctx_stack.Push(context);
			Indent();
		}

		public void WritePropertyName(string property_name)
		{
			DoValidation(Condition.Property);
			PutNewline();
			PutString(property_name);
			if (pretty_print)
			{
				if (property_name.Length > context.Padding)
				{
					context.Padding = property_name.Length;
				}
				for (int num = context.Padding - property_name.Length; num >= 0; num--)
				{
					writer.Write(' ');
				}
				writer.Write(": ");
			}
			else
			{
				writer.Write(':');
			}
			context.ExpectingValue = true;
		}
	}
	internal class FsmContext
	{
		public bool Return;

		public int NextState;

		public Lexer L;

		public int StateStack;
	}
	internal class Lexer
	{
		private delegate bool StateHandler(FsmContext ctx);

		private static int[] fsm_return_table;

		private static StateHandler[] fsm_handler_table;

		private bool allow_comments;

		private bool allow_single_quoted_strings;

		private bool end_of_input;

		private FsmContext fsm_context;

		private int input_buffer;

		private int input_char;

		private TextReader reader;

		private int state;

		private StringBuilder string_buffer;

		private string string_value;

		private int token;

		private int unichar;

		public bool AllowComments
		{
			get
			{
				return allow_comments;
			}
			set
			{
				allow_comments = value;
			}
		}

		public bool AllowSingleQuotedStrings
		{
			get
			{
				return allow_single_quoted_strings;
			}
			set
			{
				allow_single_quoted_strings = value;
			}
		}

		public bool EndOfInput => end_of_input;

		public int Token => token;

		public string StringValue => string_value;

		static Lexer()
		{
			PopulateFsmTables();
		}

		public Lexer(TextReader reader)
		{
			allow_comments = true;
			allow_single_quoted_strings = true;
			input_buffer = 0;
			string_buffer = new StringBuilder(128);
			state = 1;
			end_of_input = false;
			this.reader = reader;
			fsm_context = new FsmContext();
			fsm_context.L = this;
		}

		private static int HexValue(int digit)
		{
			switch (digit)
			{
			case 65:
			case 97:
				return 10;
			case 66:
			case 98:
				return 11;
			case 67:
			case 99:
				return 12;
			case 68:
			case 100:
				return 13;
			case 69:
			case 101:
				return 14;
			case 70:
			case 102:
				return 15;
			default:
				return digit - 48;
			}
		}

		private static void PopulateFsmTables()
		{
			fsm_handler_table = new StateHandler[28]
			{
				State1, State2, State3, State4, State5, State6, State7, State8, State9, State10,
				State11, State12, State13, State14, State15, State16, State17, State18, State19, State20,
				State21, State22, State23, State24, State25, State26, State27, State28
			};
			fsm_return_table = new int[28]
			{
				65542, 0, 65537, 65537, 0, 65537, 0, 65537, 0, 0,
				65538, 0, 0, 0, 65539, 0, 0, 65540, 65541, 65542,
				0, 0, 65541, 65542, 0, 0, 0, 0
			};
		}

		private static char ProcessEscChar(int esc_char)
		{
			switch (esc_char)
			{
			case 34:
			case 39:
			case 47:
			case 92:
				return Convert.ToChar(esc_char);
			case 110:
				return '\n';
			case 116:
				return '\t';
			case 114:
				return '\r';
			case 98:
				return '\b';
			case 102:
				return '\f';
			default:
				return '?';
			}
		}

		private static bool State1(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
				{
					continue;
				}
				if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
				{
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					ctx.NextState = 3;
					return true;
				}
				switch (ctx.L.input_char)
				{
				case 34:
					ctx.NextState = 19;
					ctx.Return = true;
					return true;
				case 44:
				case 58:
				case 91:
				case 93:
				case 123:
				case 125:
					ctx.NextState = 1;
					ctx.Return = true;
					return true;
				case 45:
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					ctx.NextState = 2;
					return true;
				case 48:
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					ctx.NextState = 4;
					return true;
				case 102:
					ctx.NextState = 12;
					return true;
				case 110:
					ctx.NextState = 16;
					return true;
				case 116:
					ctx.NextState = 9;
					return true;
				case 39:
					if (!ctx.L.allow_single_quoted_strings)
					{
						return false;
					}
					ctx.L.input_char = 34;
					ctx.NextState = 23;
					ctx.Return = true;
					return true;
				case 47:
					if (!ctx.L.allow_comments)
					{
						return false;
					}
					ctx.NextState = 25;
					return true;
				default:
					return false;
				}
			}
			return true;
		}

		private static bool State2(FsmContext ctx)
		{
			ctx.L.GetChar();
			if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 3;
				return true;
			}
			int num = ctx.L.input_char;
			if (num == 48)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 4;
				return true;
			}
			return false;
		}

		private static bool State3(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
				{
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					continue;
				}
				if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
				{
					ctx.Return = true;
					ctx.NextState = 1;
					return true;
				}
				switch (ctx.L.input_char)
				{
				case 44:
				case 93:
				case 125:
					ctx.L.UngetChar();
					ctx.Return = true;
					ctx.NextState = 1;
					return true;
				case 46:
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					ctx.NextState = 5;
					return true;
				case 69:
				case 101:
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					ctx.NextState = 7;
					return true;
				default:
					return false;
				}
			}
			return true;
		}

		private static bool State4(FsmContext ctx)
		{
			ctx.L.GetChar();
			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			switch (ctx.L.input_char)
			{
			case 44:
			case 93:
			case 125:
				ctx.L.UngetChar();
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			case 46:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 5;
				return true;
			case 69:
			case 101:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 7;
				return true;
			default:
				return false;
			}
		}

		private static bool State5(FsmContext ctx)
		{
			ctx.L.GetChar();
			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 6;
				return true;
			}
			return false;
		}

		private static bool State6(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
				{
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					continue;
				}
				if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
				{
					ctx.Return = true;
					ctx.NextState = 1;
					return true;
				}
				switch (ctx.L.input_char)
				{
				case 44:
				case 93:
				case 125:
					ctx.L.UngetChar();
					ctx.Return = true;
					ctx.NextState = 1;
					return true;
				case 69:
				case 101:
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					ctx.NextState = 7;
					return true;
				default:
					return false;
				}
			}
			return true;
		}

		private static bool State7(FsmContext ctx)
		{
			ctx.L.GetChar();
			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 8;
				return true;
			}
			switch (ctx.L.input_char)
			{
			case 43:
			case 45:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 8;
				return true;
			default:
				return false;
			}
		}

		private static bool State8(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
				{
					ctx.L.string_buffer.Append((char)ctx.L.input_char);
					continue;
				}
				if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
				{
					ctx.Return = true;
					ctx.NextState = 1;
					return true;
				}
				int num = ctx.L.input_char;
				if (num == 44 || num == 93 || num == 125)
				{
					ctx.L.UngetChar();
					ctx.Return = true;
					ctx.NextState = 1;
					return true;
				}
				return false;
			}
			return true;
		}

		private static bool State9(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 114)
			{
				ctx.NextState = 10;
				return true;
			}
			return false;
		}

		private static bool State10(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 117)
			{
				ctx.NextState = 11;
				return true;
			}
			return false;
		}

		private static bool State11(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 101)
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			return false;
		}

		private static bool State12(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 97)
			{
				ctx.NextState = 13;
				return true;
			}
			return false;
		}

		private static bool State13(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 108)
			{
				ctx.NextState = 14;
				return true;
			}
			return false;
		}

		private static bool State14(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 115)
			{
				ctx.NextState = 15;
				return true;
			}
			return false;
		}

		private static bool State15(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 101)
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			return false;
		}

		private static bool State16(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 117)
			{
				ctx.NextState = 17;
				return true;
			}
			return false;
		}

		private static bool State17(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 108)
			{
				ctx.NextState = 18;
				return true;
			}
			return false;
		}

		private static bool State18(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 108)
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			return false;
		}

		private static bool State19(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				switch (ctx.L.input_char)
				{
				case 34:
					ctx.L.UngetChar();
					ctx.Return = true;
					ctx.NextState = 20;
					return true;
				case 92:
					ctx.StateStack = 19;
					ctx.NextState = 21;
					return true;
				}
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
			}
			return true;
		}

		private static bool State20(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 34)
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			return false;
		}

		private static bool State21(FsmContext ctx)
		{
			ctx.L.GetChar();
			switch (ctx.L.input_char)
			{
			case 117:
				ctx.NextState = 22;
				return true;
			case 34:
			case 39:
			case 47:
			case 92:
			case 98:
			case 102:
			case 110:
			case 114:
			case 116:
				ctx.L.string_buffer.Append(ProcessEscChar(ctx.L.input_char));
				ctx.NextState = ctx.StateStack;
				return true;
			default:
				return false;
			}
		}

		private static bool State22(FsmContext ctx)
		{
			int num = 0;
			int num2 = 4096;
			ctx.L.unichar = 0;
			while (ctx.L.GetChar())
			{
				if ((ctx.L.input_char >= 48 && ctx.L.input_char <= 57) || (ctx.L.input_char >= 65 && ctx.L.input_char <= 70) || (ctx.L.input_char >= 97 && ctx.L.input_char <= 102))
				{
					ctx.L.unichar += HexValue(ctx.L.input_char) * num2;
					num++;
					num2 /= 16;
					if (num == 4)
					{
						ctx.L.string_buffer.Append(Convert.ToChar(ctx.L.unichar));
						ctx.NextState = ctx.StateStack;
						return true;
					}
					continue;
				}
				return false;
			}
			return true;
		}

		private static bool State23(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				switch (ctx.L.input_char)
				{
				case 39:
					ctx.L.UngetChar();
					ctx.Return = true;
					ctx.NextState = 24;
					return true;
				case 92:
					ctx.StateStack = 23;
					ctx.NextState = 21;
					return true;
				}
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
			}
			return true;
		}

		private static bool State24(FsmContext ctx)
		{
			ctx.L.GetChar();
			int num = ctx.L.input_char;
			if (num == 39)
			{
				ctx.L.input_char = 34;
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			return false;
		}

		private static bool State25(FsmContext ctx)
		{
			ctx.L.GetChar();
			switch (ctx.L.input_char)
			{
			case 42:
				ctx.NextState = 27;
				return true;
			case 47:
				ctx.NextState = 26;
				return true;
			default:
				return false;
			}
		}

		private static bool State26(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char == 10)
				{
					ctx.NextState = 1;
					return true;
				}
			}
			return true;
		}

		private static bool State27(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char == 42)
				{
					ctx.NextState = 28;
					return true;
				}
			}
			return true;
		}

		private static bool State28(FsmContext ctx)
		{
			while (ctx.L.GetChar())
			{
				if (ctx.L.input_char != 42)
				{
					if (ctx.L.input_char == 47)
					{
						ctx.NextState = 1;
						return true;
					}
					ctx.NextState = 27;
					return true;
				}
			}
			return true;
		}

		private bool GetChar()
		{
			if ((input_char = NextChar()) != -1)
			{
				return true;
			}
			end_of_input = true;
			return false;
		}

		private int NextChar()
		{
			if (input_buffer != 0)
			{
				int result = input_buffer;
				input_buffer = 0;
				return result;
			}
			return reader.Read();
		}

		public bool NextToken()
		{
			fsm_context.Return = false;
			while (true)
			{
				StateHandler stateHandler = fsm_handler_table[state - 1];
				if (!stateHandler(fsm_context))
				{
					throw new JsonException(input_char);
				}
				if (end_of_input)
				{
					return false;
				}
				if (fsm_context.Return)
				{
					break;
				}
				state = fsm_context.NextState;
			}
			string_value = string_buffer.ToString();
			string_buffer.Remove(0, string_buffer.Length);
			token = fsm_return_table[state - 1];
			if (token == 65542)
			{
				token = input_char;
			}
			state = fsm_context.NextState;
			return true;
		}

		private void UngetChar()
		{
			input_buffer = input_char;
		}
	}
	internal enum ParserToken
	{
		None = 65536,
		Number,
		True,
		False,
		Null,
		CharSeq,
		Char,
		Text,
		Object,
		ObjectPrime,
		Pair,
		PairRest,
		Array,
		ArrayPrime,
		Value,
		ValueRest,
		String,
		End,
		Epsilon
	}
}