using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("PEAK Luggage Items")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PEAK Luggage Items")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2ee823ee-81d0-43ba-91f7-a88355d316cf")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PEAKLuggageItems;

public class ModItemInfo
{
	public string ModGUID { get; set; }

	public ushort ItemID { get; set; }

	public string ItemName { get; set; }

	public int DefaultWeight { get; set; }

	public SpawnPool[] DefaultPools { get; set; }
}
[BepInPlugin("tony4twentys.PEAK_Luggage_Items", "PEAK Luggage Items", "2.1.1")]
public class PEAKLuggageItemsPlugin : BaseUnityPlugin
{
	[HarmonyPatch(typeof(LootData), "PopulateLootData")]
	public static class LootData_PopulateLootData_Patch
	{
		public static void Postfix()
		{
			try
			{
				OverrideItemWeights();
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[PEAK Luggage Items] Error in PopulateLootData patch: {arg}");
			}
		}
	}

	private static ConfigFile config;

	private static Dictionary<ushort, ConfigEntry<int>> itemWeights = new Dictionary<ushort, ConfigEntry<int>>();

	private static Dictionary<ushort, ConfigEntry<string>> itemPools = new Dictionary<ushort, ConfigEntry<string>>();

	private static ConfigEntry<bool> enableDetailedLogging;

	private static Dictionary<string, List<ModItemInfo>> DetectedMods;

	private static Dictionary<string, bool> ModLoadedStatus;

	private static readonly Dictionary<ushort, string> ItemNames;

	private static readonly Dictionary<ushort, int> DefaultWeights;

	private static readonly Dictionary<ushort, SpawnPool[]> DefaultPools;

