using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using Dawn;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UsualScrap.Behaviors;
using UsualScrap.Behaviors.Effects;
using UsualScrap.NetcodePatcher;
using UsualScrap.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("UsualScrap")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Adds many new unique items that expand on the available scrap items and interactions!")]
[assembly: AssemblyFileVersion("2.0.7.0")]
[assembly: AssemblyInformationalVersion("2.0.7")]
[assembly: AssemblyProduct("UsualScrap")]
[assembly: AssemblyTitle("UsualScrap")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.7.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace UsualScrap
{
	[BepInPlugin("Emil.UsualScrap", "UsualScrap", "2.0.7")]
	public class Plugin : BaseUnityPlugin
	{
		public static class ScrapPackKeys
		{
			public static NamespacedKey<DawnItemInfo> US_PocketWatch = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Pocket_Watch");

			public static NamespacedKey<DawnItemInfo> US_ServantBell = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Servant_Bell");

			public static NamespacedKey<DawnItemInfo> US_ChessPieces = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Chess_Pieces");

			public static NamespacedKey<DawnItemInfo> US_GoldenChessPieces = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Golden_Chess_Pieces");

			public static NamespacedKey<DawnItemInfo> US_TrafficCone = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Traffic_Cone");

			public static NamespacedKey<DawnItemInfo> US_MereGear = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Mere_Gear");
		}

		public static class ScrapItemKeys
		{
			public static NamespacedKey<DawnItemInfo> US_Ticket = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Ticket");

			public static NamespacedKey<DawnItemInfo> US_GoldenTicket = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Golden_Ticket");

			public static NamespacedKey<DawnItemInfo> US_Rose = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Rose");

			public static NamespacedKey<DawnItemInfo> US_SizableScissors = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Sizable_Scissors");

			public static NamespacedKey<DawnItemInfo> US_WalkingCane = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Walking_Cane");

			public static NamespacedKey<DawnItemInfo> US_CandyDispenser = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Candy_Dispenser");

			public static NamespacedKey<DawnItemInfo> US_VintageCandy = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Vintage_Candy");

			public static NamespacedKey<DawnItemInfo> US_FuelCylinder = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Fuel_Cylinder");

			public static NamespacedKey<DawnItemInfo> US_RadioactiveCell = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Radioactive_Cell");

			public static NamespacedKey<DawnItemInfo> US_GloomyCapsule = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Gloomy_Capsule");

			public static NamespacedKey<DawnItemInfo> US_FrigidCapsule = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Frigid_Capsule");

			public static NamespacedKey<DawnItemInfo> US_BloodyCapsule = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Bloody_Capsule");

			public static NamespacedKey<DawnItemInfo> US_Padlock = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Padlock");

			public static NamespacedKey<DawnItemInfo> US_Crowbar = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Crowbar");

			public static NamespacedKey<DawnItemInfo> US_FireAxe = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_FireAxe");

			public static NamespacedKey<DawnItemInfo> US_Sledgehammer = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Sledgehammer");

			public static NamespacedKey<DawnItemInfo> US_AntiqueSword = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_AntiqueSword");

			public static NamespacedKey<DawnItemInfo> US_RegalScepter = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_RegalScepter");
		}

		public static class StoreItemKeys
		{
			public static NamespacedKey<DawnItemInfo> US_HandLamp = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Hand_Lamp");

			public static NamespacedKey<DawnItemInfo> US_Bandages = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Bandages");

			public static NamespacedKey<DawnItemInfo> US_MedicalKit = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Medical_Kit");

			public static NamespacedKey<DawnItemInfo> US_Defibrillator = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Defibrillator");

			public static NamespacedKey<DawnItemInfo> US_ProductivityAutoinjector = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Productivity_Autoinjector");

			public static NamespacedKey<DawnItemInfo> US_ShiftController = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Shift_Controller");

			public static NamespacedKey<DawnItemInfo> US_Blowtorch = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_Blowtorch");

			public static NamespacedKey<DawnItemInfo> US_ShockBaton = NamespacedKey<DawnItemInfo>.From("Usual_Scrap", "US_ShockBaton");
		}

		public static class EffectLoader
		{
			private static AssetBundle assetBundle;

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

			public static void Initialize(AssetBundle bundle)
			{
				assetBundle = bundle;
			}

			public static GameObject Get(string path)
			{
				if (!loadedEffects.TryGetValue(path, out var value))
				{
					value = assetBundle.LoadAsset<GameObject>(path);
					if ((Object)(object)value == (Object)null)
					{
						Debug.LogError((object)("USUAL SCRAP - Failed to load effect: " + path));
						return null;
					}
					loadedEffects[path] = value;
				}
				return value;
			}
		}

		public const string PLUGIN_GUID = "Emil.UsualScrap";

		public const string PLUGIN_NAME = "UsualScrap";

		public const string PLUGIN_VERSION = "2.0.7";

		public static Plugin instance;

		private List<KeyValuePair<NamespacedKey<DawnMoonInfo>, DawnMoonInfo>> FinalMoons = new List<KeyValuePair<NamespacedKey<DawnMoonInfo>, DawnMoonInfo>>();

		private List<string> FinalMoonNames = new List<string>();

		internal static UsualScrapConfigs BoundConfig { get; private set; }

		public void InitializeItem(GrabbableObject itemScript, bool grabbable, bool grabbableToEnemies, Item itemProperties)
		{
			DawnLib.RegisterNetworkPrefab(itemProperties.spawnPrefab);
			Utilities.FixMixerGroups(itemProperties.spawnPrefab);
			itemScript.grabbable = grabbable;
			itemScript.grabbableToEnemies = grabbableToEnemies;
			itemScript.itemProperties = itemProperties;
		}

		public void Awake()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			List<Item> list = new List<Item>();
			instance = this;
			BoundConfig = new UsualScrapConfigs(((BaseUnityPlugin)this).Config);
			new UsualScrapConfigs(((BaseUnityPlugin)this).Config);
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "usualscrapassetbundle"));
			EffectLoader.Initialize(val);
			try
			{
				if (BoundConfig.HandlampLoaded.Value)
				{
					Item val2 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/HandlampAssets/US_HandlampItem.asset");
					list.Add(val2);
					TerminalNode US_HandlampNode = val.LoadAsset<TerminalNode>("Assets/Items/HandlampAssets/US_HandlampNode.asset");
					HandlampScript itemScript = val2.spawnPrefab.AddComponent<HandlampScript>();
					InitializeItem((GrabbableObject)(object)itemScript, grabbable: true, grabbableToEnemies: true, val2);
					if (BoundConfig.HandlampIsStoreItem.Value && BoundConfig.HandlampStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_HandLamp, val2, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.HandlampStorePrice.Value).OverrideInfoNode(US_HandlampNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Handlamp experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.BandagesLoaded.Value)
				{
					Item val3 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/BandagesAssets/US_BandagesItem.asset");
					list.Add(val3);
					TerminalNode US_BandagesNode = val.LoadAsset<TerminalNode>("Assets/Items/BandagesAssets/US_BandagesNode.asset");
					BandagesScript itemScript2 = val3.spawnPrefab.AddComponent<BandagesScript>();
					InitializeItem((GrabbableObject)(object)itemScript2, grabbable: true, grabbableToEnemies: true, val3);
					if (BoundConfig.BandagesIsStoreItem.Value && BoundConfig.BandagesStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_Bandages, val3, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.BandagesStorePrice.Value).OverrideInfoNode(US_BandagesNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Bandages experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.MedicalKitLoaded.Value)
				{
					Item val4 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/MedicalKitAssets/US_MedicalKitItem.asset");
					list.Add(val4);
					TerminalNode US_MedicalKitNode = val.LoadAsset<TerminalNode>("Assets/Items/MedicalKitAssets/US_MedicalKitNode.asset");
					MedicalKitScript itemScript3 = val4.spawnPrefab.AddComponent<MedicalKitScript>();
					InitializeItem((GrabbableObject)(object)itemScript3, grabbable: true, grabbableToEnemies: true, val4);
					if (BoundConfig.MedicalKitIsStoreItem.Value && BoundConfig.MedicalKitStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_MedicalKit, val4, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.MedicalKitStorePrice.Value).OverrideInfoNode(US_MedicalKitNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Medical Kit experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.DefibrillatorLoaded.Value)
				{
					Item val5 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/DefibrillatorAssets/US_DefibrillatorItem.asset");
					list.Add(val5);
					TerminalNode US_DefibrillatorNode = val.LoadAsset<TerminalNode>("Assets/Items/DefibrillatorAssets/US_DefibrillatorNode.asset");
					DefibrillatorScript itemScript4 = val5.spawnPrefab.AddComponent<DefibrillatorScript>();
					InitializeItem((GrabbableObject)(object)itemScript4, grabbable: true, grabbableToEnemies: true, val5);
					if (BoundConfig.DefibrillatorIsStoreItem.Value && BoundConfig.DefibrillatorStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_Defibrillator, val5, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.DefibrillatorStorePrice.Value).OverrideInfoNode(US_DefibrillatorNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Defibrillator experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.ProductivityAutoinjectorLoaded.Value)
				{
					Item val6 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/ProductivityAutoinjectorAssets/US_ProductivityAutoinjectorItem.asset");
					list.Add(val6);
					TerminalNode US_ProductivityAutoinjectorNode = val.LoadAsset<TerminalNode>("Assets/Items/ProductivityAutoinjectorAssets/US_ProductivityAutoinjectorNode.asset");
					ProductivityAutoinjectorScript itemScript5 = val6.spawnPrefab.AddComponent<ProductivityAutoinjectorScript>();
					InitializeItem((GrabbableObject)(object)itemScript5, grabbable: true, grabbableToEnemies: true, val6);
					if (BoundConfig.ProductivityAutoinjectorIsStoreItem.Value && BoundConfig.ProductivityAutoinjectorStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_ProductivityAutoinjector, val6, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.ProductivityAutoinjectorStorePrice.Value).OverrideInfoNode(US_ProductivityAutoinjectorNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Productivity Autoinjector experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.BlowtorchLoaded.Value)
				{
					Item val7 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/BlowtorchAssets/US_BlowtorchItem.asset");
					list.Add(val7);
					TerminalNode US_BlowtorchNode = val.LoadAsset<TerminalNode>("Assets/Items/BlowtorchAssets/US_BlowtorchNode.asset");
					RedoneBlowtorch itemScript6 = val7.spawnPrefab.AddComponent<RedoneBlowtorch>();
					InitializeItem((GrabbableObject)(object)itemScript6, grabbable: true, grabbableToEnemies: true, val7);
					if (BoundConfig.BlowtorchIsStoreItem.Value && BoundConfig.BlowtorchStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_Blowtorch, val7, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.BlowtorchStorePrice.Value).OverrideInfoNode(US_BlowtorchNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Blowtorch experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.ShiftControllerLoaded.Value)
				{
					Item val8 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/ShiftControllerAssets/US_ShiftControllerItem.asset");
					list.Add(val8);
					TerminalNode US_ShiftControllerNode = val.LoadAsset<TerminalNode>("Assets/Items/ShiftControllerAssets/US_ShiftControllerNode.asset");
					ShiftControllerScript itemScript7 = val8.spawnPrefab.AddComponent<ShiftControllerScript>();
					InitializeItem((GrabbableObject)(object)itemScript7, grabbable: true, grabbableToEnemies: true, val8);
					if (BoundConfig.ShiftControllerIsStoreItem.Value && BoundConfig.ShiftControllerStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_ShiftController, val8, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.ShiftControllerStorePrice.Value).OverrideInfoNode(US_ShiftControllerNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Shift Controller experienced an error while loading. Skipping...");
			}
			try
			{
				if (BoundConfig.ShockBatonLoaded.Value)
				{
					Item val9 = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/ShockBatonAssets/US_ShockBatonItem.asset");
					list.Add(val9);
					TerminalNode US_ShockBatonNode = val.LoadAsset<TerminalNode>("Assets/Items/ShockBatonAssets/US_ShockBatonNode.asset");
					ShockBatonScript itemScript8 = val9.spawnPrefab.AddComponent<ShockBatonScript>();
					InitializeItem((GrabbableObject)(object)itemScript8, grabbable: true, grabbableToEnemies: true, val9);
					if (BoundConfig.ShockBatonIsStoreItem.Value && BoundConfig.ShockBatonStorePrice.Value >= 0)
					{
						DawnLib.DefineItem(StoreItemKeys.US_ShockBaton, val9, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
						{
							builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
							{
								shopBuilder.OverrideCost(BoundConfig.ShockBatonStorePrice.Value).OverrideInfoNode(US_ShockBatonNode);
							});
						});
					}
				}
			}
			catch
			{
				Debug.LogError((object)"USUAL SCRAP - Shock Baton experienced an error while loading. Skipping...");
			}
			Item US_Ticket = null;
			Item US_GoldenTicket = null;
			Item US_Rose = null;
			Item US_SizableScissors = null;
			Item US_WalkingCane = null;
			Item US_CandyDispenser = null;
			Item US_VintageCandy = null;
			Item US_FuelCylinder = null;
			Item US_RadioactiveCell = null;
			Item US_GloomyCapsule = null;
			Item US_FrigidCapsule = null;
			Item US_BloodyCapsule = null;
			Item US_Padlock = null;
			Item US_Crowbar = null;
			Item US_FireAxe = null;
			Item US_Sledgehammer = null;
			Item US_AntiqueSword = null;
			Item US_RegalScepter = null;
			Item US_PocketWatch = null;
			Item US_ServantBell = null;
			Item US_ChessPieces = null;
			Item US_GoldenChessPieces = null;
			Item US_TrafficCone = null;
			Item US_MereGear = null;
			((Registry<DawnMoonInfo>)(object)LethalContent.Moons).BeforeFreeze += DetectMoons;
			((Registry<DawnMoonInfo>)(object)LethalContent.Moons).BeforeFreeze += SetWeights;
			if (BoundConfig.TicketLoaded.Value)
			{
				try
				{
					US_Ticket = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/TicketAssets/US_TicketItem.asset");
					list.Add(US_Ticket);
					TicketScript itemScript9 = US_Ticket.spawnPrefab.AddComponent<TicketScript>();
					InitializeItem((GrabbableObject)(object)itemScript9, grabbable: true, grabbableToEnemies: true, US_Ticket);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Ticket experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.GoldenTicketLoaded.Value)
			{
				try
				{
					US_GoldenTicket = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/GoldenTicketAssets/US_GoldenTicketItem.asset");
					list.Add(US_GoldenTicket);
					GoldenTicketScript itemScript10 = US_GoldenTicket.spawnPrefab.AddComponent<GoldenTicketScript>();
					InitializeItem((GrabbableObject)(object)itemScript10, grabbable: true, grabbableToEnemies: true, US_GoldenTicket);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Golden Ticket experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.RoseLoaded.Value)
			{
				try
				{
					US_Rose = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/RoseAssets/US_RoseItem.asset");
					list.Add(US_Rose);
					RoseScript itemScript11 = US_Rose.spawnPrefab.AddComponent<RoseScript>();
					InitializeItem((GrabbableObject)(object)itemScript11, grabbable: true, grabbableToEnemies: true, US_Rose);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Rose experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.SizableScissorsLoaded.Value)
			{
				try
				{
					US_SizableScissors = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/SizableScissorsAssets/US_SizableScissorsItem.asset");
					list.Add(US_SizableScissors);
					SizableScissorsScript itemScript12 = US_SizableScissors.spawnPrefab.AddComponent<SizableScissorsScript>();
					InitializeItem((GrabbableObject)(object)itemScript12, grabbable: true, grabbableToEnemies: true, US_SizableScissors);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Scissors experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.WalkingCaneLoaded.Value)
			{
				try
				{
					US_WalkingCane = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/WalkingCaneAssets/US_WalkingCaneItem.asset");
					list.Add(US_WalkingCane);
					WalkingCaneScript itemScript13 = US_WalkingCane.spawnPrefab.AddComponent<WalkingCaneScript>();
					InitializeItem((GrabbableObject)(object)itemScript13, grabbable: true, grabbableToEnemies: true, US_WalkingCane);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Walking Cane experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.CandyDispenserLoaded.Value)
			{
				try
				{
					US_CandyDispenser = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/CandyDispenserAssets/US_CandyDispenserItem.asset");
					list.Add(US_CandyDispenser);
					CandyDispenserScript itemScript14 = US_CandyDispenser.spawnPrefab.AddComponent<CandyDispenserScript>();
					InitializeItem((GrabbableObject)(object)itemScript14, grabbable: true, grabbableToEnemies: true, US_CandyDispenser);
					US_VintageCandy = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/VintageCandyAssets/US_VintageCandyItem.asset");
					list.Add(US_VintageCandy);
					VintageCandyScript itemScript15 = US_VintageCandy.spawnPrefab.AddComponent<VintageCandyScript>();
					InitializeItem((GrabbableObject)(object)itemScript15, grabbable: true, grabbableToEnemies: true, US_VintageCandy);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Candy Dispenser or Vintage Candy experienced an error while loading. Skipping...");
				}
			}
			else if (BoundConfig.VintageCandyLoaded.Value && !BoundConfig.CandyDispenserLoaded.Value)
			{
				try
				{
					US_VintageCandy = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/VintageCandyAssets/US_VintageCandyItem.asset");
					list.Add(US_VintageCandy);
					VintageCandyScript itemScript16 = US_VintageCandy.spawnPrefab.AddComponent<VintageCandyScript>();
					InitializeItem((GrabbableObject)(object)itemScript16, grabbable: true, grabbableToEnemies: true, US_VintageCandy);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Vintage Candy experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.FuelCylinderLoaded.Value)
			{
				try
				{
					US_FuelCylinder = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/FuelCylinderAssets/US_FuelCylinderItem.asset");
					list.Add(US_FuelCylinder);
					FuelCylinderScript itemScript17 = US_FuelCylinder.spawnPrefab.AddComponent<FuelCylinderScript>();
					InitializeItem((GrabbableObject)(object)itemScript17, grabbable: true, grabbableToEnemies: true, US_FuelCylinder);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Fuel Cylinder experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.RadioactiveCellLoaded.Value)
			{
				try
				{
					US_RadioactiveCell = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/RadioactiveCellAssets/US_RadioactiveCellItem.asset");
					list.Add(US_RadioactiveCell);
					RadioactiveCellScript itemScript18 = US_RadioactiveCell.spawnPrefab.AddComponent<RadioactiveCellScript>();
					InitializeItem((GrabbableObject)(object)itemScript18, grabbable: true, grabbableToEnemies: true, US_RadioactiveCell);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Radioactive Cell experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.GloomyCapsuleLoaded.Value)
			{
				try
				{
					US_GloomyCapsule = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/GloomyCapsuleAssets/US_GloomyCapsuleItem.asset");
					list.Add(US_GloomyCapsule);
					GloomyCapsuleScript itemScript19 = US_GloomyCapsule.spawnPrefab.AddComponent<GloomyCapsuleScript>();
					InitializeItem((GrabbableObject)(object)itemScript19, grabbable: true, grabbableToEnemies: true, US_GloomyCapsule);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Gloomy Capsule experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.FrigidCapsuleLoaded.Value)
			{
				try
				{
					US_FrigidCapsule = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/FrigidCapsuleAssets/US_FrigidCapsuleItem.asset");
					list.Add(US_FrigidCapsule);
					FrigidCapsuleScript itemScript20 = US_FrigidCapsule.spawnPrefab.AddComponent<FrigidCapsuleScript>();
					InitializeItem((GrabbableObject)(object)itemScript20, grabbable: true, grabbableToEnemies: true, US_FrigidCapsule);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Frigid Capsule experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.BloodyCapsuleLoaded.Value)
			{
				try
				{
					US_BloodyCapsule = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/BloodyCapsuleAssets/US_BloodyCapsuleItem.asset");
					list.Add(US_BloodyCapsule);
					BloodyCapsuleScript itemScript21 = US_BloodyCapsule.spawnPrefab.AddComponent<BloodyCapsuleScript>();
					InitializeItem((GrabbableObject)(object)itemScript21, grabbable: true, grabbableToEnemies: true, US_BloodyCapsule);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Bloody Capsule experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.PadlockLoaded.Value)
			{
				try
				{
					US_Padlock = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/PadlockAssets/US_PadlockItem.asset");
					list.Add(US_Padlock);
					PadlockScript itemScript22 = US_Padlock.spawnPrefab.AddComponent<PadlockScript>();
					InitializeItem((GrabbableObject)(object)itemScript22, grabbable: true, grabbableToEnemies: true, US_Padlock);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Padlock experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.CrowbarLoaded.Value)
			{
				try
				{
					US_Crowbar = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/CrowbarAssets/US_CrowbarItem.asset");
					list.Add(US_Crowbar);
					CrowbarScript itemScript23 = US_Crowbar.spawnPrefab.AddComponent<CrowbarScript>();
					InitializeItem((GrabbableObject)(object)itemScript23, grabbable: true, grabbableToEnemies: true, US_Crowbar);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Crowbar experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.FireAxeLoaded.Value)
			{
				try
				{
					US_FireAxe = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/FireAxeAssets/US_FireAxeItem.asset");
					list.Add(US_FireAxe);
					FireAxeScript itemScript24 = US_FireAxe.spawnPrefab.AddComponent<FireAxeScript>();
					InitializeItem((GrabbableObject)(object)itemScript24, grabbable: true, grabbableToEnemies: true, US_FireAxe);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Fire Axe experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.SledgehammerLoaded.Value)
			{
				try
				{
					US_Sledgehammer = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/SledgehammerAssets/US_SledgehammerItem.asset");
					list.Add(US_Sledgehammer);
					SledgehammerScript itemScript25 = US_Sledgehammer.spawnPrefab.AddComponent<SledgehammerScript>();
					InitializeItem((GrabbableObject)(object)itemScript25, grabbable: true, grabbableToEnemies: true, US_Sledgehammer);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Sledgehammer experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.AntiqueSwordLoaded.Value)
			{
				try
				{
					US_AntiqueSword = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/AntiqueSwordAssets/US_AntiqueSwordItem.asset");
					list.Add(US_AntiqueSword);
					AntiqueSwordScript itemScript26 = US_AntiqueSword.spawnPrefab.AddComponent<AntiqueSwordScript>();
					InitializeItem((GrabbableObject)(object)itemScript26, grabbable: true, grabbableToEnemies: true, US_AntiqueSword);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Antique Sword experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.RegalScepterLoaded.Value)
			{
				try
				{
					US_RegalScepter = val.LoadAsset<Item>("Assets/UsualScrapContent/Items/RegalScepterAssets/US_RegalScepterItem.asset");
					list.Add(US_RegalScepter);
					RegalScepterScript itemScript27 = US_RegalScepter.spawnPrefab.AddComponent<RegalScepterScript>();
					InitializeItem((GrabbableObject)(object)itemScript27, grabbable: true, grabbableToEnemies: true, US_RegalScepter);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Regal Scepter experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.MansionScrapPackEnabled.Value)
			{
				try
				{
					US_PocketWatch = val.LoadAsset<Item>("Assets/UsualScrapContent/ScrapPackItems/PocketWatchAssets/US_PocketWatchItem.asset");
					list.Add(US_PocketWatch);
					PhysicsProp itemScript28 = US_PocketWatch.spawnPrefab.AddComponent<PhysicsProp>();
					InitializeItem((GrabbableObject)(object)itemScript28, grabbable: true, grabbableToEnemies: true, US_PocketWatch);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Pocket Watch scrap pack item experienced an error while loading. Skipping...");
				}
				try
				{
					US_ServantBell = val.LoadAsset<Item>("Assets/UsualScrapContent/ScrapPackItems/ServantBellAssets/US_ServantBellItem.asset");
					list.Add(US_ServantBell);
					NoiseMakerScript itemScript29 = US_ServantBell.spawnPrefab.AddComponent<NoiseMakerScript>();
					InitializeItem((GrabbableObject)(object)itemScript29, grabbable: true, grabbableToEnemies: true, US_ServantBell);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Servant Bell scrap pack item experienced an error while loading. Skipping...");
				}
				try
				{
					US_ChessPieces = val.LoadAsset<Item>("Assets/UsualScrapContent/ScrapPackItems/ChessPiecesAssets/US_ChessPiecesItem.asset");
					list.Add(US_ChessPieces);
					RandomModelBNWScript randomModelBNWScript = US_ChessPieces.spawnPrefab.AddComponent<RandomModelBNWScript>();
					randomModelBNWScript.changeColor = true;
					InitializeItem((GrabbableObject)(object)randomModelBNWScript, grabbable: true, grabbableToEnemies: true, US_ChessPieces);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Chess Pieces scrap pack item experienced an error while loading. Skipping...");
				}
				try
				{
					US_GoldenChessPieces = val.LoadAsset<Item>("Assets/UsualScrapContent/ScrapPackItems/GoldenChessPiecesAssets/US_GoldenChessPiecesItem.asset");
					list.Add(US_GoldenChessPieces);
					RandomModelBNWScript randomModelBNWScript2 = US_GoldenChessPieces.spawnPrefab.AddComponent<RandomModelBNWScript>();
					randomModelBNWScript2.changeColor = false;
					InitializeItem((GrabbableObject)(object)randomModelBNWScript2, grabbable: true, grabbableToEnemies: true, US_GoldenChessPieces);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Golden Chess Pieces scrap pack item experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.FacilityScrapPackEnabled.Value)
			{
				try
				{
					US_TrafficCone = val.LoadAsset<Item>("Assets/UsualScrapContent/ScrapPackItems/TrafficConeAssets/US_TrafficConeItem.asset");
					list.Add(US_TrafficCone);
					PhysicsProp itemScript30 = US_TrafficCone.spawnPrefab.AddComponent<PhysicsProp>();
					InitializeItem((GrabbableObject)(object)itemScript30, grabbable: true, grabbableToEnemies: true, US_TrafficCone);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Traffic Cone scrap pack item experienced an error while loading. Skipping...");
				}
				try
				{
					US_MereGear = val.LoadAsset<Item>("Assets/UsualScrapContent/ScrapPackItems/MereGearAssets/US_MereGearItem.asset");
					list.Add(US_MereGear);
					PhysicsProp itemScript31 = US_MereGear.spawnPrefab.AddComponent<PhysicsProp>();
					InitializeItem((GrabbableObject)(object)itemScript31, grabbable: true, grabbableToEnemies: true, US_MereGear);
				}
				catch
				{
					Debug.LogError((object)"USUAL SCRAP - Mere Gear scrap pack item experienced an error while loading. Skipping...");
				}
			}
			if (BoundConfig.DisableItemIcons.Value)
			{
				foreach (Item item in list)
				{
					item.itemIcon = null;
				}
			}
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "Emil.UsualScrap");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin Emil.UsualScrap is loaded!");
			void SetWeights()
			{
				if (BoundConfig.MansionScrapPackEnabled.Value)
				{
					try
					{
						if ((Object)(object)US_PocketWatch != (Object)null)
						{
							string[] pocketWatchMoonStrings = BoundConfig.PocketWatchMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapPackKeys.US_PocketWatch, US_PocketWatch, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, pocketWatchMoonStrings, US_PocketWatch, BoundConfig.PocketWatchMoonSpawnWeights, BoundConfig.PocketWatchGlobalSpawnWeight);
									});
								});
							});
						}
						if ((Object)(object)US_ServantBell != (Object)null)
						{
							string[] servantBellMoonStrings = BoundConfig.ServantBellMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapPackKeys.US_ServantBell, US_ServantBell, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, servantBellMoonStrings, US_ServantBell, BoundConfig.ServantBellMoonSpawnWeights, BoundConfig.ServantBellGlobalSpawnWeight);
									});
								});
							});
						}
						if ((Object)(object)US_ChessPieces != (Object)null)
						{
							string[] chessPiecesMoonStrings = BoundConfig.ChessPiecesMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapPackKeys.US_ChessPieces, US_ChessPieces, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, chessPiecesMoonStrings, US_ChessPieces, BoundConfig.ChessPiecesMoonSpawnWeights, BoundConfig.ChessPiecesGlobalSpawnWeight);
									});
								});
							});
						}
						if ((Object)(object)US_GoldenChessPieces != (Object)null)
						{
							string[] goldenChessPiecesMoonStrings = BoundConfig.GoldenChessPiecesMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapPackKeys.US_GoldenChessPieces, US_GoldenChessPieces, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, goldenChessPiecesMoonStrings, US_GoldenChessPieces, BoundConfig.GoldenChessPiecesMoonSpawnWeights, BoundConfig.GoldenChessPiecesGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.FacilityScrapPackEnabled.Value)
				{
					try
					{
						if ((Object)(object)US_TrafficCone != (Object)null)
						{
							string[] trafficConeMoonStrings = BoundConfig.TrafficConeMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapPackKeys.US_TrafficCone, US_TrafficCone, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, trafficConeMoonStrings, US_TrafficCone, BoundConfig.TrafficConeMoonSpawnWeights, BoundConfig.TrafficConeGlobalSpawnWeight);
									});
								});
							});
						}
						if ((Object)(object)US_MereGear != (Object)null)
						{
							string[] mereGearMoonStrings = BoundConfig.MereGearMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapPackKeys.US_MereGear, US_MereGear, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, mereGearMoonStrings, US_MereGear, BoundConfig.MereGearMoonSpawnWeights, BoundConfig.MereGearGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.TicketSpawnsAsScrap.Value && BoundConfig.TicketLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Ticket != (Object)null)
						{
							string[] ticketMoonStrings = BoundConfig.TicketMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_Ticket, US_Ticket, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, ticketMoonStrings, US_Ticket, BoundConfig.TicketMoonSpawnWeights, BoundConfig.TicketGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.TicketSpawnsAsScrap.Value && BoundConfig.TicketLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Ticket != (Object)null)
						{
							Items.RegisterItem(US_Ticket);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.GoldenTicketSpawnsAsScrap.Value && BoundConfig.GoldenTicketLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_GoldenTicket != (Object)null)
						{
							string[] goldenTicketMoonStrings = BoundConfig.GoldenTicketMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_GoldenTicket, US_GoldenTicket, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, goldenTicketMoonStrings, US_GoldenTicket, BoundConfig.GoldenTicketMoonSpawnWeights, BoundConfig.GoldenTicketGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.GoldenTicketSpawnsAsScrap.Value && BoundConfig.GoldenTicketLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_GoldenTicket != (Object)null)
						{
							Items.RegisterItem(US_GoldenTicket);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.RoseSpawnsAsScrap.Value && BoundConfig.RoseLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Rose != (Object)null)
						{
							string[] roseMoonStrings = BoundConfig.RoseMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_Rose, US_Rose, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, roseMoonStrings, US_Rose, BoundConfig.RoseMoonSpawnWeights, BoundConfig.RoseGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.RoseSpawnsAsScrap.Value && BoundConfig.RoseLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Rose != (Object)null)
						{
							Items.RegisterItem(US_Rose);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.SizableScissorsSpawnsAsScrap.Value && BoundConfig.SizableScissorsLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_SizableScissors != (Object)null)
						{
							string[] sizableScissorsMoonStrings = BoundConfig.SizableScissorsMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_SizableScissors, US_SizableScissors, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, sizableScissorsMoonStrings, US_SizableScissors, BoundConfig.SizableScissorsMoonSpawnWeights, BoundConfig.SizableScissorsGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.SizableScissorsSpawnsAsScrap.Value && BoundConfig.SizableScissorsLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_SizableScissors != (Object)null)
						{
							Items.RegisterItem(US_SizableScissors);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.WalkingCaneSpawnsAsScrap.Value && BoundConfig.WalkingCaneLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_WalkingCane != (Object)null)
						{
							string[] walkingCaneMoonStrings = BoundConfig.WalkingCaneMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_WalkingCane, US_WalkingCane, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, walkingCaneMoonStrings, US_WalkingCane, BoundConfig.WalkingCaneMoonSpawnWeights, BoundConfig.WalkingCaneGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.WalkingCaneSpawnsAsScrap.Value && BoundConfig.WalkingCaneLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_WalkingCane != (Object)null)
						{
							Items.RegisterItem(US_WalkingCane);
						}
					}
					catch
					{
					}
				}
				if ((BoundConfig.CandyDispenserSpawnsAsScrap.Value && BoundConfig.CandyDispenserLoaded.Value) || (BoundConfig.VintageCandySpawnsAsScrap.Value && BoundConfig.VintageCandyLoaded.Value))
				{
					try
					{
						if ((Object)(object)US_CandyDispenser != (Object)null)
						{
							if ((Object)(object)US_VintageCandy == (Object)null)
							{
								return;
							}
							string[] candyDispenserMoonStrings = BoundConfig.CandyDispenserMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_CandyDispenser, US_CandyDispenser, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, candyDispenserMoonStrings, US_CandyDispenser, BoundConfig.CandyDispenserMoonSpawnWeights, BoundConfig.CandyDispenserGlobalSpawnWeight);
									});
								});
							});
						}
						if ((Object)(object)US_VintageCandy != (Object)null)
						{
							string[] vintageCandyMoonStrings = BoundConfig.VintageCandyMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_VintageCandy, US_VintageCandy, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, vintageCandyMoonStrings, US_VintageCandy, BoundConfig.VintageCandyMoonSpawnWeights, BoundConfig.VintageCandyGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if ((!BoundConfig.CandyDispenserSpawnsAsScrap.Value && BoundConfig.CandyDispenserLoaded.Value) || (!BoundConfig.VintageCandySpawnsAsScrap.Value && BoundConfig.VintageCandyLoaded.Value))
				{
					try
					{
						if ((Object)(object)US_CandyDispenser != (Object)null)
						{
							if ((Object)(object)US_VintageCandy == (Object)null)
							{
								return;
							}
							Items.RegisterItem(US_CandyDispenser);
						}
						if ((Object)(object)US_VintageCandy != (Object)null)
						{
							Items.RegisterItem(US_VintageCandy);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.FuelCylinderSpawnsAsScrap.Value && BoundConfig.FuelCylinderLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_FuelCylinder != (Object)null)
						{
							string[] fuelCylinderMoonStrings = BoundConfig.FuelCylinderMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_FuelCylinder, US_FuelCylinder, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, fuelCylinderMoonStrings, US_FuelCylinder, BoundConfig.FuelCylinderMoonSpawnWeights, BoundConfig.FuelCylinderGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.FuelCylinderSpawnsAsScrap.Value && BoundConfig.FuelCylinderLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_FuelCylinder != (Object)null)
						{
							Items.RegisterItem(US_FuelCylinder);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.RadioactiveCellSpawnsAsScrap.Value && BoundConfig.RadioactiveCellLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_RadioactiveCell != (Object)null)
						{
							string[] radioactiveCellMoonStrings = BoundConfig.RadioactiveCellMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_RadioactiveCell, US_RadioactiveCell, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, radioactiveCellMoonStrings, US_RadioactiveCell, BoundConfig.RadioactiveCellMoonSpawnWeights, BoundConfig.RadioactiveCellGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.RadioactiveCellSpawnsAsScrap.Value && BoundConfig.RadioactiveCellLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_RadioactiveCell != (Object)null)
						{
							Items.RegisterItem(US_RadioactiveCell);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.GloomyCapsuleSpawnsAsScrap.Value && BoundConfig.GloomyCapsuleLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_GloomyCapsule != (Object)null)
						{
							string[] gloomyCapsuleMoonStrings = BoundConfig.GloomyCapsuleMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_GloomyCapsule, US_GloomyCapsule, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, gloomyCapsuleMoonStrings, US_GloomyCapsule, BoundConfig.GloomyCapsuleMoonSpawnWeights, BoundConfig.GloomyCapsuleGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.GloomyCapsuleSpawnsAsScrap.Value && BoundConfig.GloomyCapsuleLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_GloomyCapsule != (Object)null)
						{
							Items.RegisterItem(US_GloomyCapsule);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.FrigidCapsuleSpawnsAsScrap.Value && BoundConfig.FrigidCapsuleLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_FrigidCapsule != (Object)null)
						{
							string[] frigidCapsuleMoonStrings = BoundConfig.FrigidCapsuleMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_FrigidCapsule, US_FrigidCapsule, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, frigidCapsuleMoonStrings, US_FrigidCapsule, BoundConfig.FrigidCapsuleMoonSpawnWeights, BoundConfig.FrigidCapsuleGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.FrigidCapsuleSpawnsAsScrap.Value && BoundConfig.FrigidCapsuleLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_FrigidCapsule != (Object)null)
						{
							Items.RegisterItem(US_FrigidCapsule);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.BloodyCapsuleSpawnsAsScrap.Value && BoundConfig.BloodyCapsuleLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_BloodyCapsule != (Object)null)
						{
							string[] bloodyCapsuleMoonStrings = BoundConfig.BloodyCapsuleMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_BloodyCapsule, US_BloodyCapsule, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, bloodyCapsuleMoonStrings, US_BloodyCapsule, BoundConfig.BloodyCapsuleMoonSpawnWeights, BoundConfig.BloodyCapsuleGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.BloodyCapsuleSpawnsAsScrap.Value && BoundConfig.BloodyCapsuleLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_BloodyCapsule != (Object)null)
						{
							Items.RegisterItem(US_BloodyCapsule);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.PadlockSpawnsAsScrap.Value && BoundConfig.PadlockLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Padlock != (Object)null)
						{
							string[] padlockMoonStrings = BoundConfig.PadlockMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_Padlock, US_Padlock, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, padlockMoonStrings, US_Padlock, BoundConfig.PadlockMoonSpawnWeights, BoundConfig.PadlockGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.PadlockSpawnsAsScrap.Value && BoundConfig.PadlockLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Padlock != (Object)null)
						{
							Items.RegisterItem(US_Padlock);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.CrowbarSpawnsAsScrap.Value && BoundConfig.CrowbarLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Crowbar != (Object)null)
						{
							string[] crowbarMoonStrings = BoundConfig.CrowbarMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_Crowbar, US_Crowbar, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, crowbarMoonStrings, US_Crowbar, BoundConfig.CrowbarMoonSpawnWeights, BoundConfig.CrowbarGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.CrowbarSpawnsAsScrap.Value && BoundConfig.CrowbarLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Crowbar != (Object)null)
						{
							Items.RegisterItem(US_Crowbar);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.FireAxeSpawnsAsScrap.Value && BoundConfig.FireAxeLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_FireAxe != (Object)null)
						{
							string[] fireAxeMoonStrings = BoundConfig.FireAxeMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_FireAxe, US_FireAxe, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, fireAxeMoonStrings, US_FireAxe, BoundConfig.FireAxeMoonSpawnWeights, BoundConfig.FireAxeGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.FireAxeSpawnsAsScrap.Value && BoundConfig.FireAxeLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_FireAxe != (Object)null)
						{
							Items.RegisterItem(US_FireAxe);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.SledgehammerSpawnsAsScrap.Value && BoundConfig.SledgehammerLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Sledgehammer != (Object)null)
						{
							string[] sledgehammerMoonStrings = BoundConfig.SledgehammerMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_Sledgehammer, US_Sledgehammer, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, sledgehammerMoonStrings, US_Sledgehammer, BoundConfig.SledgehammerMoonSpawnWeights, BoundConfig.SledgehammerGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.SledgehammerSpawnsAsScrap.Value && BoundConfig.SledgehammerLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_Sledgehammer != (Object)null)
						{
							Items.RegisterItem(US_Sledgehammer);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.AntiqueSwordSpawnsAsScrap.Value && BoundConfig.AntiqueSwordLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_AntiqueSword != (Object)null)
						{
							string[] antiqueSwordMoonStrings = BoundConfig.AntiqueSwordMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_AntiqueSword, US_AntiqueSword, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, antiqueSwordMoonStrings, US_AntiqueSword, BoundConfig.AntiqueSwordMoonSpawnWeights, BoundConfig.AntiqueSwordGlobalSpawnWeight);
									});
								});
							});
						}
					}
					catch
					{
					}
				}
				else if (!BoundConfig.AntiqueSwordSpawnsAsScrap.Value && BoundConfig.AntiqueSwordLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_AntiqueSword != (Object)null)
						{
							Items.RegisterItem(US_AntiqueSword);
						}
					}
					catch
					{
					}
				}
				if (BoundConfig.RegalScepterSpawnsAsScrap.Value && BoundConfig.RegalScepterLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_RegalScepter != (Object)null)
						{
							string[] regalScepterMoonStrings = BoundConfig.RegalScepterMoonSpawnWeights.Value.Split(',');
							DawnLib.DefineItem(ScrapItemKeys.US_RegalScepter, US_RegalScepter, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
							{
								builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
								{
									scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightBuilder)
									{
										buildallweights(weightBuilder, regalScepterMoonStrings, US_RegalScepter, BoundConfig.RegalScepterMoonSpawnWeights, BoundConfig.RegalScepterGlobalSpawnWeight);
									});
								});
							});
						}
						return;
					}
					catch
					{
						return;
					}
				}
				if (!BoundConfig.RegalScepterSpawnsAsScrap.Value && BoundConfig.RegalScepterLoaded.Value)
				{
					try
					{
						if ((Object)(object)US_RegalScepter != (Object)null)
						{
							Items.RegisterItem(US_RegalScepter);
						}
					}
					catch
					{
					}
				}
			}
			void buildallweights(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> builder, string[] moonStrings, Item item, ConfigEntry<string> moonWeightConfig, ConfigEntry<int> globalWeightConfig)
			{
				MonoBehaviour.print((object)$"Building moon weights for {item}");
				bool flag = false;
				List<string> list2 = new List<string>();
				Dictionary<string, int> dictionary = new Dictionary<string, int>();
				List<string> list3 = new List<string>();
				foreach (KeyValuePair<NamespacedKey<DawnMoonInfo>, DawnMoonInfo> finalMoon in FinalMoons)
				{
					foreach (string text in moonStrings)
					{
						try
						{
							string[] array3 = text.Split('=');
							string text2 = array3[0].Trim().ToLowerInvariant();
							string s = array3[1].Trim();
							int num = int.Parse(s);
							string text3 = Regex.Replace(finalMoon.Value.Level.PlanetName, "[\\d\\s]", "").Trim().ToLowerInvariant();
							if (text3 == text2 && num >= 0)
							{
								if (BoundConfig.DebugLogging.Value)
								{
									MonoBehaviour.print((object)$"Setting moon {finalMoon}'s weight to moon weight {num} for {item}");
								}
								dictionary[text2] = num;
								try
								{
									builder.AddWeight(finalMoon.Key, num);
								}
								catch (Exception ex)
								{
									Debug.LogWarning((object)$"Failed to add specified weight for {item} to {text2}, Attempted weight -> {num}");
									Debug.LogWarning((object)ex);
								}
								list2.Add(text2);
							}
							else if (text3 == text2 && num <= -1 && globalWeightConfig.Value >= 0)
							{
								if (BoundConfig.DebugLogging.Value)
								{
									MonoBehaviour.print((object)$"Setting moon {finalMoon}'s weight to global weight {globalWeightConfig} for {item}");
								}
								dictionary[text2] = -1;
								try
								{
									builder.AddWeight(finalMoon.Key, globalWeightConfig.Value);
								}
								catch (Exception ex2)
								{
									Debug.LogWarning((object)$"Failed to add global weight for {item} to {text2}, Attempted weight -> {globalWeightConfig.Value}");
									Debug.LogWarning((object)ex2);
								}
								list2.Add(text2);
							}
							else if (text3 == text2 && num <= -1 && globalWeightConfig.Value <= -1)
							{
								list2.Add(text2);
								dictionary[text2] = -1;
							}
							else if ((text2 == null || !(text3 != text2)) && !list3.Contains(text))
							{
								Debug.LogWarning((object)$"Usual Scrap - Moon weight config entry [{text2}] from [{item}] is unreadable and returned an error. Reformatting and resetting entry...");
								list3.Add(text);
							}
						}
						catch
						{
							if (!list3.Contains(text))
							{
								Debug.LogWarning((object)$"Usual Scrap - Moon weight config entry [{text}] from [{item}] is unreadable and returned an error. Reformatting and resetting entry...");
								list3.Add(text);
							}
						}
					}
				}
				foreach (string text4 in moonStrings)
				{
					try
					{
						string text5 = text4.Split('=')[0].Trim().ToLowerInvariant();
						if (!list2.Contains(text5) && !string.IsNullOrWhiteSpace(text5))
						{
							Debug.LogWarning((object)$"Usual Scrap - Config entry '{text5}' for [{item}] does not match any loaded moons or is formatted incorrectly. Reformatting and resetting entry...");
						}
					}
					catch
					{
					}
				}
				foreach (KeyValuePair<NamespacedKey<DawnMoonInfo>, DawnMoonInfo> finalMoon2 in FinalMoons)
				{
					string text6 = Regex.Replace(finalMoon2.Value.Level.PlanetName, "[\\d\\s]", "").Trim().ToLowerInvariant();
					if (!list2.Contains(text6))
					{
						if (BoundConfig.DebugLogging.Value)
						{
							Debug.LogWarning((object)$"{item} config does not contain {text6}, adding it to the config.. Weight setting skipped for this moon..");
						}
						bool flag2 = false;
						foreach (string text7 in moonStrings)
						{
							if (text7.ToLowerInvariant().Contains(text6))
							{
								flag2 = true;
								break;
							}
						}
						if (!flag2)
						{
							string text8 = moonWeightConfig.Value;
							if (!string.IsNullOrWhiteSpace(text8) && !text8.EndsWith(","))
							{
								text8 += ", ";
							}
							text8 = text8 + text6 + "=-1";
							moonWeightConfig.Value = text8;
							flag = true;
							list2.Add(text6);
						}
					}
				}
				List<string> list4 = new List<string>();
				foreach (string item2 in list2)
				{
					int num2 = (dictionary.ContainsKey(item2) ? dictionary[item2] : (-1));
					list4.Add($"{item2}={num2}");
				}
				string value = string.Join(", ", list4);
				moonWeightConfig.Value = value;
				((BaseUnityPlugin)this).Config.Save();
				if (flag)
				{
					MonoBehaviour.print((object)$"USUALS SCRAP -  Detected new moon(s) while processing '{item}'.");
				}
				string text9 = $"USUAL SCRAP - {item} spawn weights successfully set for ";
				foreach (string item3 in list2)
				{
					text9 = text9 + item3 + ", ";
				}
				if (BoundConfig.DebugLogging.Value)
				{
					MonoBehaviour.print((object)text9);
				}
				MonoBehaviour.print((object)$"Moon weights for {item} set.");
			}
		}

		private void DetectMoons()
		{
			TaggedRegistry<DawnMoonInfo> moons = LethalContent.Moons;
			List<TerminalKeyword> list = new List<TerminalKeyword>();
			TerminalKeyword[] allKeywords = Object.FindObjectOfType<Terminal>().terminalNodes.allKeywords;
			TerminalKeyword[] array = allKeywords;
			foreach (TerminalKeyword val in array)
			{
				if (!(((Object)val).name == "route") && !(((Object)val).name == "Route"))
				{
					continue;
				}
				CompatibleNoun[] compatibleNouns = val.compatibleNouns;
				foreach (CompatibleNoun val2 in compatibleNouns)
				{
					if (!list.Contains(val2.noun))
					{
						list.Add(val2.noun);
					}
				}
			}
			foreach (KeyValuePair<NamespacedKey<DawnMoonInfo>, DawnMoonInfo> item in (Registry<DawnMoonInfo>)(object)moons)
			{
				foreach (TerminalKeyword item2 in list)
				{
					if ((Object)(object)item.Value.NameKeyword == (Object)(object)item2 && item.Value.Level.spawnEnemiesAndScrap)
					{
						FinalMoons.Add(item);
						FinalMoonNames.Add(((object)item.Value.NameKeyword).ToString().ToLowerInvariant().Trim());
					}
				}
			}
		}
	}
	internal class UsualScrapConfigs
	{
		public readonly ConfigEntry<string> ConfigInfo;

		public readonly ConfigEntry<string> ConfigBackup;

		public readonly ConfigEntry<string> ConfigLayout;

		public readonly ConfigEntry<bool> MansionScrapPackEnabled;

		public readonly ConfigEntry<bool> FacilityScrapPackEnabled;

		public readonly ConfigEntry<bool> TicketLoaded;

		public readonly ConfigEntry<bool> TicketSpawnsAsScrap;

		public readonly ConfigEntry<string> TicketMoonSpawnWeights;

		public readonly ConfigEntry<int> TicketGlobalSpawnWeight;

		public readonly ConfigEntry<bool> GoldenTicketLoaded;

		public readonly ConfigEntry<bool> GoldenTicketSpawnsAsScrap;

		public readonly ConfigEntry<string> GoldenTicketMoonSpawnWeights;

		public readonly ConfigEntry<int> GoldenTicketGlobalSpawnWeight;

		public readonly ConfigEntry<bool> RoseLoaded;

		public readonly ConfigEntry<bool> RoseSpawnsAsScrap;

		public readonly ConfigEntry<string> RoseMoonSpawnWeights;

		public readonly ConfigEntry<int> RoseGlobalSpawnWeight;

		public readonly ConfigEntry<bool> SizableScissorsLoaded;

		public readonly ConfigEntry<bool> SizableScissorsSpawnsAsScrap;

		public readonly ConfigEntry<string> SizableScissorsMoonSpawnWeights;

		public readonly ConfigEntry<int> SizableScissorsGlobalSpawnWeight;

		public readonly ConfigEntry<bool> WalkingCaneLoaded;

		public readonly ConfigEntry<bool> WalkingCaneSpawnsAsScrap;

		public readonly ConfigEntry<string> WalkingCaneMoonSpawnWeights;

		public readonly ConfigEntry<int> WalkingCaneGlobalSpawnWeight;

		public readonly ConfigEntry<bool> CandyDispenserLoaded;

		public readonly ConfigEntry<bool> CandyDispenserSpawnsAsScrap;

		public readonly ConfigEntry<string> CandyDispenserMoonSpawnWeights;

		public readonly ConfigEntry<int> CandyDispenserGlobalSpawnWeight;

		public readonly ConfigEntry<bool> VintageCandyLoaded;

		public readonly ConfigEntry<bool> VintageCandySpawnsAsScrap;

		public readonly ConfigEntry<string> VintageCandyMoonSpawnWeights;

		public readonly ConfigEntry<int> VintageCandyGlobalSpawnWeight;

		public readonly ConfigEntry<bool> FuelCylinderLoaded;

		public readonly ConfigEntry<bool> FuelCylinderSpawnsAsScrap;

		public readonly ConfigEntry<string> FuelCylinderMoonSpawnWeights;

		public readonly ConfigEntry<int> FuelCylinderGlobalSpawnWeight;

		public readonly ConfigEntry<bool> RadioactiveCellLoaded;

		public readonly ConfigEntry<bool> RadioactiveCellSpawnsAsScrap;

		public readonly ConfigEntry<string> RadioactiveCellMoonSpawnWeights;

		public readonly ConfigEntry<int> RadioactiveCellGlobalSpawnWeight;

		public readonly ConfigEntry<bool> GloomyCapsuleLoaded;

		public readonly ConfigEntry<bool> GloomyCapsuleSpawnsAsScrap;

		public readonly ConfigEntry<string> GloomyCapsuleMoonSpawnWeights;

		public readonly ConfigEntry<int> GloomyCapsuleGlobalSpawnWeight;

		public readonly ConfigEntry<bool> FrigidCapsuleLoaded;

		public readonly ConfigEntry<bool> FrigidCapsuleSpawnsAsScrap;

		public readonly ConfigEntry<string> FrigidCapsuleMoonSpawnWeights;

		public readonly ConfigEntry<int> FrigidCapsuleGlobalSpawnWeight;

		public readonly ConfigEntry<bool> BloodyCapsuleLoaded;

		public readonly ConfigEntry<bool> BloodyCapsuleSpawnsAsScrap;

		public readonly ConfigEntry<string> BloodyCapsuleMoonSpawnWeights;

		public readonly ConfigEntry<int> BloodyCapsuleGlobalSpawnWeight;

		public readonly ConfigEntry<bool> PadlockLoaded;

		public readonly ConfigEntry<bool> PadlockSpawnsAsScrap;

		public readonly ConfigEntry<string> PadlockMoonSpawnWeights;

		public readonly ConfigEntry<int> PadlockGlobalSpawnWeight;

		public readonly ConfigEntry<bool> CrowbarLoaded;

		public readonly ConfigEntry<bool> CrowbarSpawnsAsScrap;

		public readonly ConfigEntry<string> CrowbarMoonSpawnWeights;

		public readonly ConfigEntry<int> CrowbarGlobalSpawnWeight;

		public readonly ConfigEntry<bool> FireAxeLoaded;

		public readonly ConfigEntry<bool> FireAxeSpawnsAsScrap;

		public readonly ConfigEntry<string> FireAxeMoonSpawnWeights;

		public readonly ConfigEntry<int> FireAxeGlobalSpawnWeight;

		public readonly ConfigEntry<bool> SledgehammerLoaded;

		public readonly ConfigEntry<bool> SledgehammerSpawnsAsScrap;

		public readonly ConfigEntry<string> SledgehammerMoonSpawnWeights;

		public readonly ConfigEntry<int> SledgehammerGlobalSpawnWeight;

		public readonly ConfigEntry<bool> AntiqueSwordLoaded;

		public readonly ConfigEntry<bool> AntiqueSwordSpawnsAsScrap;

		public readonly ConfigEntry<string> AntiqueSwordMoonSpawnWeights;

		public readonly ConfigEntry<int> AntiqueSwordGlobalSpawnWeight;

		public readonly ConfigEntry<bool> RegalScepterLoaded;

		public readonly ConfigEntry<bool> RegalScepterSpawnsAsScrap;

		public readonly ConfigEntry<string> RegalScepterMoonSpawnWeights;

		public readonly ConfigEntry<int> RegalScepterGlobalSpawnWeight;

		public readonly ConfigEntry<bool> HandlampLoaded;

		public readonly ConfigEntry<bool> HandlampIsStoreItem;

		public readonly ConfigEntry<int> HandlampStorePrice;

		public readonly ConfigEntry<bool> BandagesLoaded;

		public readonly ConfigEntry<bool> BandagesIsStoreItem;

		public readonly ConfigEntry<int> BandagesStorePrice;

		public readonly ConfigEntry<bool> MedicalKitLoaded;

		public readonly ConfigEntry<bool> MedicalKitIsStoreItem;

		public readonly ConfigEntry<int> MedicalKitStorePrice;

		public readonly ConfigEntry<bool> DefibrillatorLoaded;

		public readonly ConfigEntry<bool> DefibrillatorIsStoreItem;

		public readonly ConfigEntry<int> DefibrillatorStorePrice;

		public readonly ConfigEntry<bool> DefibrillatorRequiresBattery;

		public readonly ConfigEntry<bool> DefibrillatorUsesLimited;

		public readonly ConfigEntry<int> DefibrillatorUseLimit;

		public readonly ConfigEntry<bool> DefibrillatorPermaDeathRule;

		public readonly ConfigEntry<bool> DefibrillatorRefillsOnLanding;

		public readonly ConfigEntry<bool> ProductivityAutoinjectorLoaded;

		public readonly ConfigEntry<bool> ProductivityAutoinjectorIsStoreItem;

		public readonly ConfigEntry<int> ProductivityAutoinjectorStorePrice;

		public readonly ConfigEntry<bool> BlowtorchLoaded;

		public readonly ConfigEntry<bool> BlowtorchIsStoreItem;

		public readonly ConfigEntry<int> BlowtorchStorePrice;

		public readonly ConfigEntry<bool> ShockBatonLoaded;

		public readonly ConfigEntry<bool> ShockBatonIsStoreItem;

		public readonly ConfigEntry<int> ShockBatonStorePrice;

		public readonly ConfigEntry<bool> ShiftControllerLoaded;

		public readonly ConfigEntry<bool> ShiftControllerIsStoreItem;

		public readonly ConfigEntry<int> ShiftControllerStorePrice;

		public readonly ConfigEntry<int> ShiftControllerGreatRange;

		public readonly ConfigEntry<int> ShiftControllerPoorRange;

		public readonly ConfigEntry<string> PocketWatchMoonSpawnWeights;

		public readonly ConfigEntry<int> PocketWatchGlobalSpawnWeight;

		public readonly ConfigEntry<string> ServantBellMoonSpawnWeights;

		public readonly ConfigEntry<int> ServantBellGlobalSpawnWeight;

		public readonly ConfigEntry<string> ChessPiecesMoonSpawnWeights;

		public readonly ConfigEntry<int> ChessPiecesGlobalSpawnWeight;

		public readonly ConfigEntry<string> GoldenChessPiecesMoonSpawnWeights;

		public readonly ConfigEntry<int> GoldenChessPiecesGlobalSpawnWeight;

		public readonly ConfigEntry<string> TrafficConeMoonSpawnWeights;

		public readonly ConfigEntry<int> TrafficConeGlobalSpawnWeight;

		public readonly ConfigEntry<string> MereGearMoonSpawnWeights;

		public readonly ConfigEntry<int> MereGearGlobalSpawnWeight;

		public readonly ConfigEntry<bool> CapsulesDisabledOnTheShip;

		public readonly ConfigEntry<bool> TicketsFunctionOnCheapItems;

		public readonly ConfigEntry<bool> DisableItemIcons;

		public readonly ConfigEntry<bool> DebugLogging;

		public UsualScrapConfigs(ConfigFile cfg)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			try
			{
				string configFilePath = cfg.ConfigFilePath;
				if (File.Exists(configFilePath))
				{
					string destFileName = configFilePath + ".bak";
					File.Copy(configFilePath, destFileName, overwrite: true);
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("Usual Scrap - Failed to create config backup: " + ex.Message));
			}
			cfg.SaveOnConfigSet = false;
			ConfigInfo = cfg.Bind<string>("0. Important Information", "Modded Moon Generation", "Read Above", new ConfigDescription("Modded Moon Config Generation: If this is your first time using the mod, or you have added or removed moon mods, launch the game and enter a save with this installed to generate modded moon config entries", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigBackup = cfg.Bind<string>("0. Important Information", "Config backup", "Read Above", new ConfigDescription("Config Backup Saves: Configs will always be saved to a backup before being recreated, it can be found alongside your original config file", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigLayout = cfg.Bind<string>("0. Important Information", "Moon Config Formatting", "Read Above", new ConfigDescription("Moon Config Format: Moon=Weight, Moon=Weight, Moon=Weight,...\n• Unspecified or disabled moon weights will use the global weight setting instead, specified moon weights overwrite the global weight individually\n• Set a specific moon's weight to -1 to use the global weight (this is the Default setting)\n• Set the global weight to -1 to disable spawning on unspecified moons\n• Incorrectly formatted entries will be skipped, reset, and reported in the log\n• After adding or removing moon mods you must launch the game and enter a save once to generate config entries to edit for those new moons or clear old entries", (AcceptableValueBase)null, Array.Empty<object>()));
			DebugLogging = cfg.Bind<bool>("1. Debugging", "Log actions for debugging purposes", false, "Whether or not to log actions for debugging purposes");
			DisableItemIcons = cfg.Bind<bool>("2. General Options", "Disable Item Icons", false, "Whether or not to disable this mod's items icons (For use with runtime icons or similar mods)");
			MansionScrapPackEnabled = cfg.Bind<bool>("3. Scrap Packs", "Mansion Scrap Pack Enabled", false, "Whether or not the Mansion Scrap Pack is enabled, required for scrap pack items below to spawn. Scrap Packs include thematic items that have little to no function besides being scrap, they could be considered bloat and so they are in a pack");
			FacilityScrapPackEnabled = cfg.Bind<bool>("3. Scrap Packs", "Facility Scrap Pack Enabled", false, "Whether or not the Facility Scrap Pack is enabled, required for scrap pack items below to spawn. Scrap Packs include thematic items that have little to no function besides being scrap, they could be considered bloat and so they are in a pack");
			PocketWatchMoonSpawnWeights = cfg.Bind<string>("5. Scrap Pack Items", "Pocket Watch Moon Spawn Weight", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Pocket Watch will spawn, -1 to disable");
			PocketWatchGlobalSpawnWeight = cfg.Bind<int>("5. Scrap Pack Items", "Pocket Watch Global Spawn Weight", 15, "How often the Pocket Watch will spawn globally, -1 to disable");
			ServantBellMoonSpawnWeights = cfg.Bind<string>("5. Scrap Pack Items", "Servant Bell Moon Spawn Weight", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Servant Bell will spawn, -1 to disable");
			ServantBellGlobalSpawnWeight = cfg.Bind<int>("5. Scrap Pack Items", "Servant Bell Global Spawn Weight", 15, "How often the Servant Bell will spawn globally, -1 to disable");
			ChessPiecesMoonSpawnWeights = cfg.Bind<string>("5. Scrap Pack Items", "Chess Pieces Moon Spawn Weight", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often Chess Pieces will spawn, -1 to disable");
			ChessPiecesGlobalSpawnWeight = cfg.Bind<int>("5. Scrap Pack Items", "Chess Pieces Global Spawn Weight", 30, "How often Chess Pieces will spawn globally, -1 to disable");
			GoldenChessPiecesMoonSpawnWeights = cfg.Bind<string>("5. Scrap Pack Items", "Golden Chess Pieces Moon Spawn Weight", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often Golden Chess Pieces will spawn, -1 to disable");
			GoldenChessPiecesGlobalSpawnWeight = cfg.Bind<int>("5. Scrap Pack Items", "Golden Chess Pieces Global Spawn Weight", 10, "How often Golden Chess Pieces will spawn globally, -1 to disable");
			TrafficConeMoonSpawnWeights = cfg.Bind<string>("5. Scrap Pack Items", "Traffic Cone Moon Spawn Weight", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Traffic Cone will spawn, -1 to disable");
			TrafficConeGlobalSpawnWeight = cfg.Bind<int>("5. Scrap Pack Items", "Traffic Cone Global Spawn Weight", 20, "How often the Traffic Cone will spawn globally, -1 to disable");
			MereGearMoonSpawnWeights = cfg.Bind<string>("5. Scrap Pack Items", "Mere Gear Moon Spawn Weight", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Mere Gear will spawn, -1 to disable");
			MereGearGlobalSpawnWeight = cfg.Bind<int>("5. Scrap Pack Items", "Mere Gear Global Spawn Weight", 25, "How often Mere Gear will spawn globally, -1 to disable");
			TicketsFunctionOnCheapItems = cfg.Bind<bool>("Scrap Items - Tickets", "Tickets function on cheap items", true, "Whether or not tickets function when used on items with a value below 5 (Meaning tickets will no longer work on most equipment whose value is normally 0)");
			TicketLoaded = cfg.Bind<bool>("Scrap Items - Tickets", "Ticket is loaded", true, "Whether or not the Ticket is loaded");
			TicketSpawnsAsScrap = cfg.Bind<bool>("Scrap Items - Tickets", "Ticket is a scrap item", true, "Whether or not the Ticket spawns as scrap");
			TicketMoonSpawnWeights = cfg.Bind<string>("Scrap Items - Tickets", "Ticket Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Ticket will spawn, -1 to disable");
			TicketGlobalSpawnWeight = cfg.Bind<int>("Scrap Items - Tickets", "Ticket Global Spawning", 40, "How often the Ticket will spawn globally, -1 to disable");
			GoldenTicketLoaded = cfg.Bind<bool>("Scrap Items - Tickets", "Golden Ticket is loaded", true, "Whether or not the Golden Ticket is loaded");
			GoldenTicketSpawnsAsScrap = cfg.Bind<bool>("Scrap Items - Tickets", "Golden Ticket is a scrap item", true, "Whether or not the Golden Ticket spawns as scrap");
			GoldenTicketMoonSpawnWeights = cfg.Bind<string>("Scrap Items - Tickets", "Golden Ticket Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Golden Ticket will spawn, -1 to disable");
			GoldenTicketGlobalSpawnWeight = cfg.Bind<int>("Scrap Items - Tickets", "Golden Ticket Global Spawning", 5, "How often the Golden Ticket will spawn globally, -1 to disable");
			RoseLoaded = cfg.Bind<bool>("Scrap Item - Rose", "Rose is loaded", true, "Whether or not the Rose is loaded");
			RoseSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Rose", "Rose is a scrap item", true, "Whether or not the Rose spawns as scrap");
			RoseMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Rose", "Rose Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Rose will spawn, -1 to disable");
			RoseGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Rose", "Rose Global Spawning", 35, "How often the Rose will spawn globally, -1 to disable");
			SizableScissorsLoaded = cfg.Bind<bool>("Scrap Item - Sizable Scissors", "Sizable Scissors is loaded", true, "Whether or not the Sizable Scissors is loaded");
			SizableScissorsSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Sizable Scissors", "Sizable Scissors is a scrap item", true, "Whether or not the Sizable Scissors spawns as scrap");
			SizableScissorsMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Sizable Scissors", "Sizable Scissors Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Sizable Scissors will spawn, -1 to disable");
			SizableScissorsGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Sizable Scissors", "Sizable Scissors Global Spawning", 20, "How often the Sizable Scissors will spawn globally, -1 to disable");
			WalkingCaneLoaded = cfg.Bind<bool>("Scrap Item - Walking Cane", "Walking Cane is loaded", true, "Whether or not the Walking Cane is loaded");
			WalkingCaneSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Walking Cane", "Walking Cane is a scrap item", true, "Whether or not the Walking Cane spawns as scrap");
			WalkingCaneMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Walking Cane", "Walking Cane Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Walking Cane will spawn, -1 to disable");
			WalkingCaneGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Walking Cane", "Walking Cane Global Spawning", 15, "How often the Walking Cane will spawn globally, -1 to disable");
			CandyDispenserLoaded = cfg.Bind<bool>("Scrap Item - Candy Dispenser", "Candy Dispenser is loaded", true, "Whether or not the Candy Dispenser is loaded");
			CandyDispenserSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Candy Dispenser", "Candy Dispenser is a scrap item", true, "Whether or not the Candy Dispenser spawns as scrap");
			CandyDispenserMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Candy Dispenser", "Candy Dispenser Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Candy Dispenser will spawn, -1 to disable");
			CandyDispenserGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Candy Dispenser", "Candy Dispenser Global Spawning", 30, "How often the Candy Dispenser will spawn globally, -1 to disable");
			VintageCandyLoaded = cfg.Bind<bool>("Scrap Item - Vintage Candy", "Vintage Candy is loaded", true, "Whether or not the Vintage Candy is loaded, this is ignored and set to true automatically if the candy dispenser is loaded");
			VintageCandySpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Vintage Candy", "Vintage Candy is a scrap item", true, "Whether or not the Vintage Candy spawns as scrap");
			VintageCandyMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Vintage Candy", "Vintage Candy Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often Vintage Candy will spawn, -1 to disable");
			VintageCandyGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Vintage Candy", "Vintage Candy Global Spawning", 20, "How often Vintage Candy will spawn globally, -1 to disable");
			FuelCylinderLoaded = cfg.Bind<bool>("Scrap Item - Fuel Cylinder", "Fuel Cylinder is loaded", true, "Whether or not the Fuel Cylinder is loaded");
			FuelCylinderSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Fuel Cylinder", "Fuel Cylinder is a scrap item", true, "Whether or not the Fuel Cylinder spawns as scrap");
			FuelCylinderMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Fuel Cylinder", "Fuel Cylinder Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Fuel Cylinder will spawn, -1 to disable");
			FuelCylinderGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Fuel Cylinder", "Fuel Cylinder Global Spawning", 25, "How often the Fuel Cylinder will spawn globally, -1 to disable");
			RadioactiveCellLoaded = cfg.Bind<bool>("Scrap Item - Radioactive Cell", "Radioactive Cell is loaded", true, "Whether or not the Radioactive Cell is loaded");
			RadioactiveCellSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Radioactive Cell", "Radioactive Cell is a scrap item", true, "Whether or not the Radioactive Cell spawns as scrap");
			RadioactiveCellMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Radioactive Cell", "Radioactive Cell Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Radioactive Cell will spawn, -1 to disable");
			RadioactiveCellGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Radioactive Cell", "Radioactive Cell Global Spawning", 20, "How often the Radioactive Cell will spawn globally, -1 to disable");
			CapsulesDisabledOnTheShip = cfg.Bind<bool>("Scrap Items - Capsules", "Capsules Disabled On The Ship", true, "Whether or not capsules are disabled inside the ship when landed (Capsules are disabled in orbit always)");
			GloomyCapsuleLoaded = cfg.Bind<bool>("Scrap Items - Capsules", "Gloomy Capsule is loaded", true, "Whether or not the Gloomy Capsule is loaded");
			GloomyCapsuleSpawnsAsScrap = cfg.Bind<bool>("Scrap Items - Capsules", "Gloomy Capsule is a scrap item", true, "Whether or not the Gloomy Capsule spawns as scrap");
			GloomyCapsuleMoonSpawnWeights = cfg.Bind<string>("Scrap Items - Capsules", "Gloomy Capsule Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Gloomy Capsule will spawn, -1 to disable");
			GloomyCapsuleGlobalSpawnWeight = cfg.Bind<int>("Scrap Items - Capsules", "Gloomy Capsule Global Spawning", 15, "How often the Gloomy Capsule will spawn globally, -1 to disable");
			FrigidCapsuleLoaded = cfg.Bind<bool>("Scrap Items - Capsules", "Frigid Capsule is loaded", true, "Whether or not the Frigid Capsule is loaded");
			FrigidCapsuleSpawnsAsScrap = cfg.Bind<bool>("Scrap Items - Capsules", "Frigid Capsule is a scrap item", true, "Whether or not the Frigid Capsule spawns as scrap");
			FrigidCapsuleMoonSpawnWeights = cfg.Bind<string>("Scrap Items - Capsules", "Frigid Capsule Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Frigid Capsule will spawn, -1 to disable");
			FrigidCapsuleGlobalSpawnWeight = cfg.Bind<int>("Scrap Items - Capsules", "Frigid Capsule Global Spawning", 15, "How often the Frigid Capsule will spawn globally, -1 to disable");
			BloodyCapsuleLoaded = cfg.Bind<bool>("Scrap Items - Capsules", "Bloody Capsule is loaded", true, "Whether or not the Bloody Capsule is loaded");
			BloodyCapsuleSpawnsAsScrap = cfg.Bind<bool>("Scrap Items - Capsules", "Bloody Capsule is a scrap item", true, "Whether or not the Bloody Capsule spawns as scrap");
			BloodyCapsuleMoonSpawnWeights = cfg.Bind<string>("Scrap Items - Capsules", "Bloody Capsule Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Bloody Capsule will spawn, -1 to disable");
			BloodyCapsuleGlobalSpawnWeight = cfg.Bind<int>("Scrap Items - Capsules", "Bloody Capsule Global Spawning", 15, "How often the Bloody Capsule will spawn globally, -1 to disable");
			PadlockLoaded = cfg.Bind<bool>("Scrap Item - Padlock", "Padlock is loaded", true, "Whether or not the Padlock is loaded");
			PadlockSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Padlock", "Padlock is a scrap item", true, "Whether or not the Padlock spawns as scrap");
			PadlockMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Padlock", "Padlock Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Padlock will spawn, -1 to disable");
			PadlockGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Padlock", "Padlock Global Spawning", 35, "How often the Padlock will spawn globally, -1 to disable");
			CrowbarLoaded = cfg.Bind<bool>("Scrap Item - Crowbar", "Crowbar is loaded", true, "Whether or not the Crowbar is loaded");
			CrowbarSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Crowbar", "Crowbar is a scrap item", true, "Whether or not the Crowbar spawns as scrap");
			CrowbarMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Crowbar", "Crowbar Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Crowbar will spawn, -1 to disable");
			CrowbarGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Crowbar", "Crowbar Global Spawning", 25, "How often the Crowbar will spawn globally, -1 to disable");
			FireAxeLoaded = cfg.Bind<bool>("Scrap Item - Fire Axe", "Fire Axe is loaded", false, "Whether or not the Fire Axe is loaded");
			FireAxeSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Fire Axe", "Fire Axe is a scrap item", true, "Whether or not the Fire Axe spawns as scrap");
			FireAxeMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Fire Axe", "Fire Axe Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Fire Axe will spawn, -1 to disable");
			FireAxeGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Fire Axe", "Fire Axe Global Spawning", 25, "How often the Fire Axe will spawn globally, -1 to disable");
			SledgehammerLoaded = cfg.Bind<bool>("Scrap Item - Sledgehammer", "Sledgehammer is loaded", true, "Whether or not the Sledgehammer is loaded");
			SledgehammerSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Sledgehammer", "Sledgehammer is a scrap item", true, "Whether or not the Sledgehammer spawns as scrap");
			SledgehammerMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Sledgehammer", "Sledgehammer Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Sledgehammer will spawn, -1 to disable");
			SledgehammerGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Sledgehammer", "Sledgehammer Global Spawning", 20, "How often the Sledgehammer will spawn globally, -1 to disable");
			AntiqueSwordLoaded = cfg.Bind<bool>("Scrap Item - Antique Sword", "Antique Sword is loaded", false, "Whether or not the Antique Sword is loaded");
			AntiqueSwordSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Antique Sword", "Antique Sword is a scrap item", true, "Whether or not the Antique Sword spawns as scrap");
			AntiqueSwordMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Antique Sword", "Antique Sword Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Antique Sword will spawn, -1 to disable");
			AntiqueSwordGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Antique Sword", "Antique Sword Global Spawning", 20, "How often the Antique Sword will spawn globally, -1 to disable");
			RegalScepterLoaded = cfg.Bind<bool>("Scrap Item - Regal Scepter", "Regal Scepter is loaded", false, "Whether or not the Regal Scepter is loaded");
			RegalScepterSpawnsAsScrap = cfg.Bind<bool>("Scrap Item - Regal Scepter", "Regal Scepter is a scrap item", true, "Whether or not the Regal Scepter spawns as scrap");
			RegalScepterMoonSpawnWeights = cfg.Bind<string>("Scrap Item - Regal Scepter", "Regal Scepter Moon Spawning", "experimentation=-1, vow=-1, march=-1, assurance=-1, offense=-1, rend=-1, dine=-1, titan=-1, adamance=-1, artifice=-1, embrion=-1", "Specifically which moons and how often the Regal Scepter will spawn, -1 to disable");
			RegalScepterGlobalSpawnWeight = cfg.Bind<int>("Scrap Item - Regal Scepter", "Regal Scepter Global Spawning", 15, "How often the Regal Scepter will spawn globally, -1 to disable");
			HandlampLoaded = cfg.Bind<bool>("Store Item - Handlamp", "Handlamp is loaded", true, "Whether or not the Handlamp is loaded");
			HandlampIsStoreItem = cfg.Bind<bool>("Store Item - Handlamp", "Handlamp is a store item", true, "Whether or not the Handlamp is a store item");
			HandlampStorePrice = cfg.Bind<int>("Store Item - Handlamp", "Handlamp store price", 25, "The store price of the Handlamp (Cannot be a negative number)");
			BandagesLoaded = cfg.Bind<bool>("Store Item - Bandages", "Bandages are loaded", true, "Whether or not the Bandages are loaded");
			BandagesIsStoreItem = cfg.Bind<bool>("Store Item - Bandages", "Bandages are a store item", true, "Whether or not the Bandages are a store item");
			BandagesStorePrice = cfg.Bind<int>("Store Item - Bandages", "Bandages store price", 20, "The store price of the Bandages (Cannot be a negative number)");
			MedicalKitLoaded = cfg.Bind<bool>("Store Item - Medical Kit", "Medical Kit is loaded", true, "Whether or not the Medical Kit is loaded");
			MedicalKitIsStoreItem = cfg.Bind<bool>("Store Item - Medical Kit", "Medical Kit is a store item", true, "Whether or not the Medical Kit is a store item");
			MedicalKitStorePrice = cfg.Bind<int>("Store Item - Medical Kit", "Medical Kit store price", 120, "The store price of the Medical Kit (Cannot be a negative number)");
			DefibrillatorLoaded = cfg.Bind<bool>("Store Item - Defibrillator", "Defibrillator is loaded", true, "Whether or not the Defibrillator is loaded");
			DefibrillatorIsStoreItem = cfg.Bind<bool>("Store Item - Defibrillator", "Defibrillator is a store item", true, "Whether or not the Defibrillator is a store item");
			DefibrillatorStorePrice = cfg.Bind<int>("Store Item - Defibrillator", "Defibrillator store price", 375, "The store price of the Defibrillator (Cannot be a negative number)");
			DefibrillatorRequiresBattery = cfg.Bind<bool>("Store Item - Defibrillator", "Defibrillator requires battery", true, "Whether or not the Defibrillator requires battery");
			DefibrillatorUsesLimited = cfg.Bind<bool>("Store Item - Defibrillator", "Defibrillator uses are limited", true, "Whether or not Defibrillators have limited uses");
			DefibrillatorUseLimit = cfg.Bind<int>("Store Item - Defibrillator", "Defibrillators use limit", 3, "The number of uses each Defibrillator has (Uses have a minimum of 1, uses are used up on players successfully revived only)");
			DefibrillatorRefillsOnLanding = cfg.Bind<bool>("Store Item - Defibrillator", "Defibrillator refills every moon landing", false, "Whether or not existing Defibrillators will refill their uses upon landing on a moon");
			DefibrillatorPermaDeathRule = cfg.Bind<bool>("Store Item - Defibrillator", "Defibrillator follows perma-death rules", true, "Whether or not specific causes of death will prevent the defibrillator from reviving players (Ex - Corpses decapitated by CoilHeads, Corpses snipped in half by a Barber, Corpses head popped by the Ghost Girl)");
			ProductivityAutoinjectorLoaded = cfg.Bind<bool>("Store Item - Productivity Autoinjector", "Productivity Autoinjector is loaded", true, "Whether or not the Productivity Autoinjector is loaded");
			ProductivityAutoinjectorIsStoreItem = cfg.Bind<bool>("Store Item - Productivity Autoinjector", "Productivity Autoinjector is a store item", true, "Whether or not the Productivity Autoinjector is a store item");
			ProductivityAutoinjectorStorePrice = cfg.Bind<int>("Store Item - Productivity Autoinjector", "Productivity Autoinjector store price", 90, "The store price of the Productivity Autoinjector");
			BlowtorchLoaded = cfg.Bind<bool>("Store Item - Blowtorch", "Blowtorch is loaded", true, "Whether or not the Blowtorch is loaded");
			BlowtorchIsStoreItem = cfg.Bind<bool>("Store Item - Blowtorch", "Blowtorch is a store item", true, "Whether or not the Blowtorch is a store item");
			BlowtorchStorePrice = cfg.Bind<int>("Store Item - Blowtorch", "Blowtorch store price", 245, "The store price of the Blowtorch");
			ShockBatonLoaded = cfg.Bind<bool>("Store Item - Shock Baton", "Shock Baton is loaded", false, "Whether or not the Shock Baton is loaded");
			ShockBatonIsStoreItem = cfg.Bind<bool>("Store Item - Shock Baton", "Shock Baton is a store item", true, "Whether or not the Shock Baton is a store item");
			ShockBatonStorePrice = cfg.Bind<int>("Store Item - Shock Baton", "Shock Baton store price", 115, "The store price of the Shock Baton");
			ShiftControllerLoaded = cfg.Bind<bool>("Store Item - Shift Controller", "Shift Controller is loaded", true, "Whether or not the Shift Controller is loaded");
			ShiftControllerIsStoreItem = cfg.Bind<bool>("Store Item - Shift Controller", "Shift Controller is a store item", true, "Whether or not the Shift Controller is a store item");
			ShiftControllerStorePrice = cfg.Bind<int>("Store Item - Shift Controller", "Shift Controller store price", 225, "The store price of the Shift Controller");
			ShiftControllerGreatRange = cfg.Bind<int>("Store Item - Shift Controller", "Shift Controllers great/first connection range", 50, "The max range of the Shift Controller's great/first connection range. (The great/first connection range starts at 0 and stops at this value, The average/middle connection range starts at this value)");
			ShiftC