	private void Awake()
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		config = ((BaseUnityPlugin)this).Config;
		enableDetailedLogging = config.Bind<bool>("Settings", "Enable Detailed Logging", false, "Enable detailed logging for debugging purposes. When disabled, only essential messages are logged.");
		Harmony val = new Harmony("tony4twentys.PEAK_Luggage_Items");
		val.PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin tony4twentys.PEAK_Luggage_Items is loaded!");
	}

	private void Start()
	{
		DetectAndLoadModItems();
	}

	private void DetectAndLoadModItems()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Detecting installed mods for automatic item integration...");
		List<ModItemInfo> list = new List<ModItemInfo>();
		List<ModItemInfo> list2 = new List<ModItemInfo>();
		foreach (KeyValuePair<string, List<ModItemInfo>> detectedMod in DetectedMods)
		{
			string key = detectedMod.Key;
			List<ModItemInfo> value = detectedMod.Value;
			bool flag = ModLoadedStatus.ContainsKey(key) && ModLoadedStatus[key];
			bool flag2 = CheckMod(key);
			ModLoadedStatus[key] = flag2;
			if (flag2)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Mod detected: {key} - Adding {value.Count} items to configuration");
				foreach (ModItemInfo item in value)
				{
					list2.Add(item);
					LogDetailed($"  - Processing {item.ItemName} (ID: {item.ItemID}, Weight: {item.DefaultWeight})");
					if (!ItemNames.ContainsKey(item.ItemID))
					{
						ItemNames[item.ItemID] = item.ItemName;
						LogDetailed("    - Added to ItemNames dictionary");
					}
					else
					{
						LogDetailed("    - Already exists in ItemNames dictionary");
					}
					if (!DefaultWeights.ContainsKey(item.ItemID))
					{
						DefaultWeights[item.ItemID] = item.DefaultWeight;
						LogDetailed("    - Added to DefaultWeights dictionary");
					}
					else
					{
						LogDetailed("    - Already exists in DefaultWeights dictionary");
					}
					if (!DefaultPools.ContainsKey(item.ItemID))
					{
						DefaultPools[item.ItemID] = item.DefaultPools;
						LogDetailed("    - Added to DefaultPools dictionary");
					}
					else
					{
						LogDetailed("    - Already exists in DefaultPools dictionary");
					}
					LogDetailed($"  - Successfully processed {item.ItemName} (ID: {item.ItemID})");
				}
				continue;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Mod not detected: {key} - Will remove {value.Count} items from configuration");
			foreach (ModItemInfo item2 in value)
			{
				list.Add(item2);
				LogDetailed($"  - Will remove {item2.ItemName} (ID: {item2.ItemID})");
			}
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Setting up configuration entries for detected mod items...");
		SetupConfigs();
		if (list.Count > 0)
		{
			CleanConfigFile(list);
		}
	}

	private void CleanConfigFile(List<ModItemInfo> undetectedMods)
	{
		try
		{
			string configFilePath = config.ConfigFilePath;
			string text = configFilePath.Replace(".cfg", "_backup.cfg");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Cleaning config file of {undetectedMods.Count} undetected mod items...");
			LogDetailed("Config path: " + configFilePath);
			LogDetailed("Backup path: " + text);
			if (File.Exists(configFilePath))
			{
				File.Copy(configFilePath, text, overwrite: true);
				LogDetailed("Backup created successfully");
				List<string> list = File.ReadAllLines(text).ToList();
				List<string> list2 = new List<string>();
				HashSet<string> hashSet = undetectedMods.Select((ModItemInfo m) => SanitizeConfigKey(m.ItemName)).ToHashSet();
				LogDetailed("Items to remove (sanitized): " + string.Join(", ", hashSet));
				bool flag = false;
				int num = 0;
				foreach (string item2 in list)
				{
					if (item2.Contains("## Spawn weight for ") || item2.Contains("## Spawn pools for "))
					{
						Match match = Regex.Match(item2, "## Spawn (weight|pools) for ([^(]+)");
						if (match.Success)
						{
							string text2 = match.Groups[2].Value.Trim();
							string item = SanitizeConfigKey(text2);
							flag = hashSet.Contains(item);
							if (flag)
							{
								LogDetailed("Removing config entries for: " + text2);
								num++;
								continue;
							}
						}
					}
					else if (item2.Contains(" Weight =") || item2.Contains(" Pools ="))
					{
						foreach (string item3 in hashSet)
						{
							if (item2.Contains(item3 + " Weight =") || item2.Contains(item3 + " Pools ="))
							{
								LogDetailed("Removing direct config entry: " + item2.Trim());
								num++;
								flag = true;
								break;
							}
						}
						if (flag)
						{
							continue;
						}
					}
					if (flag)
					{
						if (item2.Trim() == "" || item2.StartsWith("[") || item2.StartsWith("##"))
						{
							flag = false;
						}
					}
					else
					{
						list2.Add(item2);
					}
				}
				LogDetailed($"Removed {num} item sections from config");
				File.WriteAllLines(configFilePath, list2);
				LogDetailed("Cleaned config written to file");
				foreach (ModItemInfo undetectedMod in undetectedMods)
				{
					ItemNames.Remove(undetectedMod.ItemID);
					DefaultWeights.Remove(undetectedMod.ItemID);
					DefaultPools.Remove(undetectedMod.ItemID);
					LogDetailed($"Removed {undetectedMod.ItemName} (ID: {undetectedMod.ItemID}) from dictionaries");
				}
				if (File.Exists(text))
				{
					File.Delete(text);
					LogDetailed("Backup file deleted: " + text);
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Config file cleaned successfully. Removed {undetectedMods.Count} undetected mod items.");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Config file does not exist, nothing to clean");
			}
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Failed to clean config file: " + ex.Message));
			((BaseUnityPlugin)this).Logger.LogError((object)("Stack trace: " + ex.StackTrace));
		}
	}

	private bool CheckMod(string modGUID)
	{
		try
		{
			return Chainloader.PluginInfos.ContainsKey(modGUID);
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Error checking mod " + modGUID + ": " + ex.Message));
			return false;
		}
	}

	private string SanitizeConfigKey(string name)
	{
		return name.Replace("'", "").Replace("\"", "").Replace("=", "")
			.Replace("\n", "")
			.Replace("\t", "")
			.Replace("\\", "")
			.Replace("[", "")
			.Replace("]", "");
	}

	private void LogDetailed(string message)
	{
		if (enableDetailedLogging.Value)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)message);
		}
	}

	private void LogDetailedWarning(string message)
	{
		if (enableDetailedLogging.Value)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)message);
		}
	}

	private void LogDetailedError(string message)
	{
		if (enableDetailedLogging.Value)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)message);
		}
	}

	private void SetupConfigs()
	{
		LogDetailed("Starting SetupConfigs...");
		List<KeyValuePair<ushort, string>> list = ItemNames.OrderBy((KeyValuePair<ushort, string> x) => x.Value).ToList();
		LogDetailed($"Processing {list.Count} items for config setup");
		foreach (KeyValuePair<ushort, string> item in list)
		{
			ushort id = item.Key;
			string value = item.Value;
			int num = (DefaultWeights.ContainsKey(id) ? DefaultWeights[id] : 0);
			SpawnPool[] source;
			if (DefaultPools.ContainsKey(id))
			{
				source = DefaultPools[id];
			}
			else
			{
				SpawnPool[] array = new SpawnPool[7];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				source = (SpawnPool[])(object)array;
			}
			string text = "Item Weights";
			string text2 = "Item Spawn Pools";
			if (DetectedMods.Values.Any((List<ModItemInfo> itemList) => itemList.Any((ModItemInfo mod) => mod.ItemID == id)))
			{
				text = "Detected Mods Item Weights";
				text2 = "Detected Mods Item Spawn Pools";
			}
			string text3 = SanitizeConfigKey(value);
			try
			{
				itemWeights[id] = config.Bind<int>(text, text3 + " Weight", num, "Spawn weight for " + value + " (0 = disabled)");
				LogDetailed("  - Successfully bound weight config for " + value + " (key: " + text3 + ")");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("  - Failed to bind weight config for " + value + " (key: " + text3 + "): " + ex.Message));
			}
			string text4 = string.Join(",", source.Select((SpawnPool p) => ((object)(SpawnPool)(ref p)).ToString()));
			try
			{
				itemPools[id] = config.Bind<string>(text2, text3 + " Pools", text4, "Spawn pools for " + value + " (comma-separated: LuggageBeach, LuggageJungle, etc.)");
				LogDetailed("  - Successfully bound pool config for " + value + " (key: " + text3 + ")");
			}
			catch (Exception ex2)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("  - Failed to bind pool config for " + value + " (key: " + text3 + "): " + ex2.Message));
			}
		}
	}

	private static void OverrideItemWeights()
	{
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: 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_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		if (LootData.AllSpawnWeightData == null)
		{
			return;
		}
		SpawnPool[] array = new SpawnPool[9];
		RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		SpawnPool[] array2 = (SpawnPool[])(object)array;
		foreach (KeyValuePair<ushort, string> itemName in ItemNames)
		{
			ushort key = itemName.Key;
			string value = itemName.Value;
			if (!itemWeights.ContainsKey(key) || !itemPools.ContainsKey(key))
			{
				continue;
			}
			int value2 = itemWeights[key].Value;
			string value3 = itemPools[key].Value;
			SpawnPool[] array3 = array2;
			foreach (SpawnPool key2 in array3)
			{
				if (LootData.AllSpawnWeightData.ContainsKey(key2) && LootData.AllSpawnWeightData[key2].ContainsKey(key))
				{
					LootData.AllSpawnWeightData[key2].Remove(key);
				}
			}
			if (value2 == 0)
			{
				continue;
			}
			List<SpawnPool> list = new List<SpawnPool>();
			if (!string.IsNullOrEmpty(value3))
			{
				string[] array4 = value3.Split(new char[1] { ',' });
				string[] array5 = array4;
				foreach (string text in array5)
				{
					if (Enum.TryParse<SpawnPool>(text.Trim(), out SpawnPool result))
					{
						list.Add(result);
					}
				}
			}
			foreach (SpawnPool item in list)
			{
				if (LootData.AllSpawnWeightData.ContainsKey(item) && array2.Contains(item))
				{
					LootData.AllSpawnWeightData[item][key] = value2;
				}
			}
		}
	}

	static PEAKLuggageItemsPlugin()
	{
		Dictionary<string, List<ModItemInfo>> dictionary = new Dictionary<string, List<ModItemInfo>>();
		List<ModItemInfo> list = new List<ModItemInfo>();
		List<ModItemInfo> list2 = list;
		ModItemInfo modItemInfo = new ModItemInfo
		{
			ModGUID = "spidersgeorg-RarityRoulette",
			ItemID = 39393,
			ItemName = "Revolver",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo2 = modItemInfo;
		SpawnPool[] array = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo2.DefaultPools = (SpawnPool[])(object)array;
		list2.Add(modItemInfo);
		dictionary.Add("spidersgeorg-RarityRoulette", list);
		list = new List<ModItemInfo>();
		List<ModItemInfo> list3 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.khakixd.firstaid",
			ItemID = 33647,
			ItemName = "Melatonin",
			DefaultWeight = 50
		};
		ModItemInfo modItemInfo3 = modItemInfo;
		SpawnPool[] array2 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo3.DefaultPools = (SpawnPool[])(object)array2;
		list3.Add(modItemInfo);
		List<ModItemInfo> list4 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.khakixd.firstaid",
			ItemID = 22534,
			ItemName = "Pain Killers",
			DefaultWeight = 20
		};
		ModItemInfo modItemInfo4 = modItemInfo;
		SpawnPool[] array3 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo4.DefaultPools = (SpawnPool[])(object)array3;
		list4.Add(modItemInfo);
		dictionary.Add("com.khakixd.firstaid", list);
		list = new List<ModItemInfo>();
		List<ModItemInfo> list5 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.quackandcheese.Glizzy",
			ItemID = 33466,
			ItemName = "Glizzy",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo5 = modItemInfo;
		SpawnPool[] array4 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array4, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo5.DefaultPools = (SpawnPool[])(object)array4;
		list5.Add(modItemInfo);
		dictionary.Add("com.github.quackandcheese.Glizzy", list);
		list = new List<ModItemInfo>();
		List<ModItemInfo> list6 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 21719,
			ItemName = "Sticky Plaster",
			DefaultWeight = 50
		};
		ModItemInfo modItemInfo6 = modItemInfo;
		SpawnPool[] array5 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array5, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo6.DefaultPools = (SpawnPool[])(object)array5;
		list6.Add(modItemInfo);
		List<ModItemInfo> list7 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 6082,
			ItemName = "Ice Cream",
			DefaultWeight = 30
		};
		ModItemInfo modItemInfo7 = modItemInfo;
		SpawnPool[] array6 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array6, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo7.DefaultPools = (SpawnPool[])(object)array6;
		list7.Add(modItemInfo);
		List<ModItemInfo> list8 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 43181,
			ItemName = "Popscicle Stick",
			DefaultWeight = 0
		};
		ModItemInfo modItemInfo8 = modItemInfo;
		SpawnPool[] array7 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array7, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo8.DefaultPools = (SpawnPool[])(object)array7;
		list8.Add(modItemInfo);
		List<ModItemInfo> list9 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 40176,
			ItemName = "Gobstopper",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo9 = modItemInfo;
		SpawnPool[] array8 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array8, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo9.DefaultPools = (SpawnPool[])(object)array8;
		list9.Add(modItemInfo);
		List<ModItemInfo> list10 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 62465,
			ItemName = "Salty Chrisps",
			DefaultWeight = 30
		};
		ModItemInfo modItemInfo10 = modItemInfo;
		SpawnPool[] array9 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array9, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo10.DefaultPools = (SpawnPool[])(object)array9;
		list10.Add(modItemInfo);
		List<ModItemInfo> list11 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 42692,
			ItemName = "Flaming Hot Chrips",
			DefaultWeight = 30
		};
		ModItemInfo modItemInfo11 = modItemInfo;
		SpawnPool[] array10 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array10, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo11.DefaultPools = (SpawnPool[])(object)array10;
		list11.Add(modItemInfo);
		List<ModItemInfo> list12 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 49222,
			ItemName = "Climbers Chalk",
			DefaultWeight = 20
		};
		ModItemInfo modItemInfo12 = modItemInfo;
		SpawnPool[] array11 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array11, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo12.DefaultPools = (SpawnPool[])(object)array11;
		list12.Add(modItemInfo);
		list.Add(new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 32214,
			ItemName = "Anti-Grav Shroom",
			DefaultWeight = 15,
			DefaultPools = (SpawnPool[])(object)new SpawnPool[2]
			{
				(SpawnPool)131072,
				(SpawnPool)65536
			}
		});
		List<ModItemInfo> list13 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 28995,
			ItemName = "Can O Beans",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo13 = modItemInfo;
		SpawnPool[] array12 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array12, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo13.DefaultPools = (SpawnPool[])(object)array12;
		list13.Add(modItemInfo);
		List<ModItemInfo> list14 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 31890,
			ItemName = "Extra Extreme Energy Drink",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo14 = modItemInfo;
		SpawnPool[] array13 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array13, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo14.DefaultPools = (SpawnPool[])(object)array13;
		list14.Add(modItemInfo);
		List<ModItemInfo> list15 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 60459,
			ItemName = "Watermelon",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo15 = modItemInfo;
		SpawnPool[] array14 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array14, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo15.DefaultPools = (SpawnPool[])(object)array14;
		list15.Add(modItemInfo);
		List<ModItemInfo> list16 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 29337,
			ItemName = "Watermelon Slice",
			DefaultWeight = 30
		};
		ModItemInfo modItemInfo16 = modItemInfo;
		SpawnPool[] array15 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array15, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo16.DefaultPools = (SpawnPool[])(object)array15;
		list16.Add(modItemInfo);
		List<ModItemInfo> list17 = list;
		modItemInfo = new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 27734,
			ItemName = "Chicken Drumstick",
			DefaultWeight = 15
		};
		ModItemInfo modItemInfo17 = modItemInfo;
		SpawnPool[] array16 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array16, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		modItemInfo17.DefaultPools = (SpawnPool[])(object)array16;
		list17.Add(modItemInfo);
		list.Add(new ModItemInfo
		{
			ModGUID = "com.github.BurningSulphur.Scouting4Food",
			ItemID = 45382,
			ItemName = "Ice Axe",
			DefaultWeight = 30,
			DefaultPools = (SpawnPool[])(object)new SpawnPool[2]
			{
				(SpawnPool)4096,
				(SpawnPool)8192
			}
		});
		dictionary.Add("com.github.BurningSulphur.Scouting4Food", list);
		DetectedMods = dictionary;
		ModLoadedStatus = new Dictionary<string, bool>();
		ItemNames = new Dictionary<ushort, string>
		{
			{ 0, "Airplane Food" },
			{ 1, "Anti-Rope Spool" },
			{ 2, "Antidote" },
			{ 3, "Green Crispberry" },
			{ 4, "Red Crispberry" },
			{ 5, "Yellow Crispberry" },
			{ 6, "Backpack" },
			{ 7, "Bandages" },
			{ 8, "Beehive" },
			{ 9, "Blue Berrynana" },
			{ 10, "Brown Berrynana" },
			{ 11, "Pink Berrynana" },
			{ 12, "Yellow Berrynana" },
			{ 13, "Bing Bong" },
			{ 14, "Binoculars" },
			{ 15, "Bugle" },
			{ 16, "Bugle of Friendship" },
			{ 17, "Chain Launcher" },
			{ 18, "Piton" },
			{ 19, "Black Clusterberry" },
			{ 20, "Red Clusterberry" },
			{ 21, "Yellow Clusterberry" },
			{ 22, "Green Clusterberry" },
			{ 23, "Compass" },
			{ 24, "Cure-All" },
			{ 25, "Cursed Skull" },
			{ 26, "Egg" },
			{ 27, "Energy Drink" },
			{ 28, "Stick" },
			{ 29, "First Aid Kit" },
			{ 30, "Seagull Flag" },
			{ 31, "Pink Berrynana Peel" },
			{ 32, "Flare" },
			{ 33, "Granola Bar" },
			{ 34, "Guidebook" },
			{ 35, "Heat Pack" },
			{ 36, "Coconut" },
			{ 37, "Balloon Bunch" },
			{ 38, "Honeycomb" },
			{ 39, "Cactus Ball" },
			{ 40, "Purple Kingberry" },
			{ 41, "Yellow Kingberry" },
			{ 42, "Lantern" },
			{ 43, "Faerie Lantern" },
			{ 44, "Lollipop" },
			{ 45, "Magic Bean" },
			{ 46, "Marshmallow" },
			{ 47, "Ancient Idol" },
			{ 48, "Basketball" },
			{ 49, "Scroll" },
			{ 50, "Torn Page 1" },
			{ 51, "Glowshroom" },
			{ 52, "Torn Page 3" },
			{ 53, "Torn Page 4" },
			{ 54, "Torn Page 8" },
			{ 55, "Coconut Half" },
			{ 56, "Green Kingberry" },
			{ 57, "Big Egg" },
			{ 58, "Pandoras Lunchbox" },
			{ 59, "Passport" },
			{ 60, "Scorchberry" },
			{ 61, "Pirates Compass" },
			{ 62, "Portable Stove" },
			{ 63, "Rope Cannon" },
			{ 64, "Anti-Rope Cannon" },
			{ 65, "Rope Spool" },
			{ 66, "Scout Cookies" },
			{ 67, "Scout Effigy" },
			{ 68, "Shelf Fungus" },
			{ 69, "Conch" },
			{ 70, "Blowgun" },
			{ 71, "Sports Drink" },
			{ 72, "Stone" },
			{ 73, "Trail Mix" },
			{ 74, "Warp Compass" },
			{ 75, "Orange Winterberry" },
			{ 76, "Yellow Winterberry" },
			{ 77, "Scoutmasters Bugle" },
			{ 78, "Megaphone" },
			{ 79, "Bounce Fungus" },
			{ 80, "Torn Page Blank" },
			{ 81, "Medicinal Root" },
			{ 82, "Torn Page 2" },
			{ 83, "Chubby Mushroom" },
			{ 84, "Poisonous Clustershroom" },
			{ 85, "Torn Page 5" },
			{ 86, "Torn Page 6" },
			{ 87, "Torn Page 7" },
			{ 88, "Clustershroom" },
			{ 89, "Poisonous Bugleshroom" },
			{ 90, "Remedy Fungus" },
			{ 91, "Blue Berrynana Peel" },
			{ 92, "Brown Berrynana Peel" },
			{ 93, "Bugleshroom" },
			{ 94, "Yellow Berrynana Peel" },
			{ 95, "Tick" },
			{ 96, "Torn Page 9" },
			{ 97, "Poisonous Buttonshroom" },
			{ 98, "Parasol" },
			{ 99, "Frisbee" },
			{ 100, "Rescue Hook" },
			{ 101, "Aloe Vera" },
			{ 102, "Buttonshroom" },
			{ 103, "Gold Prickleberry" },
			{ 104, "Sunscreen" },
			{ 105, "Balloon" },
			{ 106, "Dynamite" },
			{ 107, "Scout Cannon" },
			{ 108, "Red Prickleberry" },
			{ 109, "Torch" },
			{ 110, "Napberry" },
			{ 111, "Scorpion" },
			{ 112, "Strange Gem" },
			{ 114, "Roasted Bird" },
			{ 113, "Cheat Compass" },
			{ 115, "Bishop Black" },
			{ 116, "Bishop White" },
			{ 117, "King Black" },
			{ 118, "King White" },
			{ 119, "Knight Black" },
			{ 120, "Knight White" },
			{ 121, "Pawn Black" },
			{ 122, "Pawn White" },
			{ 123, "Queen Black" },
			{ 124, "Queen White" },
			{ 125, "Rook Black" },
			{ 126, "Rook White" },
			{ 127, "Turtle Flag" },
			{ 128, "BingBong Prop" },
			{ 129, "Binoculars Prop" },
			{ 130, "Bugle Prop" },
			{ 131, "Lollipop Prop" }
		};
		DefaultWeights = new Dictionary<ushort, int>
		{
			{ 0, 15 },
			{ 1, 15 },
			{ 2, 30 },
			{ 3, 0 },
			{ 4, 0 },
			{ 5, 0 },
			{ 6, 30 },
			{ 7, 50 },
			{ 8, 0 },
			{ 9, 0 },
			{ 10, 0 },
			{ 11, 0 },
			{ 12, 0 },
			{ 13, 0 },
			{ 14, 0 },
			{ 15, 0 },
			{ 16, 15 },
			{ 17, 15 },
			{ 18, 20 },
			{ 19, 0 },
			{ 20, 0 },
			{ 21, 0 },
			{ 22, 0 },
			{ 23, 0 },
			{ 24, 15 },
			{ 25, 15 },
			{ 26, 0 },
			{ 27, 30 },
			{ 28, 0 },
			{ 29, 20 },
			{ 30, 0 },
			{ 31, 0 },
			{ 32, 15 },
			{ 33, 30 },
			{ 34, 0 },
			{ 35, 100 },
			{ 36, 0 },
			{ 37, 5 },
			{ 38, 0 },
			{ 39, 0 },
			{ 40, 0 },
			{ 41, 0 },
			{ 42, 20 },
			{ 43, 15 },
			{ 44, 15 },
			{ 45, 0 },
			{ 46, 0 },
			{ 47, 1 },
			{ 48, 0 },
			{ 49, 0 },
			{ 50, 0 },
			{ 51, 0 },
			{ 52, 0 },
			{ 53, 0 },
			{ 54, 0 },
			{ 55, 0 },
			{ 56, 0 },
			{ 57, 0 },
			{ 58, 15 },
			{ 59, 0 },
			{ 60, 0 },
			{ 61, 1 },
			{ 62, 15 },
			{ 63, 15 },
			{ 64, 15 },
			{ 65, 30 },
			{ 66, 15 },
			{ 67, 15 },
			{ 68, 0 },
			{ 69, 0 },
			{ 70, 5 },
			{ 71, 50 },
			{ 72, 0 },
			{ 73, 50 },
			{ 74, 0 },
			{ 75, 0 },
			{ 76, 0 },
			{ 77, 1 },
			{ 78, 0 },
			{ 79, 0 },
			{ 80, 0 },
			{ 81, 0 },
			{ 82, 0 },
			{ 83, 0 },
			{ 84, 0 },
			{ 85, 0 },
			{ 86, 0 },
			{ 87, 0 },
			{ 88, 0 },
			{ 89, 0 },
			{ 90, 0 },
			{ 91, 0 },
			{ 92, 0 },
			{ 93, 0 },
			{ 94, 0 },
			{ 95, 0 },
			{ 96, 0 },
			{ 97, 0 },
			{ 98, 20 },
			{ 99, 0 },
			{ 100, 30 },
			{ 101, 0 },
			{ 102, 0 },
			{ 103, 0 },
			{ 104, 20 },
			{ 105, 20 },
			{ 106, 15 },
			{ 107, 15 },
			{ 108, 0 },
			{ 109, 0 },
			{ 110, 0 },
			{ 111, 0 },
			{ 112, 0 },
			{ 114, 0 },
			{ 113, 0 },
			{ 115, 0 },
			{ 116, 0 },
			{ 117, 0 },
			{ 118, 0 },
			{ 119, 0 },
			{ 120, 0 },
			{ 121, 0 },
			{ 122, 0 },
			{ 123, 0 },
			{ 124, 0 },
			{ 125, 0 },
			{ 126, 0 },
			{ 127, 0 },
			{ 128, 0 },
			{ 129, 0 },
			{ 130, 0 },
			{ 131, 0 }
		};
		Dictionary<ushort, SpawnPool[]> dictionary2 = new Dictionary<ushort, SpawnPool[]>();
		SpawnPool[] array17 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array17, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(0, (SpawnPool[])(object)array17);
		dictionary2.Add(1, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		dictionary2.Add(2, (SpawnPool[])(object)new SpawnPool[1] { (SpawnPool)2048 });
		SpawnPool[] array18 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array18, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(3, (SpawnPool[])(object)array18);
		SpawnPool[] array19 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array19, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(4, (SpawnPool[])(object)array19);
		SpawnPool[] array20 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array20, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(5, (SpawnPool[])(object)array20);
		SpawnPool[] array21 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array21, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(6, (SpawnPool[])(object)array21);
		SpawnPool[] array22 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array22, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(7, (SpawnPool[])(object)array22);
		SpawnPool[] array23 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array23, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(8, (SpawnPool[])(object)array23);
		SpawnPool[] array24 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array24, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(9, (SpawnPool[])(object)array24);
		SpawnPool[] array25 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array25, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(10, (SpawnPool[])(object)array25);
		SpawnPool[] array26 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array26, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(11, (SpawnPool[])(object)array26);
		SpawnPool[] array27 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array27, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(12, (SpawnPool[])(object)array27);
		SpawnPool[] array28 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array28, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(13, (SpawnPool[])(object)array28);
		SpawnPool[] array29 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array29, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(14, (SpawnPool[])(object)array29);
		SpawnPool[] array30 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array30, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(15, (SpawnPool[])(object)array30);
		dictionary2.Add(16, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array31 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array31, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(17, (SpawnPool[])(object)array31);
		SpawnPool[] array32 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array32, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(18, (SpawnPool[])(object)array32);
		SpawnPool[] array33 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array33, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(19, (SpawnPool[])(object)array33);
		SpawnPool[] array34 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array34, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(20, (SpawnPool[])(object)array34);
		SpawnPool[] array35 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array35, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(21, (SpawnPool[])(object)array35);
		SpawnPool[] array36 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array36, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(22, (SpawnPool[])(object)array36);
		SpawnPool[] array37 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array37, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(23, (SpawnPool[])(object)array37);
		dictionary2.Add(24, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		dictionary2.Add(25, (SpawnPool[])(object)new SpawnPool[1] { (SpawnPool)65536 });
		SpawnPool[] array38 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array38, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(26, (SpawnPool[])(object)array38);
		SpawnPool[] array39 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array39, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(27, (SpawnPool[])(object)array39);
		SpawnPool[] array40 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array40, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(28, (SpawnPool[])(object)array40);
		SpawnPool[] array41 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array41, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(29, (SpawnPool[])(object)array41);
		SpawnPool[] array42 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array42, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(30, (SpawnPool[])(object)array42);
		SpawnPool[] array43 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array43, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(31, (SpawnPool[])(object)array43);
		SpawnPool[] array44 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array44, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(32, (SpawnPool[])(object)array44);
		SpawnPool[] array45 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array45, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(33, (SpawnPool[])(object)array45);
		dictionary2.Add(35, (SpawnPool[])(object)new SpawnPool[1] { (SpawnPool)4096 });
		SpawnPool[] array46 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array46, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(36, (SpawnPool[])(object)array46);
		SpawnPool[] array47 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array47, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(37, (SpawnPool[])(object)array47);
		SpawnPool[] array48 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array48, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(38, (SpawnPool[])(object)array48);
		SpawnPool[] array49 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array49, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(39, (SpawnPool[])(object)array49);
		SpawnPool[] array50 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array50, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(40, (SpawnPool[])(object)array50);
		SpawnPool[] array51 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array51, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(41, (SpawnPool[])(object)array51);
		dictionary2.Add(42, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)2048,
			(SpawnPool)4096
		});
		dictionary2.Add(43, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array52 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array52, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(44, (SpawnPool[])(object)array52);
		SpawnPool[] array53 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array53, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(45, (SpawnPool[])(object)array53);
		SpawnPool[] array54 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array54, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(46, (SpawnPool[])(object)array54);
		dictionary2.Add(47, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array55 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array55, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(48, (SpawnPool[])(object)array55);
		SpawnPool[] array56 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array56, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(49, (SpawnPool[])(object)array56);
		SpawnPool[] array57 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array57, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(50, (SpawnPool[])(object)array57);
		SpawnPool[] array58 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array58, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(51, (SpawnPool[])(object)array58);
		SpawnPool[] array59 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array59, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(52, (SpawnPool[])(object)array59);
		SpawnPool[] array60 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array60, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(53, (SpawnPool[])(object)array60);
		SpawnPool[] array61 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array61, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(54, (SpawnPool[])(object)array61);
		SpawnPool[] array62 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array62, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(55, (SpawnPool[])(object)array62);
		SpawnPool[] array63 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array63, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(56, (SpawnPool[])(object)array63);
		SpawnPool[] array64 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array64, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(57, (SpawnPool[])(object)array64);
		dictionary2.Add(58, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array65 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array65, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(59, (SpawnPool[])(object)array65);
		SpawnPool[] array66 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array66, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(60, (SpawnPool[])(object)array66);
		SpawnPool[] array67 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array67, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(61, (SpawnPool[])(object)array67);
		SpawnPool[] array68 = new SpawnPool[4];
		RuntimeHelpers.InitializeArray(array68, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(62, (SpawnPool[])(object)array68);
		SpawnPool[] array69 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array69, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(63, (SpawnPool[])(object)array69);
		dictionary2.Add(64, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array70 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array70, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(65, (SpawnPool[])(object)array70);
		SpawnPool[] array71 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array71, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(66, (SpawnPool[])(object)array71);
		SpawnPool[] array72 = new SpawnPool[3];
		RuntimeHelpers.InitializeArray(array72, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(67, (SpawnPool[])(object)array72);
		SpawnPool[] array73 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array73, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(68, (SpawnPool[])(object)array73);
		SpawnPool[] array74 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array74, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(69, (SpawnPool[])(object)array74);
		SpawnPool[] array75 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array75, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(70, (SpawnPool[])(object)array75);
		SpawnPool[] array76 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array76, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(71, (SpawnPool[])(object)array76);
		SpawnPool[] array77 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array77, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(72, (SpawnPool[])(object)array77);
		SpawnPool[] array78 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array78, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(73, (SpawnPool[])(object)array78);
		dictionary2.Add(74, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array79 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array79, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(75, (SpawnPool[])(object)array79);
		SpawnPool[] array80 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array80, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(76, (SpawnPool[])(object)array80);
		dictionary2.Add(77, (SpawnPool[])(object)new SpawnPool[2]
		{
			(SpawnPool)65536,
			(SpawnPool)131072
		});
		SpawnPool[] array81 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array81, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(78, (SpawnPool[])(object)array81);
		SpawnPool[] array82 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array82, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(79, (SpawnPool[])(object)array82);
		SpawnPool[] array83 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array83, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(80, (SpawnPool[])(object)array83);
		SpawnPool[] array84 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array84, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(81, (SpawnPool[])(object)array84);
		SpawnPool[] array85 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array85, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(82, (SpawnPool[])(object)array85);
		SpawnPool[] array86 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array86, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(83, (SpawnPool[])(object)array86);
		SpawnPool[] array87 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array87, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(84, (SpawnPool[])(object)array87);
		SpawnPool[] array88 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array88, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(85, (SpawnPool[])(object)array88);
		SpawnPool[] array89 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array89, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(86, (SpawnPool[])(object)array89);
		SpawnPool[] array90 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array90, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(87, (SpawnPool[])(object)array90);
		SpawnPool[] array91 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array91, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(88, (SpawnPool[])(object)array91);
		SpawnPool[] array92 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array92, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(89, (SpawnPool[])(object)array92);
		SpawnPool[] array93 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array93, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(90, (SpawnPool[])(object)array93);
		SpawnPool[] array94 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array94, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(91, (SpawnPool[])(object)array94);
		SpawnPool[] array95 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array95, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(92, (SpawnPool[])(object)array95);
		SpawnPool[] array96 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array96, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(93, (SpawnPool[])(object)array96);
		SpawnPool[] array97 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array97, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(94, (SpawnPool[])(object)array97);
		SpawnPool[] array98 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array98, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(95, (SpawnPool[])(object)array98);
		SpawnPool[] array99 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array99, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(96, (SpawnPool[])(object)array99);
		SpawnPool[] array100 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array100, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(97, (SpawnPool[])(object)array100);
		dictionary2.Add(98, (SpawnPool[])(object)new SpawnPool[1] { (SpawnPool)16777216 });
		SpawnPool[] array101 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array101, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(99, (SpawnPool[])(object)array101);
		SpawnPool[] array102 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array102, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(100, (SpawnPool[])(object)array102);
		SpawnPool[] array103 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array103, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(101, (SpawnPool[])(object)array103);
		SpawnPool[] array104 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array104, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(102, (SpawnPool[])(object)array104);
		SpawnPool[] array105 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array105, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(103, (SpawnPool[])(object)array105);
		dictionary2.Add(104, (SpawnPool[])(object)new SpawnPool[1] { (SpawnPool)16777216 });
		SpawnPool[] array106 = new SpawnPool[5];
		RuntimeHelpers.InitializeArray(array106, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(105, (SpawnPool[])(object)array106);
		dictionary2.Add(106, (SpawnPool[])(object)new SpawnPool[1] { (SpawnPool)16777216 });
		SpawnPool[] array107 = new SpawnPool[6];
		RuntimeHelpers.InitializeArray(array107, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(107, (SpawnPool[])(object)array107);
		SpawnPool[] array108 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array108, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(108, (SpawnPool[])(object)array108);
		SpawnPool[] array109 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array109, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(109, (SpawnPool[])(object)array109);
		SpawnPool[] array110 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array110, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(110, (SpawnPool[])(object)array110);
		SpawnPool[] array111 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array111, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(111, (SpawnPool[])(object)array111);
		SpawnPool[] array112 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array112, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(112, (SpawnPool[])(object)array112);
		SpawnPool[] array113 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array113, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(114, (SpawnPool[])(object)array113);
		dictionary2.Add(113, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(115, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(116, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(117, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(118, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(119, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(120, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(121, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(122, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(123, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(124, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(125, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(126, (SpawnPool[])(object)new SpawnPool[0]);
		SpawnPool[] array114 = new SpawnPool[7];
		RuntimeHelpers.InitializeArray(array114, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		dictionary2.Add(127, (SpawnPool[])(object)array114);
		dictionary2.Add(128, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(129, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(130, (SpawnPool[])(object)new SpawnPool[0]);
		dictionary2.Add(131, (SpawnPool[])(object)new SpawnPool[0]);
		DefaultPools = dictionary2;
	}
}