using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FMOD;
using FMOD.Studio;
using FMODUnity;
using HarmonyLib;
using ImGuiNET;
using Mono.Cecil;
using MonoMod.Utils.Cil;
using Receiver2;
using Receiver2ModdingKit.CustomRounds;
using Receiver2ModdingKit.CustomSounds;
using Receiver2ModdingKit.Editor;
using Receiver2ModdingKit.Gamemodes;
using Receiver2ModdingKit.Helpers;
using Receiver2ModdingKit.Logging;
using Receiver2ModdingKit.ModInstaller;
using Receiver2ModdingKit.Thunderstore;
using Rewired;
using RewiredConsts;
using SharpCompress.Archives;
using SharpCompress.Common;
using SharpCompress.Readers;
using SimpleJSON;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using Wolfire;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Receiver2ModdingKit
{
	public static class ModPersistentData
	{
		private const string k_PersistentDataKeyName = "mod_persistent_data";

		private static JSONObject persistent_data = new JSONObject();

		public static void AddPersistentData(PluginInfo pluginInfo, JSONObject data)
		{
			((JSONNode)persistent_data).Add(pluginInfo.Metadata.GUID, (JSONNode)(object)data);
		}

		public static JSONObject GetPersistentData(PluginInfo pluginInfo)
		{
			return ((JSONNode)persistent_data)[pluginInfo.Metadata.GUID].AsObject;
		}

		[HarmonyPatch(typeof(PersistentPlayerData), "Serialize")]
		[HarmonyPostfix]
		private static void AddDataToSave(JSONObject __result)
		{
			try
			{
				((JSONNode)__result).Add("mod_persistent_data", (JSONNode)(object)persistent_data);
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(PersistentPlayerData), "Deserialize")]
		[HarmonyPostfix]
		private static void RetrieveDataFromSave(JSONNode jn)
		{
			try
			{
				persistent_data = jn["mod_persistent_data"].AsObject;
			}
			catch
			{
			}
		}
	}
	internal class EditorInput
	{
		public static bool GetKeyDown(KeyCode key)
		{
			return false;
		}

		public static bool GetKeyUp(KeyCode key)
		{
			return false;
		}

		public static bool GetKey(KeyCode key)
		{
			return false;
		}

		public static Vector3 GetMousePos()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.zero;
		}

		public static Ray MouseRay()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return default(Ray);
		}
	}
	public static class Extensions
	{
		internal static JSONObject current_gun_data;

		internal static bool lah_force_bullet_display;

		internal static Queue<Tuple<PoseSpring, float>> pose_spring_overrides = new Queue<Tuple<PoseSpring, float>>();

		internal static bool unlock_cursor;

		internal static bool confine_cursor;

		internal static bool freeze_camera_rotation;

		internal static Type konType = null;

		public static Harmony getConsoleColorHarmonyInstance;

		public static Harmony logEventArgsToStringHarmonyInstance;

		public static ConsoleColor BackgroundColor
		{
			get
			{
				return (ConsoleColor)(konType?.GetProperty("BackgroundColor").GetMethod.Invoke(null, null));
			}
			set
			{
				konType?.GetProperty("BackgroundColor").SetMethod.Invoke(null, new object[1] { value });
			}
		}

		public static ShellCasingScript GetBullet(this LocalAimHandler lah, Preset cartridge_dimension)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected I4, but got Unknown
			return lah.GetBullet((Preset[])(object)new Preset[1] { (Preset)(int)cartridge_dimension });
		}

		public static ShellCasingScript GetBullet(this LocalAimHandler lah, uint cartridge_dimension)
		{
			return lah.GetBullet((Preset[])(object)new Preset[1] { (Preset)cartridge_dimension });
		}

		public static ShellCasingScript GetBullet(this LocalAimHandler lah, Preset[] cartridge_dimensions)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			if ((Object)(object)lah == (Object)null)
			{
				Debug.LogError((object)"(Extension) LocalAimHandler.GetBullet(): This LocalAimHandler instance is null");
				return null;
			}
			if (cartridge_dimensions == null)
			{
				Debug.LogError((object)"(Extension) LocalAimHandler.GetBullet(): You have to provide a CartridgeSpec array");
				return null;
			}
			object obj = ReflectionManager.LAH_Get_Last_Bullet.Invoke(lah, new object[1] { cartridge_dimensions });
			if (obj == null)
			{
				return null;
			}
			return (ShellCasingScript)ReflectionManager.LAH_BulletInventory_item.GetValue(obj);
		}

		public static ShellCasingScript GetBullet(this LocalAimHandler lah, uint[] cartridge_dimensions)
		{
			return lah.GetBullet(cartridge_dimensions.Cast<Preset>().ToArray());
		}

		public static void ShowBullets(this LocalAimHandler lah, bool show_bullets)
		{
			lah_force_bullet_display = show_bullets;
		}

		public static void ForceCursorUnlock(bool unlock, bool confine)
		{
			unlock_cursor = unlock;
			confine_cursor = confine;
		}

		public static void ShakeBullets(this LocalAimHandler lah)
		{
			if ((Object)(object)lah != (Object)null)
			{
				ReflectionManager.LAH_bullet_shake_time.SetValue(lah, Time.time);
			}
		}

		public static float GetSpringState(this LocalAimHandler lah, PoseSpring spring)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)lah == (Object)null)
			{
				Debug.LogError((object)"(Extension) LocalAimHandler.GetSpringState(): This LocalAimHandler instance is null");
				return 0f;
			}
			return ((Spring)ReflectionManager.LAH_pose_springs[spring].GetValue(lah)).state;
		}

		public static void OverrideSpringState(this LocalAimHandler lah, PoseSpring spring, float amount)
		{
			pose_spring_overrides.Enqueue(new Tuple<PoseSpring, float>(spring, amount));
		}

		public static bool TryGetChild(this DirectoryInfo dir, string child_directory_name, out DirectoryInfo child_directory)
		{
			string path = Path.Combine(dir.FullName, child_directory_name);
			child_directory = new DirectoryInfo(path);
			return Directory.Exists(path);
		}

		public static void Disable(this ActiveItem active_item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			active_item.item_type = (Type)6;
		}

		public static void SetItemSpawn(this ActiveItem active_item, InventoryItem item, JSONObject persistentData = null)
		{
			active_item.SetItemSpawn(((Object)(object)item != (Object)null) ? item.InternalName : "", persistentData);
		}

		public static void SetItemSpawn(this ActiveItem active_item, string item_internal_name, JSONObject persistentData = null)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			active_item.item_type = (Type)11;
			active_item.internal_name = item_internal_name;
			if ((JSONNode)(object)persistentData != (object)null)
			{
				active_item.persistent_data = persistentData;
			}
		}

		public static bool AddItemsToSpawnList(this ReceiverCoreScript core_script, params InventoryItem[] items)
		{
			if (ModLoader.rcs_prefab_list_locked)
			{
				ModLoader.prefab_list_queue.AddRange(items);
				return false;
			}
			core_script.generic_prefabs = core_script.generic_prefabs.Concat(items).ToArray();
			return true;
		}

		public static JSONObject GetCheckpointData(this ReceiverCoreScript core_script)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return (JSONObject)(((object)current_gun_data) ?? ((object)new JSONObject()));
		}

		public static void RemovePersistentListeners(this UnityEventBase unity_event)
		{
			if (unity_event.GetPersistentEventCount() != 0)
			{
				object value = ReflectionManager.UEB_persistent_calls.GetValue(unity_event);
				ReflectionManager.PCG_Clear.Invoke(value, new object[0]);
			}
		}

		public static void MoveTo(this FileInfo source_file, string destination_file, bool overwrite)
		{
			if (overwrite && File.Exists(destination_file))
			{
				File.Delete(destination_file);
			}
			source_file.MoveTo(destination_file);
		}

		public static BepInPlugin GetBepInAttribute(this BaseUnityPlugin plugin)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			return (BepInPlugin)Attribute.GetCustomAttribute(((object)plugin).GetType(), typeof(BepInPlugin));
		}

		public static bool TryFindObjectOfType<T>(out T result) where T : Object
		{
			return (Object)(object)(result = Object.FindObjectOfType<T>()) != (Object)null;
		}

		public static bool TryFindObjectsOfType<T>(out T[] result) where T : Object
		{
			return (result = Object.FindObjectsOfType<T>()) != null;
		}

		public static List<CodeInstruction> ToCodeInstructions(this MethodInfo methodInfo, Dictionary<CodeInstruction, CodeInstruction> replaceInstructionWith = null)
		{
			List<CodeInstruction> originalInstructions = PatchProcessor.GetOriginalInstructions((MethodBase)methodInfo, (ILGenerator)null);
			if (replaceInstructionWith != null)
			{
				for (int i = 0; i < originalInstructions.Count; i++)
				{
					if (replaceInstructionWith.TryGetValue(originalInstructions[i], out var value))
					{
						originalInstructions[i] = value;
					}
				}
			}
			return originalInstructions;
		}

		public static List<CodeInstruction> ToCodeInstructionsClipLast(this MethodInfo methodInfo, out List<Label> extractedLabels, Dictionary<CodeInstruction, CodeInstruction> replaceInstructionWith = null)
		{
			List<CodeInstruction> originalInstructions = PatchProcessor.GetOriginalInstructions((MethodBase)methodInfo, (ILGenerator)null);
			if (replaceInstructionWith != null)
			{
				for (int i = 0; i < originalInstructions.Count; i++)
				{
					if (replaceInstructionWith.TryGetValue(originalInstructions[i], out var value))
					{
						originalInstructions[i] = value;
					}
				}
			}
			extractedLabels = CodeInstructionExtensions.ExtractLabels(originalInstructions.Last());
			originalInstructions.Remove(originalInstructions.Last());
			return originalInstructions;
		}

		public static void LogWithCustomLevelName(this ManualLogSource logger, object data, string levelName)
		{
			logEventArgsToStringHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.LogEventArgsToStringPatch), (string)null);
			HarmonyManager.LogEventArgsToStringPatch.levelName = levelName;
			logger.Log((LogLevel)696969, data);
			logEventArgsToStringHarmonyInstance.UnpatchSelf();
		}

		public static void LogWithCustomLevelNameAndColor(this ManualLogSource logger, object data, string levelName, ConsoleColor color)
		{
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logEventArgsToStringHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.LogEventArgsToStringPatch), (string)null);
			HarmonyManager.LogEventArgsToStringPatch.levelName = levelName;
			logger.Log((LogLevel)696969, data);
			logEventArgsToStringHarmonyInstance.UnpatchSelf();
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogWithColor(this ManualLogSource logger, LogLevel logLevel, object data, ConsoleColor color)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.Log(logLevel, data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogDebugWithColor(this ManualLogSource logger, object data, ConsoleColor color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (getConsoleColorHarmonyInstance == null)
			{
				getConsoleColorHarmonyInstance = new Harmony("GetConsoleColor");
			}
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.LogDebug(data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogErrorWithColor(this ManualLogSource logger, object data, ConsoleColor color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (getConsoleColorHarmonyInstance == null)
			{
				getConsoleColorHarmonyInstance = new Harmony("GetConsoleColor");
			}
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.LogError(data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogFatalWithColor(this ManualLogSource logger, object data, ConsoleColor color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (getConsoleColorHarmonyInstance == null)
			{
				getConsoleColorHarmonyInstance = new Harmony("GetConsoleColor");
			}
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.LogFatal(data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogInfoWithColor(this ManualLogSource logger, object data, ConsoleColor color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (getConsoleColorHarmonyInstance == null)
			{
				getConsoleColorHarmonyInstance = new Harmony("GetConsoleColor");
			}
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.LogInfo(data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogMessageWithColor(this ManualLogSource logger, object data, ConsoleColor color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (getConsoleColorHarmonyInstance == null)
			{
				getConsoleColorHarmonyInstance = new Harmony("GetConsoleColor");
			}
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.LogMessage(data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}

		public static void LogWarningWithColor(this ManualLogSource logger, object data, ConsoleColor color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (getConsoleColorHarmonyInstance == null)
			{
				getConsoleColorHarmonyInstance = new Harmony("GetConsoleColor");
			}
			getConsoleColorHarmonyInstance = Harmony.CreateAndPatchAll(typeof(HarmonyManager.GetConsoleColorPatch), (string)null);
			HarmonyManager.GetConsoleColorPatch.consoleColor = color;
			logger.LogWarning(data);
			getConsoleColorHarmonyInstance.UnpatchSelf();
		}
	}
	public static class HarmonyManager
	{
		internal static class HarmonyInstances
		{
			public static Harmony Core;

			public static Harmony Transpilers;

			public static Harmony DebugPatches;

			public static Harmony Thunderstore;

			public static Harmony CustomSounds;

			public static Harmony ModHelpEntry;

			public static Harmony ModGameMode;

			public static Harmony CustomRoundTypes;

			public static Harmony ModPersistentData;
		}

		private static class Transpilers
		{
			private static GameModeMusicSpec current_working_music_spec;

			[HarmonyPatch(typeof(GunScript), "Update")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> GunScriptTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "gun_model"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Bne_Un, (object)null, (string)null)).Advance().InsertAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null))
					.InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModGunScript), "UpdateModGun", (Type[])null, (Type[])null)))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "UpdateSlide")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> GunScriptSlideTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "AccelFromChangeAndTime", (Type[])null, (Type[])null), (string)null)).SetOperandAndAdvance(AccessTools.Method(typeof(ModGunScript), "CalculateSlideAcceleration", (Type[])null, (Type[])null)).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "AccelFromChangeAndTime", (Type[])null, (Type[])null), (string)null))
					.SetOperandAndAdvance(AccessTools.Method(typeof(ModGunScript), "CalculateSlideAccelerationTime", (Type[])null, (Type[])null))
					.RemoveInstructions(2)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(RuntimeTileLevelGenerator), "PopulateItems")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PopulateItemsTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "gun_type"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)).SetOperandAndAdvance(AccessTools.Field(typeof(GunScript), "magazine_root_types")).InsertAndAdvance(new CodeInstruction(OpCodes.Ldlen, (object)null))
					.SetOpcodeAndAdvance(OpCodes.Ldc_I4_0)
					.SetOpcodeAndAdvance(OpCodes.Bne_Un_S)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(LocalAimHandler), "HandleGunControls")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> LAHGunControlsTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Expected O, but got Unknown
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "gun_model"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_I4_5, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Bne_Un, (object)null, (string)null)).Advance().SetOperandAndAdvance(AccessTools.Field(typeof(GunScript), "slide_lock_is_safety"))
					.SetOpcodeAndAdvance(OpCodes.Ldc_I4_1)
					.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Leave, (object)null, (string)null))
					.Advance()
					.Insert(new CodeInstruction(OpCodes.Nop, (object)null))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(LocalAimHandler), "UpdateLooseBulletDisplay")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> LAHBulletDisplayTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Expected O, but got Unknown
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Expected O, but got Unknown
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Expected O, but got Unknown
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Expected O, but got Unknown
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions).MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Brtrue, (object)null, (string)null));
				if (smartCodeMatcher.IsValid)
				{
					CodeInstruction instruction = smartCodeMatcher.Instruction;
					smartCodeMatcher.Start().MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(LocalAimHandler), "get_IsHoldingMagazine", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)).InsertAndAdvance(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Extensions), "lah_force_bullet_display")))
						.Insert(instruction);
				}
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(LocalAimHandler), "HandleGunControls")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> LAHHandleGunControlsTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Expected O, but got Unknown
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Expected O, but got Unknown
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Expected O, but got Unknown
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Expected O, but got Unknown
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Expected O, but got Unknown
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Expected O, but got Unknown
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Expected O, but got Unknown
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e8: Expected O, but got Unknown
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Expected O, but got Unknown
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions, generator).MatchForward(true, new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(GunScript), "mag_seated_wrong"), (string)null)).MatchBack(true, new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Newobj, (object)null, (string)null)).Advance()
					.InsertAndAdvance(new CodeInstruction(OpCodes.Ldarg_1, (object)null), new CodeInstruction(OpCodes.Isinst, (object)typeof(ModGunScript)))
					.Insert(OpCodes.Call, (object)AccessTools.Method(typeof(Vector3), "op_Multiply", new Type[2]
					{
						typeof(Vector3),
						typeof(float)
					}, (Type[])null))
					.CreateBranch(OpCodes.Brfalse_S, (CodeInstruction[])(object)new CodeInstruction[2]
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null),
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModGunScript), "GetMagSmackStrength", (Type[])null, (Type[])null))
					}, (CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_R4, (object)1f)
					});
				LocalBuilder localBuilder = generator.DeclareLocal(typeof(Vector3));
				smartCodeMatcher.Advance().InsertAndAdvance(new CodeInstruction(OpCodes.Stloc, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Ldloca, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Time), "get_time", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(Vector3), "z")), new CodeInstruction(OpCodes.Ldloc, (object)localBuilder.LocalIndex));
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(LocalAimHandler), "Update")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> LAHUpdateXRayTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(LocalAimHandler), "inspect_x_ray_timer"), (string)null)
				}).Advance(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Time), "get_timeScale", (Type[])null, (Type[])null)),
					new CodeInstruction(OpCodes.Div, (object)null)
				})
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(MagazineScript), "UpdateRoundPositions")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> MagazineFollowerTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(true, new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null)).Advance(-1).RemoveInstruction()
					.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Sub, (object)null, (string)null))
					.RemoveInstruction()
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(MenuManagerScript), "Update")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ModGameModeSupressMenu(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Expected O, but got Unknown
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Cursor), "set_visible", (Type[])null, (Type[])null), (string)null)).SetInstruction(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ModGameModeManager), "DisplayGameModeMenu"))).Advance(2)
					.SetInstruction(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ModGameModeManager), "DisplayGameModeMenu")))
					.Advance()
					.Insert(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null), new CodeInstruction(OpCodes.Ceq, (object)null))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(MusicScript), "Update")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ModGameModeMusic(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Expected O, but got Unknown
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Expected O, but got Unknown
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Expected O, but got Unknown
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Expected O, but got Unknown
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Expected O, but got Unknown
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Expected O, but got Unknown
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Expected O, but got Unknown
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Expected O, but got Unknown
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Expected O, but got Unknown
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Expected O, but got Unknown
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Expected O, but got Unknown
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_022d: Expected O, but got Unknown
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Expected O, but got Unknown
				//IL_026b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Expected O, but got Unknown
				//IL_0279: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Expected O, but got Unknown
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a0: Expected O, but got Unknown
				//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c1: Expected O, but got Unknown
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e2: Expected O, but got Unknown
				//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f0: Expected O, but got Unknown
				//IL_030c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0312: Expected O, but got Unknown
				//IL_032e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0334: Expected O, but got Unknown
				//IL_0350: Unknown result type (might be due to invalid IL or missing references)
				//IL_0356: Expected O, but got Unknown
				//IL_035f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0365: Expected O, but got Unknown
				//IL_0381: Unknown result type (might be due to invalid IL or missing references)
				//IL_0387: Expected O, but got Unknown
				//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a9: Expected O, but got Unknown
				//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_03cb: Expected O, but got Unknown
				//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03da: Expected O, but got Unknown
				//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fc: Expected O, but got Unknown
				//IL_0418: Unknown result type (might be due to invalid IL or missing references)
				//IL_041e: Expected O, but got Unknown
				//IL_043a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0440: Expected O, but got Unknown
				//IL_0449: Unknown result type (might be due to invalid IL or missing references)
				//IL_044f: Expected O, but got Unknown
				//IL_0461: Unknown result type (might be due to invalid IL or missing references)
				//IL_0467: Expected O, but got Unknown
				//IL_0483: Unknown result type (might be due to invalid IL or missing references)
				//IL_0489: Expected O, but got Unknown
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions, generator);
				smartCodeMatcher.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)1f, (string)null), new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "main_menu"), (string)null));
				smartCodeMatcher.Advance().RemoveInstructions(2).Advance(-1);
				smartCodeMatcher.SetAndAdvance(OpCodes.Ldloc_0, null).InsertAndAdvance(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ReceiverCoreScript), "game_mode")), new CodeInstruction(OpCodes.Ldnull, (object)null), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null)));
				smartCodeMatcher.CreateBranch(OpCodes.Brfalse, (CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ReceiverCoreScript), "game_mode")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(GameModeBase), "GetGameMode", (Type[])null, (Type[])null)),
					new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ModGameModeBase), "ModGameMode"))
				}, (CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldc_R4, (object)1f),
					new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "main_menu"))
				});
				smartCodeMatcher.MatchBack(false, new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null));
				CodeInstruction val = new CodeInstruction(smartCodeMatcher.Instruction);
				val.opcode = OpCodes.Bne_Un;
				smartCodeMatcher.Advance(5);
				smartCodeMatcher.InsertAndAdvance(val, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModGameModeManager), "get_CurrentGameMode", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(ModGameModeBase), "GetMusicParams", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Stsfld, (object)AccessTools.Field(typeof(Transpilers), "current_working_music_spec")), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Transpilers), "current_working_music_spec")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameModeMusicSpec), "target_global_gain")), new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "target_global_gain")), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Transpilers), "current_working_music_spec")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameModeMusicSpec), "gain_recover_delay")), new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "gain_recover_delay")), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Transpilers), "current_working_music_spec")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameModeMusicSpec), "danger")), new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "danger")), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Transpilers), "current_working_music_spec")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameModeMusicSpec), "mystical")), new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "mystical")), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(MusicScript), "main_menu")));
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "LoadCheckpoint")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ModGameModeLoad(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Stloc_3, (object)null, (string)null)).InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModGameModeManager), "ChooseGameModeFromJSON", (Type[])null, (Type[])null))).InstructionEnumeration();
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "TriggerCheckpoint")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ModGameModeSave(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions);
				smartCodeMatcher.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Constrained, (object)typeof(GameMode), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null));
				smartCodeMatcher.Advance();
				smartCodeMatcher.InsertAndAdvance(OpCodes.Pop);
				smartCodeMatcher.Insert(OpCodes.Call, (object)AccessTools.Method(typeof(ModGameModeManager), "GetGameModeName", (Type[])null, (Type[])null));
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(/*Could not decode attribute arguments.*/)]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ImDoingBad(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Expected O, but got Unknown
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Expected O, but got Unknown
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Expected O, but got Unknown
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldc_I4, (object)437, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Encoding), "GetEncoding", new Type[1] { typeof(int) }, (Type[])null), (string)null)).RemoveInstructions(2).Insert(new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Encoding), "Default")))
					.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldc_I4, (object)437, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Encoding), "GetEncoding", new Type[1] { typeof(int) }, (Type[])null), (string)null))
					.RemoveInstructions(2)
					.Insert(new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Encoding), "Default")))
					.InstructionEnumeration();
			}
		}

		private static class DebugTranspilers
		{
			[HarmonyPatch(typeof(MenuManagerScript), "UpdateDeveloperMenu")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> DevMenuTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Expected O, but got Unknown
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Expected O, but got Unknown
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected O, but got Unknown
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Expected O, but got Unknown
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Expected O, but got Unknown
				//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Expected O, but got Unknown
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_022d: Expected O, but got Unknown
				//IL_0255: Unknown result type (might be due to invalid IL or missing references)
				//IL_025b: Expected O, but got Unknown
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions, generator);
				return smartCodeMatcher.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"Subtitles", (string)null)).SetAndAdvance(OpCodes.Ldstr, "Tapes Unlock Debug").InsertAndAdvance(new CodeInstruction(OpCodes.Ldstr, (object)""))
					.InsertAndAdvance(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ModTapeManager), "tapes_debug_window_open")))
					.InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ImGui), "MenuItem", new Type[3]
					{
						typeof(string),
						typeof(string),
						typeof(bool)
					}, (Type[])null)))
					.InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModTapeManager), "SwitchMenuVisible", (Type[])null, (Type[])null)))
					.Insert(new CodeInstruction(OpCodes.Ldstr, (object)"Subtitles"))
					.Advance(-1)
					.InsertBranch(OpCodes.Brfalse, smartCodeMatcher.Pos + 1)
					.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ImGui), "EndMainMenuBar", (Type[])null, (Type[])null), (string)null))
					.SetAndAdvance(OpCodes.Ldstr, "Modding")
					.InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ImGui), "BeginMenu", new Type[1] { typeof(string) }, (Type[])null)))
					.Insert(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ImGui), "EndMainMenuBar", (Type[])null, (Type[])null)))
					.InsertBranchAndAdvance(OpCodes.Brfalse, smartCodeMatcher.Pos)
					.InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModInfoAsset), "DisplayImGuiControls", (Type[])null, (Type[])null)))
					.InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ImGui), "EndMenu", (Type[])null, (Type[])null)))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(AudioManager), "Update")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> AudioDebugMenuTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ImGui), "End", (Type[])null, (Type[])null), (string)null)).InsertAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ModAudioManager), "DrawImGUIDebug", (Type[])null, (Type[])null))).InstructionEnumeration();
			}
		}

		private static class R2ModManPatches
		{
			[HarmonyPatch(typeof(Locale), "GetTapeSubtitle", new Type[]
			{
				typeof(string),
				typeof(LocaleID)
			})]
			[HarmonyPostfix]
			public static void PatchLocaleSubtitles(string tape_id, LocaleID locale_id, ref TapeSubtitles __result)
			{
				ModTapeManager.TryReplaceSubtitles(tape_id, ref __result);
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "Awake")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> R2MMCoreTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ReceiverCoreScript), "LoadPersistentData", (Type[])null, (Type[])null), (string)null)).Insert(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Receiver2ModdingKit.Thunderstore.Thunderstore), "InstallGuns", (Type[])null, (Type[])null))).InstructionEnumeration();
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "Awake")]
			[HarmonyPostfix]
			private static void InstallGameModesSmile()
			{
				Receiver2ModdingKit.Thunderstore.Thunderstore.InstallGameModes();
			}

			[HarmonyPatch(typeof(TapeManager), "OnEnable")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> R2MMTapesTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(TapeManager), "tape_prefabs_all"), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(List<GameObject>), "get_Count", (Type[])null, (Type[])null), (string)null)).InsertAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null)).Insert(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Receiver2ModdingKit.Thunderstore.Thunderstore), "InstallTapes", (Type[])null, (Type[])null)))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(ModulePrefabsList), "OnEnable")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> R2MMTilesTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Expected O, but got Unknown
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions).MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldlen, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Conv_I4, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Blt, (object)null, (string)null)).Advance(2).InsertAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null))
					.Insert(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Receiver2ModdingKit.Thunderstore.Thunderstore), "InstallTiles", (Type[])null, (Type[])null)))
					.InstructionEnumeration();
			}
		}

		internal static class GetConsoleColorPatch
		{
			internal static ConsoleColor consoleColor;

			[HarmonyPatch(typeof(LogLevelExtensions), "GetConsoleColor")]
			[HarmonyPostfix]
			internal static void ChangeGetColorResult(ref ConsoleColor __result)
			{
				__result = consoleColor;
			}
		}

		internal static class LogEventArgsToStringPatch
		{
			internal static string levelName;

			[HarmonyPatch(typeof(LogEventArgs), "ToString")]
			[HarmonyPostfix]
			internal static void ChangeLogEventArgsLevel(LogEventArgs __instance, ref string __result)
			{
				__result = $"[{levelName,-7}:{__instance.Source.SourceName,10}] {__instance.Data}";
			}
		}

		private static void DisplayInstructions(CodeMatcher code_matcher, int breadth)
		{
			DisplayInstructions(code_matcher, breadth, (Action<string>)Debug.LogError);
		}

		private static void DisplayInstructions(CodeMatcher code_matcher, int breadth, Action<string> logger)
		{
			int num = Mathf.Max(code_matcher.Pos - breadth, 0);
			int num2 = Mathf.Min(code_matcher.Pos + breadth + 1, code_matcher.Length - 1);
			for (int i = num; i < code_matcher.Pos; i++)
			{
				logger(((object)code_matcher.InstructionAt(i - code_matcher.Pos)).ToString());
			}
			logger(string.Concat(code_matcher.Instruction, " <"));
			for (int j = code_matcher.Pos + 1; j < num2; j++)
			{
				logger(((object)code_matcher.InstructionAt(j - code_matcher.Pos)).ToString());
			}
		}

		[HarmonyPatch(typeof(TapesMenuScript), "Awake")]
		[HarmonyPrefix]
		private static void AddMissingTapeEntryCategory(Dictionary<TapeGroupID, MenuEntryCategories> ___menuCategoryMappings)
		{
			___menuCategoryMappings.Add((TapeGroupID)7, (MenuEntryCategories)60);
		}

		[HarmonyPatch(typeof(ReceiverCoreScript), "LoadModGun")]
		[HarmonyPrefix]
		private static void CheckFolderForSigmaBundles(string directoryName)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			string[] files = Directory.GetFiles(directoryName);
			foreach (string text in files)
			{
				if (!(Path.GetExtension(text) == ".sigma"))
				{
					continue;
				}
				IArchive val = ArchiveFactory.Open(text, (ReaderOptions)null);
				try
				{
					foreach (IArchiveEntry entry in val.Entries)
					{
						if (!Path.GetExtension(((IEntry)entry).Key).Contains(((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower()))
						{
							continue;
						}
						using Stream stream = entry.OpenEntryStream();
						byte[] array = new byte[((IEntry)entry).Size];
						stream.Read(array, 0, (int)((IEntry)entry).Size);
						using FileStream fileStream = File.Create(Path.Combine(directoryName, ((IEntry)entry).Key));
						fileStream.Write(array, 0, array.Length);
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
				File.Delete(text);
			}
		}

		[HarmonyPatch(typeof(GunScript), "CanHolster")]
		[HarmonyPrefix]
		private static bool PatchGunHolster(GunScript __instance, ref bool __result)
		{
			if (__instance is ModGunScript modGunScript)
			{
				__result = modGunScript.CanHolster();
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(MenuManagerScript), "Update")]
		[HarmonyPostfix]
		private static void ForceCursorState()
		{
			if (Extensions.unlock_cursor)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)(Extensions.confine_cursor ? 2 : 0);
			}
		}

		[HarmonyPatch(typeof(MagazineScript), "UpdateRoundPositions")]
		[HarmonyPostfix]
		private static void PatchMagazineRoundPositions(ref MagazineScript __instance)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			if (__instance is DoubleStackMagazine)
			{
				for (int i = 0; i < __instance.NumRounds(); i++)
				{
					ShellCasingScript val = __instance.rounds[i];
					bool flag = i % 2 == 0 == (__instance.rounds.Count % 2 == 0) != __instance.round_position_params.mirror_double_stack;
					((Component)val).transform.localPosition = new Vector3((Vector3.right * ((Component)val).GetComponent<BoxCollider>().size.x * __instance.round_position_params.param_e * (float)((!flag) ? 1 : (-1))).x, ((Component)val).transform.localPosition.y, ((Component)val).transform.localPosition.z);
				}
				if (__instance.extracting)
				{
					ShellCasingScript val2 = __instance.rounds[0];
					float num = Mathf.InverseLerp(Vector3.Dot(((Component)((InventoryItem)__instance).slot).transform.Find("barrel/point_round_entering").position, ((Component)__instance).transform.forward), Vector3.Dot(__instance.round_top.position, ((Component)__instance).transform.forward), Vector3.Dot(((Component)((InventoryItem)__instance).slot).transform.Find("slide/point_chambered_round").position, ((Component)__instance).transform.forward));
					bool flag2 = __instance.rounds.Count % 2 == 0 != __instance.round_position_params.mirror_double_stack;
					((Component)val2).transform.localPosition = new Vector3((((Component)val2).transform.right * ((Component)val2).GetComponent<BoxCollider>().size.x * __instance.round_position_params.param_e * (float)((!flag2) ? 1 : (-1))).x * num, ((Component)val2).transform.localPosition.y, ((Component)val2).transform.localPosition.z);
				}
			}
		}

		[HarmonyPatch(typeof(MagazineScript), "Awake")]
		[HarmonyPostfix]
		private static void UpdateSpringOnAwake(MagazineScript __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.spring))
			{
				__instance.spring.UpdateScale();
			}
		}

		[HarmonyPatch(typeof(TapesMenuScript), "OnLoad")]
		[HarmonyPrefix]
		private static void PatchTapeMenuLoad()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)ReceiverCoreScript.Instance().game_mode.GetGameMode() == 3)
			{
				ModTapeManager.PrepareTapesForCompound();
			}
			else
			{
				ModTapeManager.PrepareTapesForGame();
			}
		}

		[HarmonyPatch(typeof(TapesMenuScript), "CreateMenuEntries")]
		[HarmonyPrefix]
		private static void PrePatchTapeCreateMenuEntries(ref TapesMenuScript __instance)
		{
			ModTapeManager.Init();
			GameObject ecsPrefab = Object.Instantiate<GameObject>(GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Tape Menu/Entries Layout/ScrollableContent Variant/Viewport/Content/Standard/Invalid"));
			__instance.ecsPrefab = ecsPrefab;
		}

		[HarmonyPatch(typeof(TapesMenuScript), "CreateMenuEntries")]
		[HarmonyPostfix]
		private static void PostPatchTapeCreateMenuEntries(TapesMenuScript __instance)
		{
			ModTapeManager.CreateModTapes(__instance);
		}

		[HarmonyPatch(typeof(CartridgeSpec), "SetFromPreset")]
		[HarmonyPrefix]
		private static bool PatchSetCartridge(Preset preset, ref CartridgeSpec __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (ModShellCasingScript.mod_cartridges.ContainsKey(preset))
			{
				__instance = ModShellCasingScript.mod_cartridges[preset];
				return false;
			}
			return true;
		}

		public static void PrintMethodIL(Type type, string name, bool original = false)
		{
			PrintMethodIL(AccessTools.Method(type, name, (Type[])null, (Type[])null), original);
		}

		public static void PrintMethodIL(MethodInfo method, bool original = false)
		{
			List<CodeInstruction> list = (original ? PatchProcessor.GetOriginalInstructions((MethodBase)method, (ILGenerator)null) : PatchProcessor.GetCurrentInstructions((MethodBase)method, int.MaxValue, (ILGenerator)null));
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				Debug.Log((object)list[i]);
			}
		}

		[HarmonyPatch(typeof(ReceiverCoreScript), "Awake")]
		[HarmonyPostfix]
		private static void PatchCoreAwake(List<GameObject> ___gun_prefabs_all)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			foreach (GameObject item in ___gun_prefabs_all)
			{
				ModGunScript component = item.GetComponent<ModGunScript>();
				if ((Object)(object)component != (Object)null)
				{
					try
					{
						ModLoader.LoadGun(component);
					}
					catch (Exception ex)
					{
						Debug.LogError((object)("Error happened when loading gun " + ((InventoryItem)component).InternalName));
						Debug.LogError((object)ex);
					}
				}
			}
			ModLoader.Finish();
			ReceiverCoreScript.Instance().player_prefab.GetComponent<PlayerScript>().main_camera_prefab.GetComponent<Camera>().nearClipPlane = 0.02f;
			string[] files = Directory.GetFiles(Path.Combine(Application.persistentDataPath, "Tapes"), "*.srt", SearchOption.AllDirectories);
			for (int i = 0; i < files.Length; i++)
			{
				FileInfo fileInfo = new FileInfo(files[i]);
				ModTapeManager.RegisterSubtitles(fileInfo.Name.Replace(".srt", ""), fileInfo);
			}
			try
			{
				ModdingKitConfig.Initialize();
			}
			catch
			{
				Debug.LogError((object)"An error accured when trying to create settings for the Modding Kit");
			}
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				BankList[] array = allLoadedAssetBundle.LoadAllAssets<BankList>();
				if (array != null)
				{
					ModAudioManager.LoadBanksFromLists(array);
				}
			}
			foreach (TapeContent modTape in ReceiverCoreScript.Instance().tape_loadout_asset.GetModTapes())
			{
				LocaleTapeMenuEntry val = new LocaleTapeMenuEntry();
				val.name = "Invalid";
				val.id_string = modTape.tape_id_string;
				val.title = modTape.title;
				val.description = modTape.text;
				Locale.active_locale_tape_menu_entries_string.Add(modTape.tape_id_string, val);
			}
			Delegate[] invocationList = ModdingKitEvents.ExecuteOnStartup.GetInvocationList();
			foreach (Delegate obj2 in invocationList)
			{
				try
				{
					obj2.DynamicInvoke();
				}
				catch (Exception ex2)
				{
					Debug.LogError((object)("Failed invoking startup event for method " + obj2.Method.Name + ";\nDumping stack trace:"));
					Debug.LogError((object)ex2);
				}
			}
		}

		[HarmonyPatch(typeof(ShellCasingScript), "CollisionSound")]
		[HarmonyPrefix]
		private static bool PatchCollisionSound(BallisticMaterial material, ref ShellCasingScript __instance)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected I4, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if (((InventoryItem)__instance).physics_collided || !(__instance is ModShellCasingScript))
			{
				return true;
			}
			ModShellCasingScript modShellCasingScript = (ModShellCasingScript)(object)__instance;
			((InventoryItem)modShellCasingScript).physics_collided = true;
			if (!((ShellCasingScript)modShellCasingScript).IsSpent())
			{
				AudioManager.PlayOneShot3D(modShellCasingScript.sound_bullet_fall_hard, ((Component)modShellCasingScript).transform.position, 1f, 1f);
				return false;
			}
			MaterialLabel material_label = material.material_label;
			switch (material_label - 1)
			{
			case 0:
			case 1:
			case 2:
			case 4:
			case 5:
			case 7:
			case 13:
			case 14:
			case 18:
				AudioManager.PlayOneShot3D(modShellCasingScript.sound_shell_casing_impact_hard, ((Component)modShellCasingScript).transform.position, 1f, 1f);
				break;
			case 3:
			case 6:
			case 8:
			case 9:
			case 10:
			case 11:
			case 12:
				AudioManager.PlayOneShot3D(modShellCasingScript.sound_shell_casing_impact_soft, ((Component)modShellCasingScript).transform.position, 1f, 1f);
				break;
			}
			return false;
		}

		[HarmonyPatch(typeof(MagazineScript), "Awake")]
		[HarmonyPrefix]
		private static void PatchMagazineAwake(MagazineScript __instance)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			SpringCompressInstance[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<SpringCompressInstance>();
			foreach (SpringCompressInstance val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogError((object)("Null spring in magazine \"" + ((InventoryItem)__instance).InternalName + "\""));
				}
				else if (!(((Vector3)(ref val.orig_center)).magnitude > 0f))
				{
					val.orig_center = (((Component)val).transform.InverseTransformPoint(val.new_top.position) + ((Component)val).transform.InverseTransformPoint(val.new_bottom.position)) / 2f;
					val.orig_dist = Vector3.Distance(val.new_top.position, val.new_bottom.position);
				}
			}
		}

		[HarmonyPatch(typeof(RuntimeTileLevelGenerator), "SpawnMagazine")]
		[HarmonyPostfix]
		private static void PatchSpawnMagazine(ref ActiveItem __result)
		{
			if (!ModdingKitEvents.ItemSpawnHandlers.ContainsKey(ReceiverCoreScript.Instance().CurrentLoadout.gun_internal_name))
			{
				return;
			}
			foreach (ModdingKitEvents.OnItemSpawn item in ModdingKitEvents.ItemSpawnHandlers[ReceiverCoreScript.Instance().CurrentLoadout.gun_internal_name])
			{
				try
				{
					if (item(ref __result))
					{
						break;
					}
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("Failed invoking item spawn event method " + item.Method.Name + " for gun " + ReceiverCoreScript.Instance().CurrentLoadout.gun_internal_name + ";\nDumping stack trace:"));
					Debug.LogError((object)ex);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerLoadout), "Deserialize")]
		[HarmonyPrefix]
		private static void PatchDeserializeLoadout(JSONNode jn_root)
		{
			if (jn_root.HasKey("gun_persistent_data"))
			{
				Extensions.current_gun_data = jn_root["gun_persistent_data"].AsObject;
			}
		}

		[HarmonyPatch(typeof(PlayerLoadout), "Serialize")]
		[HarmonyPostfix]
		private static void PatchSerializeLoadout(ref JSONObject __result)
		{
			GunScript val = default(GunScript);
			if ((Object)(object)LocalAimHandler.player_instance != (Object)null && LocalAimHandler.player_instance.TryGetGun(ref val) && val is ModGunScript)
			{
				((JSONNode)__result)["gun_persistent_data"] = (JSONNode)(object)(val as ModGunScript).EncodeJSON((JSONNode)(object)((StorableMonoBehaviour)val).GetPersistentData());
			}
		}

		[HarmonyPatch(typeof(PlayerLoadout), "Reserialize")]
		[HarmonyPostfix]
		private static void PatchReserializeLoadout()
		{
			Extensions.current_gun_data = null;
		}

		[HarmonyPatch(typeof(ReceiverCoreScript), "SpawnGun")]
		[HarmonyPostfix]
		private static void PatchSpawnGun(ref GunScript __result)
		{
			if (!((Object)(object)__result == (Object)null) && __result is ModGunScript && (__result as ModGunScript).OwnData((JSONNode)(object)Extensions.current_gun_data))
			{
				((StorableMonoBehaviour)__result).SetPersistentData((__result as ModGunScript).DecodeJSON((JSONNode)(object)Extensions.current_gun_data));
			}
		}

		[HarmonyPatch(typeof(SettingsMenuScript), "OnKeybindsClick")]
		[HarmonyPostfix]
		private static void PatchOpenKeybinds()
		{
			GunScript val = default(GunScript);
			if (!((Object)(object)LocalAimHandler.player_instance == (Object)null) && LocalAimHandler.player_instance.TryGetGun(ref val))
			{
				KeybindsManager.SetKeybindsActive(val.weapon_group_name);
			}
		}

		[HarmonyPatch(typeof(RankingProgressionGameMode), "EvaluateNextLoadout")]
		[HarmonyPrefix]
		private static void PatchEvaluateLoadout(ref HashSet<string> ___campaign_loadouts)
		{
			string[] loadout_names = ReceiverCoreScript.Instance().weapon_loadout_asset.GetAllLoadoutNames();
			___campaign_loadouts.RemoveWhere((string loadout_name) => !loadout_names.Contains(loadout_name));
		}

		[HarmonyPatch(typeof(ReceiverCoreScript), "GetWorldGenerationConfigurationFromName")]
		[HarmonyPostfix]
		private static void PatchGetWCG(ref WorldGenerationConfiguration __result)
		{
			if (__result != null)
			{
				string[] loadout_names = ReceiverCoreScript.Instance().weapon_loadout_asset.GetAllLoadoutNames();
				__result.loadouts.RemoveAll(delegate(LoadoutValue loadout)
				{
					string name = loadout.name;
					return !loadout_names.Contains(name);
				});
			}
		}

		[HarmonyPatch(typeof(RankingProgressionCampaign), "LoadFile")]
		[HarmonyPostfix]
		private static void PatchLoadCampaign(string filename)
		{
			JSONNode val = ReceiverCoreScript.LoadJSONFile(filename);
			if (val.HasKey("use_modded_guns") && val["use_modded_guns"].AsBool && !ModdedGunsCampaignManager.modded_guns_campaigns.Contains(filename))
			{
				ModdedGunsCampaignManager.modded_guns_campaigns.Add(filename);
			}
		}

		[HarmonyPatch(typeof(WorldGenerationConfiguration), "Deserialize")]
		[HarmonyPostfix]
		private static void PatchLoadWCG(ref WorldGenerationConfiguration __result)
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			GameModeBase game_mode = ReceiverCoreScript.Instance().game_mode;
			if (!((Object)(object)game_mode != (Object)null) || !(game_mode is RankingProgressionGameMode))
			{
				return;
			}
			string item = AccessTools.Field(typeof(RankingProgressionGameMode), "campaign_path").GetValue(game_mode) as string;
			if (!ModdedGunsCampaignManager.modded_guns_campaigns.Contains(item))
			{
				return;
			}
			string[] loadout_names = ReceiverCoreScript.Instance().weapon_loadout_asset.GetAllLoadoutNames();
			__result.loadouts.RemoveAll((LoadoutValue loadout) => !loadout_names.Contains(loadout.name));
			string[] array = loadout_names;
			foreach (string loadout_name in array)
			{
				if (!ReceiverCoreScript.Instance().weapon_loadout_asset.GetLoadoutPrefab(loadout_name).gun_internal_name.StartsWith("wolfire") && !__result.loadouts.Any((LoadoutValue loadout_value) => loadout_value.name == loadout_name))
				{
					__result.loadouts.Add(new LoadoutValue
					{
						name = loadout_name
					});
				}
			}
		}

		[HarmonyPatch(typeof(LocalAimHandler), "StepRecoil")]
		[HarmonyPostfix]
		private static void PatchStepRecoil()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Hand[] hands = LocalAimHandler.player_instance.hands;
			foreach (Hand val in hands)
			{
				if ((int)val.state == 1)
				{
					ModGunScript modGunScript = val.slot.contents[0] as ModGunScript;
					if ((Object)(object)modGunScript != (Object)null)
					{
						Vector3 value = val.recoil_events.Last();
						Vector2 stepRecoilMultiplier = modGunScript.GetStepRecoilMultiplier();
						value.x *= stepRecoilMultiplier.x;
						value.y *= stepRecoilMultiplier.y;
						val.recoil_events[val.recoil_events.Count - 1] = value;
					}
				}
			}
		}

		[HarmonyPatch(typeof(LocalAimHandler), "UpdateLooseBulletDisplay")]
		[HarmonyPrefix]
		private static void ShowBulletInventoryIfCanInsertRoundInChamber(LocalAimHandler __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			int handWithState = __instance.GetHandWithState((State)1);
			if (handWithState != -1)
			{
				GunScript val = (GunScript)__instance.hands[handWithState].slot.contents[0];
				if (__instance.GetHandWithState((State)2) == -1 && (val.IsSlideLockedOpen() || (val.SlideLockIsSafety() && val.IsSafetyOn() && !val.IsThereAChamberedRound() && !val.IsThereAMagInGun() && ((SimpleMover)val.slide).amount > 0.2f)))
				{
					Extensions.lah_force_bullet_display = true;
					return;
				}
			}
			Extensions.lah_force_bullet_display = false;
		}

		[HarmonyPatch(typeof(LocalAimHandler), "HandleGunControls")]
		[HarmonyPostfix]
		private static void PatchHandleSprings()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			LocalAimHandler obj = default(LocalAimHandler);
			if (LocalAimHandler.TryGetInstance(ref obj))
			{
				while (Extensions.pose_spring_overrides.Count > 0)
				{
					Tuple<PoseSpring, float> tuple = Extensions.pose_spring_overrides.Dequeue();
					((Spring)ReflectionManager.LAH_pose_springs[tuple.Item1].GetValue(obj)).target_state = tuple.Item2;
				}
			}
		}

		[HarmonyPatch(typeof(GunScript), "FireBullet")]
		[HarmonyPrefix]
		private static bool PatchFireEmptyShell(ShellCasingScript round)
		{
			if ((Object)(object)round == (Object)null || round.IsSpent())
			{
				return false;
			}
			return true;
		}

		internal static void UnpatchAll()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			FieldInfo[] fields = typeof(HarmonyInstances).GetFields();
			for (int i = 0; i < fields.Length; i++)
			{
				Harmony val = (Harmony)fields[i].GetValue(null);
				if (val != null)
				{
					val.UnpatchSelf();
				}
			}
		}

		private static IEnumerator FixLegacySounds()
		{
			yield return null;
			foreach (MethodBase patchedMethod in HarmonyInstances.CustomSounds.GetPatchedMethods())
			{
				Patches patchInfo = Harmony.GetPatchInfo(patchedMethod);
				if (patchInfo.Owners.Count != 1)
				{
					HarmonyInstances.CustomSounds.Unpatch(patchedMethod, (HarmonyPatchType)1, patchInfo.Owners.First((string ownerID) => ownerID != HarmonyInstances.CustomSounds.Id));
					continue;
				}
				break;
			}
		}

		private static IEnumerator WaitForModel10ToSpawn()
		{
			GunScript[] array = Object.FindObjectsOfType<GunScript>();
			for (int i = 0; i < array.Length; i++)
			{
				if ((int)array[i].gun_model == 2)
				{
					Object.Instantiate<GunScript>(ReceiverCoreScript.Instance().GetGunPrefab(ReceiverCoreScript.Instance().CurrentLoadout.gun_internal_name), ((Component)array[i]).transform.position, ((Component)array[i]).transform.rotation);
					((Component)array[i]).gameObject.SetActive(false);
					break;
				}
			}
			yield break;
		}

		internal static void Initialize()
		{
			HarmonyInstances.Core = Harmony.CreateAndPatchAll(typeof(HarmonyManager), (string)null);
			HarmonyInstances.Transpilers = Harmony.CreateAndPatchAll(typeof(Transpilers), (string)null);
			HarmonyInstances.ModHelpEntry = Harmony.CreateAndPatchAll(typeof(ModHelpEntryManager), (string)null);
			HarmonyInstances.CustomSounds = Harmony.CreateAndPatchAll(typeof(ModAudioPatches), (string)null);
			HarmonyInstances.ModGameMode = Harmony.CreateAndPatchAll(typeof(ModGameModeManager), (string)null);
			HarmonyInstances.CustomRoundTypes = Harmony.CreateAndPatchAll(typeof(CustomRoundTypes.Patches), (string)null);
			HarmonyInstances.ModPersistentData = Harmony.CreateAndPatchAll(typeof(ModPersistentData), (string)null);
			Harmony.CreateAndPatchAll(typeof(FMODLookForTapeFilterBytes), (string)null);
			if (Receiver2ModdingKit.Thunderstore.Thunderstore.LaunchedWithR2ModMan)
			{
				HarmonyInstances.Thunderstore = Harmony.CreateAndPatchAll(typeof(R2ModManPatches), (string)null);
			}
			((MonoBehaviour)ModdingKitCorePlugin.instance).StartCoroutine(FixLegacySounds());
		}
	}
	public class Keybind
	{
		public interface KeyMapping
		{
			int GetKey();

			bool IsRedirect();
		}

		public class KeyboardKey : KeyMapping
		{
			private KeyCode key;

			public KeyboardKey(KeyCode key)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				this.key = key;
			}

			public int GetKey()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected I4, but got Unknown
				return (int)key;
			}

			public bool IsRedirect()
			{
				return false;
			}
		}

		public class KeyRedirect : KeyMapping
		{
			private int action_id;

			public KeyRedirect(int action_id)
			{
				this.action_id = action_id;
			}

			public int GetKey()
			{
				return action_id;
			}

			public bool IsRedirect()
			{
				return true;
			}
		}

		public string name;

		public string gun_name = "";

		public KeyMapping key;

		public int fallback_action_id;

		public Keybind(string keybind_menu_name, int fallback_action_id, KeyMapping default_value = null)
		{
			name = keybind_menu_name;
			this.fallback_action_id = fallback_action_id;
			key = default_value;
		}

		public string GetLongName()
		{
			return gun_name + "::" + name;
		}
	}
	public class KeybindContainer
	{
		public string gun_name;

		public GameObject category_object;

		public ModKeybindComponent[] keybind_components;

		public bool active { get; private set; }

		public void SetActive(bool active)
		{
			this.active = active;
			category_object.SetActive(active);
			ModKeybindComponent[] array = keybind_components;
			for (int i = 0; i < array.Length; i++)
			{
				((Component)array[i]).gameObject.SetActive(active);
			}
		}
	}
	internal static class KeybindsManager
	{
		internal static GameObject keybinds_menu_banner = null;

		internal static GameObject keybinds_menu_space = null;

		internal static List<KeybindContainer> custom_keybinds = new List<KeybindContainer>();

		private static Dictionary<string, int> m_rewired_actions = null;

		internal static Dictionary<string, int> rewired_actions
		{
			get
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Invalid comparison between Unknown and I4
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				if (m_rewired_actions == null)
				{
					m_rewired_actions = new Dictionary<string, int> { { "None", -1 } };
					FieldInfo[] fields = typeof(Action).GetFields(BindingFlags.Static | BindingFlags.Public);
					for (int i = 0; i < fields.Length; i++)
					{
						int num = (int)fields[i].GetValue(null);
						LocaleUIString val = ControllerBindingScript.RewiredActionToButtonLabel(num, (Pole)0);
						if ((int)val != 151)
						{
							m_rewired_actions.Add(Locale.GetUIString(val), num);
						}
					}
				}
				return m_rewired_actions;
			}
		}

		public static bool IsKeybindRegistered(string weapon_group_name)
		{
			return custom_keybinds.Any((KeybindContainer keybind) => keybind.gun_name == weapon_group_name);
		}

		public static KeybindContainer GetKeybinds(string weapon_group_name)
		{
			return custom_keybinds.First((KeybindContainer keybind) => keybind.gun_name == weapon_group_name);
		}

		public static bool TryGetKeybinds(string weapon_group_name, out KeybindContainer keybind_container)
		{
			foreach (KeybindContainer custom_keybind in custom_keybinds)
			{
				if (custom_keybind.gun_name == weapon_group_name)
				{
					keybind_container = custom_keybind;
					return true;
				}
			}
			keybind_container = null;
			return false;
		}

		public static void DeactivateAllKeybinds()
		{
			if ((Object)(object)keybinds_menu_banner != (Object)null)
			{
				keybinds_menu_banner.SetActive(false);
			}
			if ((Object)(object)keybinds_menu_space != (Object)null)
			{
				keybinds_menu_space.SetActive(false);
			}
			foreach (KeybindContainer custom_keybind in custom_keybinds)
			{
				custom_keybind.SetActive(active: false);
			}
		}

		public static void SetKeybindsActive(string weapon_group_name)
		{
			bool active = false;
			foreach (KeybindContainer custom_keybind in custom_keybinds)
			{
				if (custom_keybind.gun_name == weapon_group_name)
				{
					custom_keybind.SetActive(active: true);
					active = true;
				}
				else
				{
					custom_keybind.SetActive(active: false);
				}
			}
			if ((Object)(object)keybinds_menu_banner != (Object)null)
			{
				keybinds_menu_banner.SetActive(active);
			}
			if ((Object)(object)keybinds_menu_space != (Object)null)
			{
				keybinds_menu_space.SetActive(active);
			}
		}
	}
	public class ModKeybindComponent : MonoBehaviour
	{
		public Keybind keybind;

		public Button keyboard_binding;

		public TextMeshProUGUI keyboard_binding_text;

		public DropdownComponent redirect_binding;

		public Button clear_button;

		private IEnumerator PickKeyCoroutine()
		{
			SettingsMenuManager.ShowKeyBindDialog(((Object)this).name);
			while (!Input.GetKeyDown((KeyCode)27))
			{
				foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
				{
					if (Input.GetKeyDown(value))
					{
						redirect_binding.Select(0);
						keybind.key = new Keybind.KeyboardKey(value);
						((TMP_Text)keyboard_binding_text).text = ((object)value/*cast due to .constrained prefix*/).ToString();
						SettingsMenuManager.HideKeyBindDialog();
						ModdingKitConfig.UpdateKeybindValue(keybind);
						yield break;
					}
				}
				yield return null;
			}
			SettingsMenuManager.HideKeyBindDialog();
		}

		public void Awake()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			if (keybind.key.IsRedirect())
			{
				for (int i = 0; i < redirect_binding.dropdown.options.Count; i++)
				{
					string text = redirect_binding.dropdown.options[i].text;
					if (KeybindsManager.rewired_actions[text] == keybind.key.GetKey())
					{
						string key = KeybindsManager.rewired_actions.Keys.ElementAt(i);
						keybind.key = new Keybind.KeyRedirect(KeybindsManager.rewired_actions[key]);
						((TMP_Text)keyboard_binding_text).text = "";
						break;
					}
				}
			}
			else
			{
				((TMP_Text)keyboard_binding_text).text = ((object)(KeyCode)keybind.key.GetKey()/*cast due to .constrained prefix*/).ToString();
			}
			((UnityEvent)keyboard_binding.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)ModdingKitCorePlugin.instance).StartCoroutine(PickKeyCoroutine());
			});
			((UnityEvent<int>)(object)redirect_binding.OnChange).AddListener((UnityAction<int>)delegate(int index)
			{
				string key2 = KeybindsManager.rewired_actions.Keys.ElementAt(index);
				keybind.key = new Keybind.KeyRedirect(KeybindsManager.rewired_actions[key2]);
				((TMP_Text)keyboard_binding_text).text = "";
				ModdingKitConfig.UpdateKeybindValue(keybind);
			});
			((UnityEvent)clear_button.onClick).AddListener((UnityAction)delegate
			{
				((TMP_Text)keyboard_binding_text).text = "";
				redirect_binding.Select(0);
				keybind.key = new Keybind.KeyRedirect(-1);
				ModdingKitConfig.UpdateKeybindValue(keybind);
			});
		}
	}
	public class Metadata<T> : Component
	{
		public string Name { get; private set; }

		public T Value { get; private set; }

		public void Set(T value)
		{
			Set(Name, value);
		}

		public void Set(string name, T value)
		{
			Name = name;
			Value = value;
		}
	}
	public static class MetadataExtensions
	{
		public static Metadata<T> AddMeta<T>(this GameObject gobj, string name, T value)
		{
			Metadata<T>[] components = gobj.GetComponents<Metadata<T>>();
			foreach (Metadata<T> metadata in components)
			{
				if (metadata.Name == name)
				{
					metadata.Set(value);
					return metadata;
				}
			}
			Metadata<T> metadata2 = gobj.AddComponent<Metadata<T>>();
			metadata2.Set(name, value);
			return metadata2;
		}

		public static Metadata<T> SetMeta<T>(this GameObject gobj, string name, T value)
		{
			Metadata<T>[] components = gobj.GetComponents<Metadata<T>>();
			foreach (Metadata<T> metadata in components)
			{
				if (metadata.Name == name)
				{
					metadata.Set(value);
					return metadata;
				}
			}
			return gobj.AddMeta(name, value);
		}

		public static Metadata<T> SetMeta<T>(this Component comp, string name, T value)
		{
			Metadata<T>[] components = comp.GetComponents<Metadata<T>>();
			foreach (Metadata<T> metadata in components)
			{
				if (metadata.Name == name)
				{
					metadata.Set(value);
					return metadata;
				}
			}
			return comp.gameObject.AddMeta(name, value);
		}

		public static T GetMeta<T>(this GameObject gobj, string name)
		{
			Metadata<T>[] components = gobj.GetComponents<Metadata<T>>();
			foreach (Metadata<T> metadata in components)
			{
				if (metadata.Name == name)
				{
					return metadata.Value;
				}
			}
			return default(T);
		}

		public static T GetMeta<T>(this Component comp, string name)
		{
			Metadata<T>[] components = comp.GetComponents<Metadata<T>>();
			foreach (Metadata<T> metadata in components)
			{
				if (metadata.Name == name)
				{
					return metadata.Value;
				}
			}
			return default(T);
		}
	}
	[RequireComponent(typeof(InventorySlot), typeof(LevelItem))]
	public abstract class ModGunScript : GunScript, ISerializationCallbackReceiver
	{
		[Serializable]
		public class ModLocaleTactics
		{
			public string title;

			[TextArea]
			public string description;

			public LocaleTactics GetLocaleTactics(GunScript gun)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				return new LocaleTactics
				{
					gun_internal_name = gun.weapon_group_name,
					title = (Utility.IsNullOrWhiteSpace(title) ? ((InventoryItem)gun).InternalName : title),
					text = description
				};
			}
		}

		[Tooltip("All objects in the prefab should have the same activation status, most desirably they should be deactivated")]
		public GameObject muzzle_flash_prefab;

		public bool visible_in_spawnmenu = true;

		public bool spawns_in_dreaming = true;

		public float magazine_shake_strength_multiplier = 1f;

		public float slide_return_time = 0.04f;

		public ModHelpEntry help_entry;

		public ModLocaleTactics locale_tactics;

		[SerializeField]
		[HideInInspector]
		private bool help_entry_generate;

		[SerializeField]
		[HideInInspector]
		private string help_entry_name;

		[SerializeField]
		[HideInInspector]
		private Sprite help_entry_info_sprite;

		[SerializeField]
		[HideInInspector]
		private string help_entry_title;

		[SerializeField]
		[HideInInspector]
		private string help_entry_description;

		[SerializeField]
		[HideInInspector]
		private string locale_tactics_title;

		[SerializeField]
		[HideInInspector]
		private string locale_tactics_description;

		[Tooltip("List of custom audio events used by the gun, created via RMB -> Create -> Receiver 2 Modding -> Custom Sounds List")]
		public CustomSoundsList audio;

		protected bool _disconnector_needs_reset
		{
			get
			{
				return ReflectionManager.GS_disconnector_needs_reset.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_disconnector_needs_reset.Invoke((GunScript)(object)this) = value;
			}
		}

		protected float _hammer_halfcocked
		{
			get
			{
				return ReflectionManager.GS_hammer_halfcocked.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_hammer_halfcocked.Invoke((GunScript)(object)this) = value;
			}
		}

		protected float _hammer_cocked_val
		{
			get
			{
				return ReflectionManager.GS_hammer_cocked_val.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_hammer_cocked_val.Invoke((GunScript)(object)this) = value;
			}
		}

		protected int _hammer_state
		{
			get
			{
				return ReflectionManager.GS_hammer_state.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_hammer_state.Invoke((GunScript)(object)this) = value;
			}
		}

		protected bool _slide_stop_locked
		{
			get
			{
				return ReflectionManager.GS_slide_stop_locked.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_slide_stop_locked.Invoke((GunScript)(object)this) = value;
			}
		}

		protected LinearMover _select_fire
		{
			get
			{
				return ReflectionManager.GS_select_fire.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_select_fire.Invoke((GunScript)(object)this) = value;
			}
		}

		protected float _yoke_open
		{
			get
			{
				return ReflectionManager.GS_yoke_open.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_yoke_open.Invoke((GunScript)(object)this) = value;
			}
		}

		protected int _current_firing_mode_index
		{
			get
			{
				return ReflectionManager.GS_current_firing_mode_index.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_current_firing_mode_index.Invoke((GunScript)(object)this) = value;
			}
		}

		protected LinearMover _firing_pin
		{
			get
			{
				return ReflectionManager.GS_firing_pin.Invoke((GunScript)(object)this);
			}
			set
			{
				ReflectionManager.GS_firing_pin.Invoke((GunScript)(object)this) = value;
			}
		}

		public PlayerInput player_input { get; protected set; }

		public KeybindContainer keybinds { get; protected set; }

		internal static void UpdateModGun(GunScript gun)
		{
			if (gun is ModGunScript)
			{
				try
				{
					((ModGunScript)(object)gun).UpdateGun();
				}
				catch (Exception ex)
				{
					Debug.LogError((object)$"Catched exception during {((InventoryItem)gun).InternalName}'s UpdateGun");
					Debug.LogException(ex);
				}
			}
		}

		protected static float InterpCurve(in float[] curve, float time)
		{
			if (curve == null || curve.Length < 2)
			{
				Debug.LogError((object)"ModGunScript.InterpCurve(): curve parameter must contain at least 2 elements");
				return 0f;
			}
			if (time <= curve[0])
			{
				return curve[1];
			}
			if (time >= curve[curve.Length - 2])
			{
				return curve[curve.Length - 1];
			}
			for (int i = 0; i < curve.Length - 2; i += 2)
			{
				if (time <= curve[i + 2])
				{
					float num = Mathf.InverseLerp(curve[i], curve[i + 2], time);
					return Mathf.Lerp(curve[i + 1], curve[i + 3], num);
				}
			}
			return curve[1];
		}

		protected void TryFireBullet(float dry_fire_volume = 1f)
		{
			if (Object.op_Implicit((Object)(object)base.round_in_chamber) && !base.round_in_chamber.IsSpent() && ((SimpleMover)base.slide).amount == 0f)
			{
				((GunScript)this).FireBullet(base.round_in_chamber);
				return;
			}
			base.recoil_transfer_x -= Random.Range(15f, 30f);
			base.recoil_transfer_y += Random.Range(-20f, 20f);
			base.dry_fired = true;
			ReceiverEvents.TriggerEvent((ReceiverEventTypeInt)13, (!((Object)(object)base.round_in_chamber != (Object)null)) ? 1 : 2);
			AudioManager.PlayOneShotAttached(base.sound_dry_fire, ((Component)this).gameObject, dry_fire_volume);
		}

		protected void TryFireBullet(float dry_fire_volume, Action<ShellCasingScript> on_fire)
		{
			if (Object.op_Implicit((Object)(object)base.round_in_chamber) && !base.round_in_chamber.IsSpent() && ((SimpleMover)base.slide).amount == 0f)
			{
				on_fire(base.round_in_chamber);
				return;
			}
			base.recoil_transfer_x -= Random.Range(15f, 30f);
			base.recoil_transfer_y += Random.Range(-20f, 20f);
			base.dry_fired = true;
			ReceiverEvents.TriggerEvent((ReceiverEventTypeInt)13, (!((Object)(object)base.round_in_chamber != (Object)null)) ? 1 : 2);
			AudioManager.PlayOneShotAttached(base.sound_dry_fire, ((Component)this).gameObject, dry_fire_volume);
		}

		protected void UpdateAnimatedComponents()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			AnimatedMover[] animated_components = base.animated_components;
			foreach (AnimatedMover val in animated_components)
			{
				((GunScript)this).ApplyTransform(val.anim_path, val.mover.amount, val.component);
			}
		}

		protected void SetArmorPiercing(bool armor_piercing)
		{
			if (armor_piercing != base.armor_piercing)
			{
				base.armor_piercing = armor_piercing;
				TurretArmor[] array = Object.FindObjectsOfType<TurretArmor>();
				for (int i = 0; i < array.Length; i++)
				{
					((Component)array[i]).SendMessage("UpdateMaterial", (object)this);
				}
			}
		}

		protected void Awake()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			player_input = new PlayerInput((GunScript)(object)this);
			using (new TransformDebugScope())
			{
				try
				{
					((GunScript)this).Awake();
				}
				catch (NullReferenceException ex)
				{
					Debug.LogError((object)$"Catched exception during {((InventoryItem)this).InternalName}'s Awake");
					if (!string.IsNullOrEmpty(TransformDebugScope.last_target))
					{
						Debug.LogError((object)("You seem to be missing the " + TransformDebugScope.last_target + " transform."));
					}
					else
					{
						Debug.LogError((object)"Carefully check if you've assigned all the fields properly and if there aren't any missing references");
					}
					Debug.LogError((object)ex);
				}
			}
			UpdatedSpring[] update_springs = base.update_springs;
			foreach (UpdatedSpring val in update_springs)
			{
				if ((Object)(object)val.spring == (Object)null)
				{
					Debug.LogError((object)("Null spring in gun \"" + ((InventoryItem)this).InternalName + "\""));
					continue;
				}
				val.spring.orig_center = (((Component)val.spring).transform.InverseTransformPoint(val.spring.new_top.position) + ((Component)val.spring).transform.InverseTransformPoint(val.spring.new_bottom.position)) / 2f;
				val.spring.orig_dist = Vector3.Distance(val.spring.new_top.position, val.spring.new_bottom.position);
			}
			if ((Object)(object)audio != (Object)null)
			{
				audio.SetGun(this);
				ModdingKitConfig.AddConfigEventListener(delegate(object sender, SettingChangedEventArgs args)
				{
					if (args.ChangedSetting.Definition.Key == "Use Custom Sounds")
					{
						audio.SetSoundEvents();
					}
				});
				audio.SetSoundEvents();
			}
			GameObject object_prefab = muzzle_flash_prefab;
			bool flag = true;
			if ((Object)(object)object_prefab == (Object)null)
			{
				object_prefab = base.pooled_muzzle_flash.object_prefab;
			}
			if ((Object)(object)object_prefab != (Object)null && ObjectPool.pools != null)
			{
				ObjectPool val2 = ObjectPool.pools["MuzzleFlashPool"];
				Dictionary<string, int> dictionary = ReflectionManager.OP_pool_map.GetValue(val2) as Dictionary<string, int>;
				GameObject val3;
				if (dictionary.ContainsKey(((InventoryItem)this).InternalName + "_muzzle_flash"))
				{
					val3 = val2.pooled_prefab_parameters[dictionary[((InventoryItem)this).InternalName + "_muzzle_flash"]].pool_object;
				}
				else
				{
					val2.AddPrefab(object_prefab);
					val3 = new GameObject(((InventoryItem)this).InternalName + "_muzzle_flash");
					val3.transform.parent = ((Component)val2).transform;
					Object.Instantiate<GameObject>(object_prefab, val3.transform);
					int num = dictionary.Values.Max() + 1;
					if (num >= val2.pooled_prefab_parameters.Count)
					{
						Object.Destroy((Object)(object)val3);
						flag = false;
					}
					else
					{
						dictionary.Add(((Object)val3).name, num);
						val2.pooled_prefab_parameters[num].ClaimPool(val3);
					}
				}
				if (flag)
				{
					base.pooled_muzzle_flash.pool_prefab = ((Component)val2).gameObject;
					base.pooled_muzzle_flash.object_prefab = val3;
					base.pooled_muzzle_flash.object_prefab_name = ((Object)val3).name;
				}
			}
			try
			{
				AwakeGun();
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)$"Caught exception during {((InventoryItem)this).InternalName}'s AwakeGun");
				Debug.LogException(ex2);
			}
		}

		protected void Update()
		{
			using (new TransformDebugScope())
			{
				try
				{
					EarlyUpdateGun();
				}
				catch (Exception ex)
				{
					Debug.LogError((object)$"Caught exception during {((InventoryItem)this).InternalName}'s EarlyUpdateGun");
					Debug.LogException(ex);
				}
				try
				{
					((GunScript)this).Update();
				}
				catch (NullReferenceException ex2)
				{
					Debug.LogError((object)$"Caught exception during {((InventoryItem)this).InternalName}'s Update");
					if (!string.IsNullOrEmpty(TransformDebugScope.last_target))
					{
						Debug.LogError((object)("You seem to be missing the " + TransformDebugScope.last_target + " transform."));
					}
					else
					{
						Debug.LogError((object)"Carefully check if you've assigned all the fields properly and if there aren't any missing references");
					}
					Debug.LogException((Exception)ex2);
				}
				try
				{
					LateUpdateGun();
					UpdateAnimatedComponents();
					if (Object.op_Implicit((Object)(object)((SimpleMover)base.safety).transform))
					{
						((SimpleMover)base.safety).UpdateDisplay();
					}
				}
				catch (Exception ex3)
				{
					Debug.LogError((object)$"Caught exception during {((InventoryItem)this).InternalName}'s LateUpdateGun");
					Debug.LogException(ex3);
				}
			}
		}

		public void BaseInitializeGun()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.spawn_info_sprite == (Object)null)
			{
				Debug.LogError((object)("Gun " + ((InventoryItem)this).InternalName + " doesn't have a spawn_info_sprite assigned, it may cause problems later"));
				base.spawn_info_sprite = Sprite.Create(Texture2D.blackTexture, Rect.zero, Vector2.zero);
			}
			keybinds = SettingsMenuManager.GenerateKeybindMenu(this);
			try
			{
				InitializeGun();
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Error accured while initializing gun " + ((InventoryItem)this).InternalName + ":"));
				Debug.LogException(ex);
			}
		}

		public override void OnChangeInventorySlot(InventorySlot old_slot, InventorySlot new_slot, Hand from_hand, Hand to_hand)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			((GunScript)this).OnChangeInventorySlot(old_slot, new_slot, from_hand, to_hand);
			if ((Object)(object)new_slot != (Object)null && (Object)(object)old_slot != (Object)null)
			{
				if ((int)new_slot.type == 2)
				{
					OnHolster();
				}
				else if ((int)new_slot.type == 1)
				{
					OnUnholster();
				}
			}
		}

		public virtual void InitializeGun()
		{
		}

		public virtual void AwakeGun()
		{
		}

		public virtual ModHelpEntry GetGunHelpEntry()
		{
			if (help_entry == null || !help_entry.generate)
			{
				return null;
			}
			return help_entry;
		}

		[Obsolete("This method makes gun loading unnecessarily complicated, use ModShellCasingScript instead")]
		public virtual CartridgeSpec GetCustomCartridgeSpec()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			CartridgeSpec result = default(CartridgeSpec);
			((CartridgeSpec)(ref result)).SetFromPreset((Preset)0);
			return result;
		}

		public virtual LocaleTactics GetGunTactics()
		{
			return locale_tactics.GetLocaleTactics((GunScript)(object)this);
		}

		public virtual float GetTotalMass()
		{
			return -1f;
		}

		[HarmonyPatch(typeof(GunScript), "GetTotalMass")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		public float GetDefaultTotalMass()
		{
			return 0f;
		}

		[HarmonyPatch(typeof(GunScript), "GetTotalMass")]
		[HarmonyPrefix]
		public static bool PatchGetTotalMass(GunScript __instance, ref float __result)
		{
			__result = __instance.GetTotalMass();
			return __result < 0f;
		}

		public virtual float GetMagSmackStrength()
		{
			return magazine_shake_strength_multiplier;
		}

		public virtual Vector2 GetStepRecoilMultiplier()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(1f / base.mass, 1f / base.mass);
		}

		public virtual bool CanHolster()
		{
			if ((Object)(object)base.magazine_instance_in_gun != (Object)null)
			{
				return ((SimpleMover)base.magazine).amount == 0f;
			}
			return true;
		}

		public virtual void OnHolster()
		{
		}

		public virtual void OnUnholster()
		{
		}

		public abstract void UpdateGun();

		public virtual void EarlyUpdateGun()
		{
		}

		public virtual void LateUpdateGun()
		{
		}

		public virtual float GetSlideReturnTime()
		{
			return slide_return_time;
		}

		public static float CalculateSlideAcceleration(GunScript __instance, float change, float time)
		{
			if (__instance is ModGunScript)
			{
				time = (__instance as ModGunScript).GetSlideReturnTime();
			}
			return 2f * change / (time * time);
		}

		internal static float CalculateSlideAccelerationTime(GunScript __instance, float change, float time)
		{
			if (__instance is ModGunScript)
			{
				time = (__instance as ModGunScript).GetSlideReturnTime();
			}
			return 2f * change / (time * time) * time;
		}

		public override string TypeName()
		{
			return "ModGunScript";
		}

		public bool OwnData(JSONNode data)
		{
			if (data != (object)null && data.HasKey("gun_internal_name"))
			{
				return data["gun_internal_name"] == (object)((InventoryItem)this).InternalName;
			}
			return false;
		}

		public JSONObject EncodeJSON(JSONNode json)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			JSONObject val = new JSONObject();
			((JSONNode)val)["gun_internal_name"] = JSONNode.op_Implicit(((InventoryItem)this).InternalName);
			if (json == (object)null)
			{
				return val;
			}
			Enumerator enumerator = json.GetEnumerator();
			while (((Enumerator)(ref enumerator)).MoveNext())
			{
				KeyValuePair<string, JSONNode> current = ((Enumerator)(ref enumerator)).Current;
				((JSONNode)val)[((InventoryItem)this).InternalName + "." + current.Key] = current.Value;
			}
			return val;
		}

		public JSONObject DecodeJSON(JSONNode json)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			JSONObject val = new JSONObject();
			if (json == (object)null)
			{
				return val;
			}
			Enumerator enumerator = json.GetEnumerator();
			while (((Enumerator)(ref enumerator)).MoveNext())
			{
				KeyValuePair<string, JSONNode> current = ((Enumerator)(ref enumerator)).Current;
				if (!(current.Key == "gun_internal_name"))
				{
					((JSONNode)val)[current.Key.Replace(((InventoryItem)this).InternalName + ".", "")] = current.Value;
				}
			}
			return val;
		}

		public override JSONObject GetPersistentData()
		{
			return ((GunScript)this).GetPersistentData();
		}

		public override void SetPersistentData(JSONObject data)
		{
			((GunScript)this).SetPersistentData(data);
		}

		public void OnBeforeSerialize()
		{
			if (help_entry != null)
			{
				help_entry_generate = help_entry.generate;
				help_entry_name = help_entry.name;
				help_entry_info_sprite = help_entry.info_sprite;
				help_entry_title = help_entry.title;
				help_entry_description = help_entry.description;
			}
			if (locale_tactics != null)
			{
				locale_tactics_title = locale_tactics.title;
				locale_tactics_description = locale_tactics.description;
			}
		}

		public void OnAfterDeserialize()
		{
			if (help_entry == null)
			{
				help_entry = new ModHelpEntry(help_entry_name)
				{
					generate = help_entry_generate,
					info_sprite = help_entry_info_sprite,
					title = help_entry_title,
					description = help_entry_description
				};
			}
			if (locale_tactics == null)
			{
				locale_tactics = new ModLocaleTactics
				{
					title = locale_tactics_title,
					description = locale_tactics_description
				};
			}
		}
	}
	[Serializable]
	public class ModHelpEntry
	{
		[Tooltip("Should the help entry be generated")]
		public bool generate;

		[Tooltip("Name of the help menu button")]
		public string name;

		[Tooltip("Sprite to display on the top of the help menu entry")]
		public Sprite info_sprite;

		[Tooltip("Title of the entry, displayed in big, bold letters")]
		public string title;

		[Tooltip("All the text describing the gun, HTML style selectors are allowed")]
		[TextArea]
		public string description;

		[Tooltip("Whether or not the entry is locked by default")]
		public bool locked_default;

		public MenuEntryCategories menu_entry_category;

		internal bool settings_button_active;

		private EntryComponentScript m_entry_component;

		private List<UnityAction> action_queue = new List<UnityAction>();

		public ModHelpEntry(string name)
		{
			this.name = name;
		}

		public EntryComponentScript GetEntryComponent()
		{
			return m_entry_component;
		}

		internal void SetEntryComponent(EntryComponentScript entry)
		{
			m_entry_component = entry;
			if (action_queue.Count <= 0)
			{
				return;
			}
			foreach (UnityAction item in action_queue)
			{
				((UnityEvent)((Button)m_entry_component.secondary_button).onClick).AddListener(item);
			}
		}

		public void AddSettingsButtonAction(UnityAction action)
		{
			settings_button_active = true;
			if ((Object)(object)m_entry_component != (Object)null)
			{
				((UnityEvent)((Button)m_entry_component.secondary_button).onClick).AddListener(action);
			}
			else
			{
				action_queue.Add(action);
			}
		}
	}
	public class ModHelpEntryManager : MonoBehaviour
	{
		private delegate void D2(string s);

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<MethodInfo, bool> <>9__6_0;

			public static UnityAction <>9__8_2;

			public static Func<EntryComponentScript, bool> <>9__9_0;

			public static Func<EntryComponentScript, bool> <>9__9_1;

			internal bool <get_help_menu>b__6_0(MethodInfo x)
			{
				if (x.Name == "OnEntryClick")
				{
					return x.GetParameters()[0].ParameterType == typeof(string);
				}
				return false;
			}

			internal void <PatchHelpCreateMenuEntries>b__8_2()
			{
				AudioManager.PlayOneShot("event:/UI/ui_butt_sett_key", 1f);
			}

			internal bool <PatchHelpOnLoad>b__9_0(EntryComponentScript e)
			{
				return ((Behaviour)e).isActiveAndEnabled;
			}

			internal bool <PatchHelpOnLoad>b__9_1(EntryComponentScript e)
			{
				return e.hidden;
			}
		}

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

		private static Delegate OnEntryClick;

		private static HelpMenuScript m_help_menu;

		private static Sprite secondary_button_sprite;

		private static HelpMenuScript help_menu
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)m_help_menu))
				{
					m_help_menu = Object.FindObjectOfType<HelpMenuScript>();
					OnEntryClick = Delegate.CreateDelegate(typeof(D2), m_help_menu, typeof(EntryDescriptionMenuScript).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic).FirstOrDefault((MethodInfo x) => x.Name == "OnEntryClick" && x.GetParameters()[0].ParameterType == typeof(string)));
				}
				return m_help_menu;
			}
		}

		private void Awake()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			using Stream stream = ModdingKitCorePlugin.GetResourceStream("cog.png");
			if (stream.Length > 0)
			{
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, (int)stream.Length);
				Texture2D val = new Texture2D(64, 64);
				ImageConversion.LoadImage(val, array);
				secondary_button_sprite = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
			}
			else
			{
				secondary_button_sprite = Sprite.Create(Texture2D.whiteTexture, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
			}
		}

		[HarmonyPatch(typeof(HelpMenuScript), "CreateMenuEntries")]
		[HarmonyPrefix]
		private static void PatchHelpCreateMenuEntries(HelpMenuScript __instance)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			foreach (ModHelpEntry value2 in entries.Values)
			{
				if (!Locale.active_locale_help_menu_entries_string.ContainsKey(value2.name))
				{
					LocaleHelpMenuEntry value = new LocaleHelpMenuEntry
					{
						title = value2.title,
						description = value2.description,
						id_string = value2.name,
						name = value2.name
					};
					Locale.active_locale_help_menu_entries_string.Add(value2.name, value);
				}
				if ((int)value2.menu_entry_category != 0)
				{
					for (int i = 0; i < ((EntryDescriptionMenuScript)__instance).categories.Count; i++)
					{
						if (((EntryDescriptionMenuScript)__instance).categories[i].category_id == value2.menu_entry_category)
						{
							CreateEntry(value2, ((EntryDescriptionMenuScript)__instance).categories[i]);
						}
					}
				}
				else
				{
					CreateEntry(value2, ((EntryDescriptionMenuScript)__instance).categories[4]);
				}
			}
			void CreateEntry(ModHelpEntry mod_entry, Category help_page)
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Expected O, but got Unknown
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_021f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Expected O, but got Unknown
				if (!help_page.entry_string_id_dict.ContainsKey(mod_entry.name))
				{
					GameObject val = Object.Instantiate<GameObject>(help_menu.ecsPrefab);
					((Object)val).name = mod_entry.name;
					val.transform.SetParent(help_page.root_object.transform, true);
					Transform obj = val.transform.Find("Button");
					obj.localPosition += Vector3.left * 37f;
					((Transform)val.GetComponent<RectTransform>()).localScale = new Vector3(1f, 1f, 1f);
					EntryComponentScript component = val.GetComponent<EntryComponentScript>();
					component.string_id = mod_entry.name;
					((TMP_Text)component.title).text = mod_entry.name;
					((UnityEvent)((Button)component.button).onClick).AddListener((UnityAction)delegate
					{
						OnEntryClick.DynamicInvoke(mod_entry.name);
					});
					component.default_enabled = !mod_entry.locked_default;
					if ((Object)(object)mod_entry.info_sprite != (Object)null)
					{
						component.media.sprite_index = ((EntryDescriptionMenuScript)help_menu).sprites.Count();
						((EntryDescriptionMenuScript)help_menu).sprites.Add(mod_entry.info_sprite);
					}
					help_page.entries.Add(component);
					help_page.entry_string_id_dict.Add(mod_entry.name, component);
					((EntryDescriptionMenuScript)__instance).category_string_id_dict.Add(mod_entry.name, help_page);
					if (mod_entry.settings_button_active)
					{
						GameObject val2 = Object.Instantiate<GameObject>(GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Help Menu/Entries Layout/ScrollableContent Variant/Viewport/Content/Guns/StovePipe/Secondary Button"));
						val2.transform.SetParent(val.transform);
						val2.transform.localScale = Vector3.one;
						val2.transform.localPosition = Vector3.right * 236.2f;
						val2.SetActive(true);
						component.secondary_button = val2.GetComponent<SelectableButton>();
						ButtonClickedEvent onClick = ((Button)component.secondary_button).onClick;
						object obj2 = <>c.<>9__8_2;
						if (obj2 == null)
						{
							UnityAction val3 = delegate
							{
								AudioManager.PlayOneShot("event:/UI/ui_butt_sett_key", 1f);
							};
							<>c.<>9__8_2 = val3;
							obj2 = (object)val3;
						}
						((UnityEvent)onClick).AddListener((UnityAction)obj2);
						((Component)((Component)component.secondary_button).transform.Find("Image")).GetComponent<Image>().sprite = secondary_button_sprite;
					}
					mod_entry.SetEntryComponent(component);
				}
			}
		}

		[HarmonyPatch(typeof(HelpMenuScript), "OnLoad")]
		[HarmonyPostfix]
		private static void PatchHelpOnLoad(HelpMenuScript __instance)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			foreach (Category category in ((EntryDescriptionMenuScript)__instance).categories)
			{
				int num = category.entry_string_id_dict.Values.Count((EntryComponentScript e) => ((Behaviour)e).isActiveAndEnabled);
				int num2 = category.entry_string_id_dict.Values.Count((EntryComponentScript e) => e.hidden);
				if (Locale.active_locale_category_string.TryGetValue(category.category_id, out var value))
				{
					((TMP_Text)category.title).text = $"{value} - {num}/{category.entries.Count - num2}";
				}
			}
		}
	}
	public class ModShellCasingScript : ShellCasingScript, ISerializationCallbackReceiver
	{
		[Serializable]
		public class ModCartridgeSpec
		{
			[Tooltip("Mass of the empty casing, in grams")]
			public float casing_mass;

			[Tooltip("Mass of the bullet, in grams")]
			public float bullet_mass;

			[Tooltip("Muzzle speed of the projectile, in meters / second")]
			public float speed;

			[Tooltip("Diameter, or caliber, of the bullet")]
			public float diameter;

			[Tooltip("Density of the material, in grams / cc")]
			public float density = 11.34f;

			public CartridgeSpec CreateSpec()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				return new CartridgeSpec
				{
					mass = bullet_mass,
					extra_mass = casing_mass,
					speed = speed,
					cylinder_length = bullet_mass / density / ((float)Math.PI * diameter * diameter * 0.25f),
					diameter = diameter,
					density = density,
					gravity = true
				};
			}
		}

		internal static Dictionary<Preset, CartridgeSpec> mod_cartridges = new Dictionary<Preset, CartridgeSpec>();

		[EventRef]
		public string sound_shell_casing_impact_hard = "event:/bullets/shell_casing_impact_hard";

		[EventRef]
		public string sound_bullet_fall_hard = "event:/bullets/bullet_fall_hard";

		[EventRef]
		public string sound_shell_casing_impact_soft = "event:/bullets/shell_casing_impact_soft";

		public ModCartridgeSpec spec;

		public CustomRoundDefinition customRoundTypeParameters;

		[SerializeField]
		[HideInInspector]
		private float spec_casing_mass;

		[SerializeField]
		[HideInInspector]
		private float spec_bullet_mass;

		[SerializeField]
		[HideInInspector]
		private float spec_speed;

		[SerializeField]
		[HideInInspector]
		private float spec_diameter;

		[SerializeField]
		[HideInInspector]
		private float spec_density;

		public void OnBeforeSerialize()
		{
			spec_casing_mass = spec.casing_mass;
			spec_bullet_mass = spec.bullet_mass;
			spec_speed = spec.speed;
			spec_diameter = spec.diameter;
			spec_density = spec.density;
		}

		public void OnAfterDeserialize()
		{
			if (spec == null)
			{
				spec = new ModCartridgeSpec
				{
					casing_mass = spec_casing_mass,
					bullet_mass = spec_bullet_mass,
					speed = spec_speed,
					diameter = spec_diameter,
					density = spec_density
				};
			}
		}
	}
	public class ModTape
	{
		private readonly TapeContent tape_content;

		private readonly GameObject tertiary_button;

		private readonly EntryComponentScript entry;

		public ModTape(TapeContent tape_content, GameObject tertiary_button, EntryComponentScript entry)
		{
			this.tape_content = tape_content;
			this.tertiary_button = tertiary_button;
			this.entry = entry;
		}

		public void SetEntryCompound()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			((Component)entry.button).GetComponent<RectTransform>().anchoredPosition = new Vector2(-56.2f, 2f);
			((Component)entry.button).GetComponent<RectTransform>().sizeDelta = new Vector2(343f, 46f);
			tertiary_button.SetActive(true);
		}

		public void SetEntryNormal()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			((Component)entry.button).GetComponent<RectTransform>().anchoredPosition = new Vector2(200f, -23f);
			((Component)entry.button).GetComponent<RectTransform>().sizeDelta = new Vector2(400f, 46f);
			tertiary_button.SetActive(false);
		}
	}
	internal class ModTapeManager : MonoBehaviour
	{
		private static List<ModTape> tapes = new List<ModTape>();

		private static GameObject instantiate_tape_button_prefab;

		private static Sprite instantiate_tape_sprite;

		private static TapesMenuScript tapes_menu;

		internal static bool tapes_debug_window_open;

		private static Dictionary<string, FileInfo> tape_subtitles { get; } = new Dictionary<string, FileInfo>();

		internal static void Init()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			instantiate_tape_button_prefab = Object.Instantiate<GameObject>(GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Tape Menu/Entries Layout/ScrollableContent Variant/Viewport/Content/Standard/Invalid/Secondary Button"));
			using (Stream stream = ModdingKitCorePlugin.GetResourceStream("tape.png"))
			{
				if (stream.Length > 0)
				{
					byte[] array = new byte[stream.Length];
					stream.Read(array, 0, (int)stream.Length);
					Texture2D val = new Texture2D(64, 64);
					ImageConversion.LoadImage(val, array);
					instantiate_tape_sprite = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
				}
				else
				{
					instantiate_tape_sprite = Sprite.Create(Texture2D.whiteTexture, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
				}
			}
			((Object)instantiate_tape_button_prefab).name = "Instantiate Tape ";
			instantiate_tape_button_prefab.transform.localScale = Vector3.one;
			((Component)instantiate_tape_button_prefab.transform.Find("Image")).GetComponent<Image>().sprite = instantiate_tape_sprite;
			instantiate_tape_button_prefab.transform.Find("Image").localScale = new Vector3(1.2f, 1.2f, 1.2f);
			instantiate_tape_button_prefab.SetActive(true);
		}

		internal static void CreateModTapes(TapesMenuScript tapes_menu)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			foreach (TapeContent mod_tape in ReceiverCoreScript.Instance().tape_loadout_asset.GetModTapes())
			{
				Category val = ((EntryDescriptionMenuScript)tapes_menu).category_string_id_dict[mod_tape.tape_id_string];
				EntryComponentScript tape_entry = val.entries.First((EntryComponentScript entry) => entry.string_id == mod_tape.tape_id_string);
				((Object)((Component)tape_entry).gameObject).name = ((Object)mod_tape).name;
				GameObject val2 = Object.Instantiate<GameObject>(instantiate_tape_button_prefab);
				val2.transform.SetParent(((Component)tape_entry).transform);
				val2.transform.localScale = Vector3.one;
				((Transform)val2.GetComponent<RectTransform>()).SetSiblingIndex(1);
				((UnityEvent)((Button)val2.GetComponent<SelectableButton>()).onClick).AddListener((UnityAction)delegate
				{
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0043: Unknown result type (might be due to invalid IL or missing references)
					//IL_0048: Unknown result type (might be due to invalid IL or missing references)
					//IL_0058: Unknown result type (might be due to invalid IL or missing references)
					TapeScript val3 = TapeManager.InstantiateTape(tape_entry.string_id, (Transform)null);
					if ((Object)(object)LocalAimHandler.player_instance != (Object)null)
					{
						((Component)val3).transform.position = ((Component)LocalAimHandler.player_instance).transform.position + new Vector3(0f, 0.5f, 0f);
						((Component)val3).transform.rotation = Random.rotation;
					}
					((InventoryItem)val3).AddRigidBody();
				});
				ModTape item = new ModTape(mod_tape, val2, tape_entry);
				tapes.Add(item);
			}
		}

		internal static void RegisterSubtitles(string tape_id, FileInfo tape_subtitles_file)
		{
			tape_subtitles.Add(tape_id, tape_subtitles_file);
		}

		internal static void TryReplaceSubtitles(string tape_id, ref TapeSubtitles subtitles)
		{
			if (!tape_subtitles.ContainsKey(tape_id))
			{
				return;
			}
			FileInfo fileInfo = tape_subtitles[tape_id];
			if (fileInfo.Exists)
			{
				using (StreamReader streamReader = new StreamReader(fileInfo.FullName))
				{
					subtitles.tape_path = fileInfo.FullName;
					subtitles.tape_subtitle_string = streamReader.ReadToEnd();
				}
			}
		}

		internal static void PrepareTapesForCompound()
		{
			foreach (ModTape tape in tapes)
			{
				tape.SetEntryCompound();
			}
		}

		internal static void PrepareTapesForGame()
		{
			foreach (ModTape tape in tapes)
			{
				tape.SetEntryNormal();
			}
		}

		internal static void SwitchMenuVisible()
		{
			tapes_debug_window_open = !tapes_debug_window_open;
		}

		private static void DrawTapesImGUI()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)tapes_menu == (Object)null && (Object)(object)GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Tape Menu") != (Object)null)
			{
				tapes_menu = GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Tape Menu").GetComponent<TapesMenuScript>();
			}
			if (!((Object)(object)tapes_menu != (Object)null) || !tapes_debug_window_open)
			{
				return;
			}
			ImGui.SetNextWindowSize(new Vector2(240f, 600f), (ImGuiCond)4);
			ImGuiWindowFlags val = (ImGuiWindowFlags)0;
			if (!ReceiverGlobals.window_interactive)
			{
				val = (ImGuiWindowFlags)(val | 0xB);
				ImGui.SetNextWindowBgAlpha(0f);
				ImGui.PushStyleVar((ImGuiStyleVar)3, 0f);
			}
			if (!ImGui.Begin("Unlocked Tapes", ref tapes_debug_window_open, val))
			{
				return;
			}
			foreach (Category category in ((EntryDescriptionMenuScript)tapes_menu).categories)
			{
				ImGui.Separator();
				ImGui.Text(((object)Unsafe.As<MenuEntryCategories, MenuEntryCategories>(ref category.category_id)/*cast due to .constrained prefix*/).ToString());
				ImGui.Separator();
				foreach (EntryComponentScript entry in category.entries)
				{
					bool flag = ReceiverCoreScript.Instance().PlayerData.picked_up_tape_ids_string.Contains(entry.string_id);
					if (ImGui.Checkbox(entry.string_id, ref flag))
					{
						if (flag)
						{
							ReceiverCoreScript.Instance().PlayerData.picked_up_tape_ids_string.Add(entry.string_id);
						}
						else
						{
							ReceiverCoreScript.Instance().PlayerData.picked_up_tape_ids_string.Remove(entry.string_id);
						}
						tapes_menu.OnEnable();
					}
				}
			}
			ImGui.End();
		}

		private void Update()
		{
			DrawTapesImGUI();
		}
	}
	internal static class ModdedGunsCampaignManager
	{
		public static HashSet<string> modded_guns_campaigns = new HashSet<string>();
	}
	internal class ModdingKitConfig
	{
		public static ConfigEntry<bool> use_custom_sounds;

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

		public static ConfigEntry<bool> enable_asset_caching;

		public static ConfigEntry<string> asset_database_path;

		public static ConfigEntry<string> asset_cache_path;

		public static ConfigFile Config => ((BaseUnityPlugin)ModdingKitCorePlugin.instance).Config;

		public static void Initialize()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			use_custom_sounds = Config.Bind<bool>("Guns settings", "Use Custom Sounds", true, "Should modded guns use custom sounds.");
			asset_database_path = Config.Bind<string>("Assets settings", "Asset Database Path", "./AssetsDatabase", "Path to the database of asset file infos. Change if you want to synchronize across multiple plugin instances");
			enable_asset_caching = Config.Bind<bool>("Assets settings", "Enable Asset Caching", true, "Should the plugin chache the extracted assets.");
			asset_cache_path = Config.Bind<string>("Assets settings", "Asset Cache Path", "./AssetsCache", "Path where cached assets will be stored. Change if you want to synchronize across multiple plugin instances");
			SettingsMenuManager.CreateSettingsMenuOption<bool>("Custom Sounds", use_custom_sounds, 9);
			SettingsMenuManager.CreateSettingsMenuButton("Install Gun Mod", "Install", new UnityAction(ModLoader.SearchForMod), 10);
		}

		public static void AddConfigEventListener(EventHandler<SettingChangedEventArgs> settings_changed_listener)
		{
			if ((Object)(object)ModdingKitCorePlugin.instance != (Object)null && Config != null)
			{
				Config.SettingChanged += settings_changed_listener;
			}
		}

		public static void UpdateKeybindValue(Keybind keybind)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			string value = "-1";
			if (keybind.key != null)
			{
				value = (keybind.key.IsRedirect() ? keybind.key.GetKey().ToString() : ((object)(KeyCode)keybind.key.GetKey()/*cast due to .constrained prefix*/).ToString());
			}
			custom_keybinds_config[keybind.GetLongName()].Value = value;
		}

		public static string BindKeybindConfig(Keybind keybind)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			string text = "-1";
			if (keybind.key != null)
			{
				text = (keybind.key.IsRedirect() ? keybind.key.GetKey().ToString() : ((object)(KeyCode)keybind.key.GetKey()/*cast due to .constrained prefix*/).ToString());
			}
			ConfigEntry<string> val = Config.Bind<string>("Custom Keybinds", keybind.GetLongName(), text, (ConfigDescription)null);
			custom_keybinds_config[keybind.GetLongName()] = val;
			return val.Value;
		}
	}
	[BepInPlugin("pl.szikaka.receiver_2_modding_kit", "Receiver 2 Modding Kit", "1.5.0")]
	[BepInProcess("Receiver2")]
	public class ModdingKitCorePlugin : BaseUnityPlugin
	{
		public delegate void StartupAction();

		private static ModHelpEntryManager mod_help;

		private static ModTapeManager mod_tapes;

		internal static Dictionary<Preset, ShellCasingScript> round_prefabs = new Dictionary<Preset, ShellCasingScript>();

		public static readonly string supportedVersion = "2.2.4";

		public static ModdingKitCorePlugin instance { get; private set; }

		[Obsolete("Use methods from ModdingKitEvents class instead")]
		public static void AddTaskAtCoreStartup(StartupAction action)
		{
			ModdingKitEvents.ExecuteOnStartup = (ModdingKitEvents.StartupAction)Delegate.Combine(ModdingKitEvents.ExecuteOnStartup, (ModdingKitEvents.StartupAction)delegate
			{
				action.DynamicInvoke();
			});
		}

		public static Stream GetResourceStream(string resource_name)
		{
			if (Assembly.GetExecutingAssembly().GetManifestResourceInfo("Receiver2ModdingKit.resources." + resource_name) != null)
			{
				return Assembly.GetExecutingAssembly().GetManifestResourceStream("Receiver2ModdingKit.resources." + resource_name);
			}
			if (File.Exists(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)instance).Info.Location), resource_name)))
			{
				return File.OpenRead(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)instance).Info.Location), resource_name));
			}
			return Stream.Null;
		}

		public static void AddNewCartridgePreset(Preset preset, CartridgeSpec cartridge)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ModShellCasingScript.mod_cartridges.Add(preset, cartridge);
		}

		private static void GatherAllRoundPrefabs()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			InventoryItem[] generic_prefabs = ReceiverCoreScript.Instance().generic_prefabs;
			foreach (InventoryItem obj in generic_prefabs)
			{
				ShellCasingScript val;
				if ((val = (ShellCasingScript)(object)((obj is ShellCasingScript) ? obj : null)) != null && ((Object)val).name != "load_progression" && ((Object)val).name != "762x54r_round_object" && !round_prefabs.ContainsKey(val.cartridge_type))
				{
					round_prefabs.Add(val.cartridge_type, val);
				}
			}
		}

		public static void AddShellCasingScriptPrefab(ShellCasingScript prefab)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			round_prefabs.Add(prefab.cartridge_type, prefab);
			Array.Resize(ref ReceiverCoreScript.Instance().generic_prefabs, ReceiverCoreScript.Instance().generic_prefabs.Length + 1);
			ReceiverCoreScript.Instance().generic_prefabs[ReceiverCoreScript.Instance().generic_prefabs.Length - 1] = (InventoryItem)(object)prefab;
		}

		public static ShellCasingScript GetRoundPrefab(Preset cartridge_type)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return round_prefabs[cartridge_type];
		}

		private IEnumerator SetErrorState()
		{
			while ((Object)(object)ReceiverCoreScript.Instance() == (Object)null)
			{
				yield return null;
			}
			GameObject val = new GameObject("Modding Kit Error");
			RectTransform val2 = val.AddComponent<RectTransform>();
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((Transform)val2).SetParent(GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter").transform);
			val2.pivot = Vector2.zero;
			((Transform)val2).localScale = Vector3.one;
			val2.anchoredPosition = Vector2.zero;
			val2.pivot = Vector2.one;
			val2.anchorMax = Vector2.one;
			val2.anchorMin = Vector2.one;
			val2.sizeDelta = new Vector2(400f, 300f);
			((TMP_Text)obj).fontSize = 20f;
			((TMP_Text)obj).faceColor = new Color32(byte.MaxValue, (byte)50, (byte)50, byte.MaxValue);
			((TMP_Text)obj).text = "An error happened within the Modding Kit:\n   Modding Kit version " + ((BaseUnityPlugin)this).Info.Metadata.Version.ToString() + "\n   Was made to support game version " + supportedVersion + "\n   And will not work for this version (" + ReceiverCoreScript.Instance().build_info.version + ")\n   Please update your game and/or plugin";
		}

		private void AddPatchMessageToMenu()
		{
			((Component)((Component)ReceiverCoreScript.Instance()).transform.Find("Menus/New Main Menu/Canvas/CanvasGroup/Title image")).gameObject.SetActive(false);
			((Component)((Component)ReceiverCoreScript.Instance()).transform.Find("Menus/New Main Menu/Canvas/CanvasGroup/Title/Number")).gameObject.SetActive(false);
			((Component)((Component)ReceiverCoreScript.Instance()).transform.Find("Menus/New Main Menu/Canvas/CanvasGroup/Title")).gameObject.SetActive(true);
			((TMP_Text)((Component)((Component)ReceiverCoreScript.Instance()).transform.Find("Menus/New Main Menu/Canvas/CanvasGroup/Title/Receiver")).GetComponent<TextMeshProUGUI>()).text = "Please restart the game :)";
			((Component)((Component)ReceiverCoreScript.Instance()).transform.Find("Menus/New Main Menu/Canvas/CanvasGroup/PressStartText")).gameObject.SetActive(false);
			((TMP_Text)((Component)((Component)ReceiverCoreScript.Instance()).transform.Find("Menus/New Main Menu/Canvas/CanvasGroup/Bottom atmospheric text/Text")).GetComponent<TextMeshProUGUI>()).text = "FMOD libraries couldn't be loaded due to a \"security patch\" included in glibc >= 2.41.\nThe Modding Kit has patched the libraries to be loadable again, but it requires a game restart, so restart that game :)\nFor more info: https://qa.fmod.com/t/glibc-2-41-breaks-loading-fmodstudio-libraries-in-standalone-linux-builds/22592/2";
		}

		private void Awake()
		{
			//IL_013a: Expected O, but got Unknown
			if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
			{
				string path = Path.Combine(Application.dataPath, "Plugins");
				string filePath = Path.Combine(path, "libfmod.so");
				string filePath2 = Path.Combine(path, "libfmodstudio.so");
				if (LinuxELFExecstackPatcher.PatchFlag(filePath) | LinuxELFExecstackPatcher.PatchFlag(filePath2))
				{
					ModdingKitEvents.AddTaskAtCoreStartup(AddPatchMessageToMenu);
				}
			}
			if (FMODLogger.Initialize())
			{
				Debug.Log((object)"FMOD Logger initialisation successful");
			}
			else
			{
				Debug.Log((object)"Loaded FMOD Library is the non-logging version");
			}
			instance = this;
			Type[] types = typeof(BepInPlugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.FullName == "BepInEx.ConsoleUtil.Kon")
				{
					Extensions.konType = type;
					break;
				}
			}
			ModdingKitEvents.AddTaskAtCoreStartup(GatherAllRoundPrefabs);
			try
			{
				if (Receiver2ModdingKit.Thunderstore.Thunderstore.LaunchedWithR2ModMan)
				{
					Debug.Log((object)"Launched Receiver 2 Modding Kit with r2modman");
					Receiver2ModdingKit.Thunderstore.Thunderstore.InstallMods();
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)"Error while loading mods");
				Debug.LogException(ex);
			}
			finally
			{
				if (!Receiver2ModdingKit.Thunderstore.Thunderstore.LaunchedWithR2ModMan)
				{
					Debug.Log((object)"Launched Receiver 2 Modding Kit standalone");
				}
			}
			ModdingKitEvents.AddTaskAtCoreStartup(delegate
			{
			});
			try
			{
				HarmonyManager.Initialize();
				ReflectionManager.Initialize();
			}
			catch (HarmonyException ex2)
			{
				Debug.LogError((object)ex2);
				((MonoBehaviour)this).StartCoroutine(SetErrorState());
			}
			catch (MissingFieldException ex3)
			{
				Debug.LogError((object)ex3);
				((MonoBehaviour)this).StartCoroutine(SetErrorState());
			}
			mod_help = ((Component)this).gameObject.AddComponent<ModHelpEntryManager>();
			mod_tapes = ((Component)this).gameObject.AddComponent<ModTapeManager>();
			((Component)this).gameObject.AddComponent<ModGameModeManager>();
			ModAudioManager.Initialize();
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "GlobalBaseConfiguration")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "GlobalBaseConfiguration"));
			}
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "PlayerLoadouts")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "PlayerLoadouts"));
			}
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "RankingProgressionCampaigns")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "RankingProgressionCampaigns"));
			}
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "WorldGenerationConfigurations")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "WorldGenerationConfigurations"));
			}
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "Guns")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "Guns"));
			}
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "Tiles")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "Tiles"));
			}
			if (!Directory.Exists(Path.Combine(Application.persistentDataPath, "Tapes")))
			{
				Directory.CreateDirectory(Path.Combine(Application.persistentDataPath, "Tapes"));
			}
		}

		private void Update()
		{
			ModAudioManager.Update();
		}

		private void OnDestroy()
		{
			HarmonyManager.UnpatchAll();
			if ((Object)(object)mod_help != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)mod_help);
			}
			if ((Object)(object)mod_tapes != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)mod_tapes);
			}
			if (Directory.Exists(ScriptEngine.ScriptDirectory))
			{
				Directory.Delete(ScriptEngine.ScriptDirectory, recursive: true);
			}
			if ((Object)(object)ModLoader.mod_installer != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)ModLoader.mod_installer);
			}
			ModAudioManager.Release();
			if (Receiver2ModdingKit.Thunderstore.Thunderstore.LaunchedWithR2ModMan)
			{
				Receiver2ModdingKit.Thunderstore.Thunderstore.CleanupMods();
			}
		}
	}
	public static class ModdingKitEvents
	{
		public delegate void StartupAction();

		public delegate bool OnItemSpawn(ref ActiveItem spawned_item);

		internal static StartupAction ExecuteOnStartup = delegate
		{
		};

		internal static Dictionary<string, List<OnItemSpawn>> ItemSpawnHandlers = new Dictionary<string, List<OnItemSpawn>>();

		public static void AddTaskAtCoreStartup(StartupAction action)
		{
			ExecuteOnStartup = (StartupAction)Delegate.Combine(ExecuteOnStartup, action);
		}

		public static void RegisterItemSpawnHandler(string gun_internal_name, OnItemSpawn handler)
		{
			if (ItemSpawnHandlers.ContainsKey(gun_internal_name))
			{
				ItemSpawnHandlers[gun_internal_name].Add(handler);
				return;
			}
			ItemSpawnHandlers[gun_internal_name] = new List<OnItemSpawn> { handler };
		}
	}
	public class PlayerInput
	{
		private GunScript gun;

		private LocalAimHandler lah;

		public PlayerInput(GunScript gun)
		{
			this.gun = gun;
			lah = LocalAimHandler.player_instance;
		}

		public bool UpdatePlayerReference()
		{
			lah = LocalAimHandler.player_instance;
			return (Object)(object)lah != (Object)null;
		}

		private bool CheckGun()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if ((int)lah.hands[1].state == 1)
			{
				return (Object)(object)((InventoryItem)gun).slot == (Object)(object)lah.hands[1].slot;
			}
			return false;
		}

		public bool GetButtonDown(int button)
		{
			return GetButtonDown(button, ignore_lah: false);
		}

		public bool GetButtonDown(int button, bool ignore_lah)
		{
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if (!ignore_lah)
			{
				if (CheckGun())
				{
					return lah.character_input.GetButtonDown(button);
				}
				return false;
			}
			return true;
		}

		public bool GetButtonDown(Keybind key)
		{
			return GetButtonDown(key, ignore_lah: false);
		}

		public bool GetButtonDown(Keybind key, bool ignore_lah)
		{
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if (key == null)
			{
				return false;
			}
			if (key.key == null)
			{
				return GetButtonDown(key.fallback_action_id, ignore_lah);
			}
			if (key.key.IsRedirect())
			{
				return GetButtonDown(key.key.GetKey());
			}
			if ((ignore_lah || CheckGun()) && !ImGuiConsole.console_open)
			{
				return Input.GetKeyDown((KeyCode)key.key.GetKey());
			}
			return false;
		}

		public bool GetButton(int button)
		{
			return GetButton(button, ignore_lah: false);
		}

		public bool GetButton(int button, bool ignore_lah)
		{
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if (!ignore_lah)
			{
				if (CheckGun())
				{
					return lah.character_input.GetButton(button);
				}
				return false;
			}
			return true;
		}

		public bool GetButton(Keybind key)
		{
			return GetButton(key, ignore_lah: false);
		}

		public bool GetButton(Keybind key, bool ignore_lah)
		{
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if (key == null)
			{
				return false;
			}
			if (key.key == null)
			{
				return GetButton(key.fallback_action_id, ignore_lah);
			}
			if (key.key.IsRedirect())
			{
				return GetButton(key.key.GetKey());
			}
			if ((ignore_lah || CheckGun()) && !ImGuiConsole.console_open)
			{
				return Input.GetKey((KeyCode)key.key.GetKey());
			}
			return false;
		}

		public bool GetButtonUp(int button)
		{
			return GetButtonUp(button, ignore_lah: false);
		}

		public bool GetButtonUp(int button, bool ignore_lah)
		{
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if (!ignore_lah)
			{
				if (CheckGun())
				{
					return lah.character_input.GetButtonUp(button);
				}
				return false;
			}
			return true;
		}

		public bool GetButtonUp(Keybind key)
		{
			return GetButtonUp(key, ignore_lah: false);
		}

		public bool GetButtonUp(Keybind key, bool ignore_lah)
		{
			if (!UpdatePlayerReference())
			{
				return false;
			}
			if (key == null)
			{
				return false;
			}
			if (key.key == null)
			{
				return GetButtonUp(key.fallback_action_id, ignore_lah);
			}
			if (key.key.IsRedirect())
			{
				return GetButtonUp(key.key.GetKey());
			}
			if ((ignore_lah || CheckGun()) && !ImGuiConsole.console_open)
			{
				return Input.GetKeyUp((KeyCode)key.key.GetKey());
			}
			return false;
		}
	}
	public enum PoseSpring
	{
		Aim,
		CameraZoom,
		InspectGun,
		SlidePull,
		Reload,
		PressCheck,
		InspectCylinder,
		AddRounds,
		EjectRounds
	}
	internal static class ReflectionManager
	{
		public static FieldRef<GunScript, bool> GS_disconnector_needs_reset { get; private set; }

		public static FieldRef<GunScript, float> GS_hammer_halfcocked { get; private set; }

		public static FieldRef<GunScript, float> GS_hammer_cocked_val { get; private set; }

		public static FieldRef<GunScript, int> GS_hammer_state { get; private set; }

		public static FieldRef<GunScript, LinearMover> GS_select_fire { get; private set; }

		public static FieldRef<GunScript, float> GS_yoke_open { get; private set; }

		public static FieldRef<GunScript, int> GS_current_firing_mode_index { get; private set; }

		public static FieldRef<GunScript, LinearMover> GS_firing_pin { get; private set; }

		public static FieldInfo RCS_gun_prefabs_all { get; private set; }

		public static FieldInfo RCS_magazine_prefabs_all { get; private set; }

		public static FieldRef<GunScript, bool> GS_slide_stop_locked { get; private set; }

		public static Type LAH_BulletInventory { get; private set; }

		public static FieldInfo LAH_BulletInventory_item { get; private set; }

		public static Dictionary<PoseSpring, FieldInfo> LAH_pose_springs { get; private set; }

		public static MethodInfo LAH_Get_Last_Bullet { get; private set; }

		public static FieldInfo LAH_bullet_shake_time { get; private set; }

		public static FieldInfo PH_bounds { get; private set; }

		public static FieldInfo UEB_persistent_calls { get; private set; }

		public static MethodInfo PCG_Clear { get; private set; }

		public static FieldInfo OP_pool_map { get; private set; }

		private static FieldRef<I_Type, F_Type> GetFieldDelegate<I_Type, F_Type>(string field_name)
		{
			try
			{
				return AccessTools.FieldRefAccess<I_Type, F_Type>(field_name);
			}
			catch (ArgumentException)
			{
				Debug.LogError((object)("Cannot find field \"" + field_name + "\", perhaps your Modding Kit plugin is out of date?"));
				throw new MissingFieldException("Cannot Find Field: - " + typeof(F_Type).ToString() + " " + typeof(I_Type).ToString() + "." + field_name);
			}
		}

		private static FieldInfo GetFieldInfo(Type type, string fieldName)
		{
			FieldInfo? field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				Debug.LogError((object)("Cannot find field \"" + fieldName + "\", perhaps your Modding Kit plugin is out of date?"));
				throw new MissingFieldException("Cannot Find Field: - " + type.ToString() + "." + fieldName);
			}
			return field;
		}

		private static MethodInfo GetMethodInfo(Type type, string methodName)
		{
			MethodInfo methodInfo = null;
			try
			{
				methodInfo = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			catch (AmbiguousMatchException)
			{
				Debug.LogError((object)("Cannot identify method \"" + methodName + "\", perhaps your Modding Kit plugin is out of date?"));
				throw new MissingFieldException("Wrong Method Parameters: - " + type.ToString() + "." + methodName);
			}
			if (methodInfo == null)
			{
				Debug.LogError((object)("Cannot find method \"" + methodName + "\", perhaps your Modding Kit plugin is out of date?"));
				throw new MissingFieldException("Cannot Find Method: - " + type.ToString() + "." + methodName);
			}
			return methodInfo;
		}

		private static MethodInfo GetMethodInfo(Type type, string methodName, params Type[] parameters)
		{
			MethodInfo methodInfo = null;
			try
			{
				methodInfo = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, parameters, null);
			}
			catch (AmbiguousMatchException)
			{
				Debug.LogError((object)("Cannot identify method \"" + methodName + "\", perhaps your Modding Kit plugin is out of date?"));
				throw new MissingFieldException("Wrong Method Parameters: - " + type.ToString() + "." + methodName);
			}
			if (methodInfo == null)
			{
				Debug.LogError((object)("Cannot find method \"" + methodName + "\", perhaps your Modding Kit plugin is out of date?"));
				throw new MissingFieldException("Cannot Find Method: - " + type.ToString() + "." + methodName);
			}
			return methodInfo;
		}

		internal static void Initialize()
		{
			GS_disconnector_needs_reset = GetFieldDelegate<GunScript, bool>("disconnector_needs_reset");
			GS_hammer_halfcocked = GetFieldDelegate<GunScript, float>("hammer_halfcocked");
			GS_hammer_cocked_val = GetFieldDelegate<GunScript, float>("hammer_cocked_val");
			GS_hammer_state = GetFieldDelegate<GunScript, int>("hammer_state");
			GS_slide_stop_locked = GetFieldDelegate<GunScript, bool>("slide_stop_locked");
			GS_select_fire = GetFieldDelegate<GunScript, LinearMover>("select_fire");
			GS_yoke_open = GetFieldDelegate<GunScript, float>("yoke_open");
			GS_current_firing_mode_index = GetFieldDelegate<GunScript, int>("current_firing_mode_index");
			GS_firing_pin = GetFieldDelegate<GunScript, LinearMover>("firing_pin");
			PH_bounds = GetFieldInfo(typeof(PegboardHanger), "bounds");
			RCS_gun_prefabs_all = GetFieldInfo(typeof(ReceiverCoreScript), "gun_prefabs_all");
			RCS_magazine_prefabs_all = GetFieldInfo(typeof(ReceiverCoreScript), "magazine_prefabs_all");
			UEB_persistent_calls = GetFieldInfo(typeof(UnityEventBase), "m_PersistentCalls");
			OP_pool_map = GetFieldInfo(typeof(ObjectPool), "pool_map");
			PCG_Clear = GetMethodInfo(UEB_persistent_calls.FieldType, "Clear");
			LAH_BulletInventory = typeof(LocalAimHandler).GetNestedTypes(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Single((Type t) => t.Name == "BulletInventory");
			LAH_BulletInventory_item = GetFieldInfo(LAH_BulletInventory, "item");
			LAH_pose_springs = new Dictionary<PoseSpring, FieldInfo>
			{
				{
					PoseSpring.Aim,
					GetFieldInfo(typeof(LocalAimHandler), "aim_spring")
				},
				{
					PoseSpring.CameraZoom,
					GetFieldInfo(typeof(LocalAimHandler), "camera_zoom_spring")
				},
				{
					PoseSpring.InspectGun,
					GetFieldInfo(typeof(LocalAimHandler), "inspect_gun_pose_spring")
				},
				{
					PoseSpring.SlidePull,
					GetFieldInfo(typeof(LocalAimHandler), "slide_pose_spring")
				},
				{
					PoseSpring.Reload,
					GetFieldInfo(typeof(LocalAimHandler), "reload_pose_spring")
				},
				{
					PoseSpring.PressCheck,
					GetFieldInfo(typeof(LocalAimHandler), "press_check_pose_spring")
				},
				{
					PoseSpring.InspectCylinder,
					GetFieldInfo(typeof(LocalAimHandler), "inspect_cylinder_pose_spring")
				},
				{
					PoseSpring.AddRounds,
					GetFieldInfo(typeof(LocalAimHandler), "add_rounds_pose_spring")
				},
				{
					PoseSpring.EjectRounds,
					GetFieldInfo(typeof(LocalAimHandler), "eject_rounds_pose_spring")
				}
			};
			LAH_Get_Last_Bullet = GetMethodInfo(typeof(LocalAimHandler), "GetLastMatchingLooseBullet");
			LAH_bullet_shake_time = GetFieldInfo(typeof(LocalAimHandler), "show_bullet_shake_time");
		}
	}
	public static class SettingsMenuManager
	{
		public class SettingsMenuEntry<T>
		{
			protected ConfigEntry<T> entry;

			public T default_value => (T)((ConfigEntryBase)entry).DefaultValue;

			public T value => entry.Value;

			public GameObject label { get; }

			public GameObject control { get; }

			internal SettingsMenuEntry(ConfigEntry<T> entry, GameObject label, GameObject control)
			{
				this.entry = entry;
				this.label = label;
				this.control = control;
			}
		}

		public class SettingsMenuButton
		{
			public GameObject label { get; }

			public Button button { get; }

			internal SettingsMenuButton(GameObject label, Button button)
			{
				this.label = label;
				this.button = button;
			}
		}

		private static readonly string left_column_menu_path = "ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Settings Menu/ScrollableContent Variant/Viewport/Content/Left Column/";

		private static readonly string right_column_menu_path = "ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Settings Menu/ScrollableContent Variant/Viewport/Content/Right Column/";

		private static GameObject m_keybinds_menu = null;

		private static GameObject m_keybinds_selection_field = null;

		private static GameObject m_label_prefab = null;

		private static GameObject m_button_setting_prefab = null;

		private static GameObject m_toggle_setting_prefab = null;

		private static GameObject m_dropdown_setting_prefab = null;

		private static GameObject m_slider_setting_prefab = null;

		private static GameObject keybinds_menu
		{
			get
			{
				if ((Object)(object)m_keybinds_menu == (Object)null)
				{
					m_keybinds_menu = GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group/New Keybinding Menu/ScrollableContent Variant/Viewport/Content");
				}
				return m_keybinds_menu;
			}
		}

		private static GameObject keybinds_selection_field
		{
			get
			{
				if ((Object)(object)m_keybinds_selection_field == (Object)null)
				{
					m_keybinds_selection_field = ((Component)keybinds_menu.GetComponentInChildren<KeybindingComponent>()).gameObject;
				}
				return m_keybinds_selection_field;
			}
		}

		private static GameObject label_prefab
		{
			get
			{
				if ((Object)(object)m_label_prefab != (Object)null)
				{
					return m_label_prefab;
				}
				m_label_prefab = Object.Instantiate<GameObject>(((Component)GameObject.Find(left_column_menu_path).GetComponentInChildren<CanvasRenderer>()).gameObject);
				return m_label_prefab;
			}
		}

		private static GameObject button_setting_prefab
		{
			get
			{
				if ((Object)(object)m_button_setting_prefab != (Object)null)
				{
					return m_button_setting_prefab;
				}
				m_button_setting_prefab = Object.Instantiate<GameObject>(((Component)((Component)GameObject.Find(right_column_menu_path).GetComponentInChildren<Button>()).transform.parent).gameObject);
				((Object)((Component)m_button_setting_prefab.GetComponentInChildren<Button>()).gameObject).name = "Button";
				((UnityEventBase)m_button_setting_prefab.GetComponentInChildren<Button>().onClick).RemoveAllListeners();
				return m_button_setting_prefab;
			}
		}

		private static GameObject toggle_setting_prefab
		{
			get
			{
				if ((Object)(object)m_toggle_setting_prefab != (Object)null)
				{
					return m_toggle_setting_prefab;
				}
				m_toggle_setting_prefab = Object.Instantiate<GameObject>(GameObject.Find(right_column_menu_path).GetComponentInChildren(Type.GetType("Receiver2.ToggleComponent, Wolfire.Receiver2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")).gameObject);
				return m_toggle_setting_prefab;
			}
		}

		private static GameObject dropdown_setting_prefab
		{
			get
			{
				if ((Object)(object)m_dropdown_setting_prefab != (Object)null)
				{
					return m_dropdown_setting_prefab;
				}
				m_dropdown_setting_prefab = Object.Instantiate<GameObject>(((Component)GameObject.Find(right_column_menu_path).GetComponentInChildren<DropdownComponent>()).gameObject);
				return m_dropdown_setting_prefab;
			}
		}

		private static GameObject slider_setting_prefab
		{
			get
			{
				if ((Object)(object)m_slider_setting_prefab != (Object)null)
				{
					return m_slider_setting_prefab;
				}
				m_slider_setting_prefab = Object.Instantiate<GameObject>(((Component)GameObject.Find(right_column_menu_path).GetComponentInChildren<SliderComponent>()).gameObject);
				return m_slider_setting_prefab;
			}
		}

		public static SettingsMenuButton CreateSettingsMenuButton(string name, string button_text, UnityAction callback, int index = -1)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(button_setting_prefab);
			((Object)val).name = name + " Container";
			Object.DestroyImmediate((Object)(object)((Component)val.transform.Find("Button/Text")).GetComponent<LocalizedTextMesh>());
			((TMP_Text)((Component)val.transform.Find("Button/Text")).GetComponent<TextMeshProUGUI>()).text = button_text;
			ButtonClickedEvent onClick = ((Component)val.transform.Find("Button")).GetComponent<Button>().onClick;
			((UnityEventBase)(object)onClick).RemovePersistentListeners();
			((UnityEvent)onClick).AddListener(callback);
			val.transform.SetParent(GameObject.Find(right_column_menu_path).transform);
			val.transform.localScale = Vector3.one;
			val.transform.localPosition = new Vector3(val.transform.localPosition.x, val.transform.localPosition.y, 0f);
			((Component)val.transform.Find("Button")).GetComponent<RectTransform>().sizeDelta = new Vector2(596f, 46f);
			if (index >= 0)
			{
				((Transform)val.GetComponent<RectTransform>()).SetSiblingIndex(index);
			}
			GameObject val2 = Object.Instantiate<GameObject>(label_prefab);
			((Object)val2).name = name;
			Object.DestroyImmediate((Object)(object)((Component)val2.transform.Find("Text")).GetComponent<LocalizedTextMesh>());
			((TMP_Text)((Component)val2.transform.Find("Text")).GetComponent<TextMeshProUGUI>()).text = name;
			val2.transform.SetParent(val.transform.parent.parent.Find("Left Column"));
			val2.transform.localScale = Vector3.one;
			val2.transform.localPosition = new Vector3(val2.transform.localPosition.x, val2.transform.localPosition.y, 0f);
			if (index >= 0)
			{
				((Transform)val2.GetComponent<RectTransform>()).SetSiblingIndex(index);
			}
			return new SettingsMenuButton(val2, ((Component)val.transform.Find("Button")).GetComponent<Button>());
		}

		public static SettingsMenuEntry<T> CreateSettingsMenuOption<T>(string name, ConfigEntry<T> config_entry, int index = -1)
		{
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_0688: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			if (config_entry == null)
			{
				throw new ArgumentNullException("SettingsMenuManager.CreateSettingsManuOption(): Config entry cannot be null");
			}
			GameObject control = null;
			switch (typeof(T).Name)
			{
			case "Boolean":
			{
				control = Object.Instantiate<GameObject>(toggle_setting_prefab);
				((Object)control).name = name + " Toggle";
				Component toggle_component = control.GetComponent(Type.GetType("Receiver2.ToggleComponent, Wolfire.Receiver2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"));
				UnityEvent<T> obj = ((object)toggle_component).GetType().GetField("OnChange").GetValue(toggle_component) as UnityEvent<T>;
				((UnityEventBase)(object)obj).RemovePersistentListeners();
				obj.AddListener((UnityAction<T>)delegate(T value)
				{
					config_entry.Value = value;
				});
				config_entry.SettingChanged += delegate
				{
					((object)toggle_component).GetType().GetField("value", BindingFlags.Instance | BindingFlags.Public).SetValue(toggle_component, config_entry.Value as bool?);
					((Component)control.transform.Find("Toggle")).GetComponent<Toggle>().isOn = (config_entry.Value as bool?).Value;
				};
				((Component)control.transform.Find("Toggle")).GetComponent<Toggle>().isOn = (config_entry.Value as bool?).Value;
				break;
			}
			case "String":
			{
				if (!(((ConfigEntryBase)config_entry).Description.AcceptableValues is AcceptableValueList<string>))
				{
					throw new ArgumentException("SettingsMenuManager.CreateSettingsManuOption(): Config entry must have an AcceptableValueList<string> in its description to use the dropdown");
				}
				List<string> value_list = ((AcceptableValueList<string>)(object)((ConfigEntryBase)config_entry).Description.AcceptableValues).AcceptableValues.ToList();
				control = Object.Instantiate<GameObject>(dropdown_setting_prefab);
				((Object)control).name = name + " Dropdown";
				DropdownComponent dropdown_component = control.GetComponent<DropdownComponent>();
				dropdown_component.SetOptions(value_list);
				IntEvent onChange2 = dropdown_component.OnChange;
				((UnityEventBase)(object)onChange2).RemovePersistentListeners();
				((UnityEvent<int>)(object)onChange2).AddListener((UnityAction<int>)delegate(int value)
				{
					config_entry.Value = (T)Convert.ChangeType(((AcceptableValueList<string>)(object)((ConfigEntryBase)config_entry).Description.AcceptableValues).AcceptableValues[value], typeof(T));
				});
				config_entry.SettingChanged += delegate
				{
					dropdown_component.Select(value_list.IndexOf((string)Convert.ChangeType(config_entry.Value, typeof(string))));
				};
				dropdown_component.Select(value_list.IndexOf((string)Convert.ChangeType(config_entry.Value, typeof(string))));
				break;
			}
			case "Int32":
			case "Int64":
			case "Double":
			case "Single":
			{
				if (!(((ConfigEntryBase)config_entry).Description.AcceptableValues is AcceptableValueRange<float>))
				{
					throw new ArgumentException("SettingsMenuManager.CreateSettingsManuOption(): Config entry must have an AcceptableValueRange<float> in its description to use the slider");
				}
				AcceptableValueRange<float> val = (AcceptableValueRange<float>)(object)((ConfigEntryBase)config_entry).Description.AcceptableValues;
				control = Object.Instantiate<GameObject>(slider_setting_prefab);
				((Object)control).name = name + " Slider";
				SliderComponent slider_component = control.GetComponent<SliderComponent>();
				if (((ConfigEntryBase)config_entry).Description.Tags.Contains("format: percent"))
				{
					slider_component.format = "P0";
				}
				else
				{
					string text = (string)((ConfigEntryBase)config_entry).Description.Tags.FirstOrDefault((object tag) => tag is string && Regex.IsMatch((string)tag, "format: [A-z0-9]{1,2}$"));
					if (text != null)
					{
						slider_component.format = text.Substring(8);
					}
					else
					{
						slider_component.format = "0";
					}
				}
				slider_component.format = (((ConfigEntryBase)config_entry).Description.Tags.Contains("format: percent") ? "P0" : "0");
				slider_component.slider.minValue = val.MinValue;
				slider_component.slider.maxValue = val.MaxValue;
				FloatEvent onChange = slider_component.OnChange;
				((UnityEventBase)(object)onChange).RemovePersistentListeners();
				((UnityEvent<float>)(object)onChange).AddListener((UnityAction<float>)delegate(float value)
				{
					config_entry.Value = (T)Convert.ChangeType(value, typeof(T));
				});
				if (typeof(T).Name.StartsWith("Int"))
				{
					config_entry.SettingChanged += delegate
					{
						slider_component.Value = Mathf.Floor((float)Convert.ChangeType(config_entry.Value, typeof(float)));
					};
					slider_component.Value = Mathf.Floor((float)Convert.ChangeType(config_entry.Value, typeof(float)));
				}
				else
				{
					config_entry.SettingChanged += delegate
					{
						slider_component.Value = (float)Convert.ChangeType(config_entry.Value, typeof(float));
					};
					slider_component.Value = (float)Convert.ChangeType(config_entry.Value, typeof(float));
				}
				break;
			}
			default:
				Debug.LogError((object)("Control of type " + typeof(T).Name + " is not supported"));
				return null;
			}
			control.transform.SetParent(GameObject.Find(right_column_menu_path).transform);
			control.transform.localScale = Vector3.one;
			control.transform.localPosition = new Vector3(control.transform.localPosition.x, control.transform.localPosition.y, 0f);
			if (index >= 0)
			{
				((Transform)control.GetComponent<RectTransform>()).SetSiblingIndex(index);
			}
			GameObject val2 = Object.Instantiate<GameObject>(label_prefab);
			((Object)val2).name = name;
			Object.DestroyImmediate((Object)(object)((Component)val2.transform.Find("Text")).GetComponent<LocalizedTextMesh>());
			((TMP_Text)((Component)val2.transform.Find("Text")).GetComponent<TextMeshProUGUI>()).text = name;
			val2.transform.SetParent(control.transform.parent.parent.Find("Left Column"));
			val2.transform.localScale = Vector3.one;
			val2.transform.localPosition = new Vector3(val2.transform.localPosition.x, val2.transform.localPosition.y, 0f);
			if (index >= 0)
			{
				((Transform)val2.GetComponent<RectTransform>()).SetSiblingIndex(index);
			}
			return new SettingsMenuEntry<T>(config_entry, val2, control);
		}

		public static GameObject AddKeybindsCategory(string category_name, float scale)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(((Component)keybinds_menu.transform.Find("Automatics Category")).gameObject, keybinds_menu.transform);
			((TMP_Text)((Component)obj.transform.Find("Title")).GetComponent<TextMeshProUGUI>()).text = category_name;
			obj.transform.localScale = new Vector3(scale, scale, scale);
			((Object)obj).name = category_name + " Category";
			((Transform)obj.GetComponent<RectTransform>()).SetAsLastSibling();
			Object.DestroyImmediate((Object)(object)((Component)obj.transform.Find("Title")).GetComponent<LocalizedTextMesh>());
			return obj;
		}

		public static ModKeybindComponent AddKeybindField(Keybind keybind)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(keybinds_selection_field, keybinds_menu.transform);
			((Object)val).name = keybind.name;
			Object.DestroyImmediate((Object)(object)val.GetComponent<KeybindingComponent>());
			((TMP_Text)((Component)val.transform.Find("Text")).GetComponent<TextMeshProUGUI>()).text = keybind.name;
			Object.DestroyImmediate((Object)(object)((Component)val.transform.Find("Second Binding")).gameObject);
			GameObject obj = Object.Instantiate<GameObject>(dropdown_setting_prefab, val.transform);
			((Transform)obj.GetComponent<RectTransform>()).SetSiblingIndex(2);
			((Object)obj).name = "Redirect Dropdown";
			DropdownComponent component = obj.GetComponent<DropdownComponent>();
			List<string> list = KeybindsManager.rewired_actions.Keys.ToList();
			component.SetOptions(list);
			((UnityEventBase)(object)component.OnChange).RemovePersistentListeners();
			if (keybind.key != null && keybind.key.IsRedirect())
			{
				component.Select(list.FindIndex((string action_name) => KeybindsManager.rewired_actions[action_name] == keybind.key.GetKey()));
			}
			Transform obj2 = ((Transform)obj.GetComponent<RectTransform>()).Find("Dropdown");
			((RectTransform)((obj2 is RectTransform) ? obj2 : null)).anchoredPosition = new Vector2(3f, 0f);
			Transform obj3 = ((Transform)obj.GetComponent<RectTransform>()).Find("Dropdown");
			((RectTransform)((obj3 is RectTransform) ? obj3 : null)).sizeDelta = new Vector2(9f, 46f);
			Button component2 = ((Component)val.transform.Find("First Binding/Button")).GetComponent<Button>();
			RectTransform component3 = ((Component)component2).GetComponent<RectTransform>();
			component3.anchoredPosition -= new Vector2(4f, 0f);
			((TMP_Text)((Component)((Component)component2).transform.Find("Text")).GetComponent<TextMeshProUGUI>()).text = "";
			((UnityEventBase)(object)component2.onClick).RemovePersistentListeners();
			Button component4 = ((Component)val.transform.Find("Clear button container/New red button")).GetComponent<Button>();
			((UnityEventBase)(object)component4.onClick).RemovePersistentListeners();
			ModKeybindComponent modKeybindComponent = val.AddComponent<ModKeybindComponent>();
			modKeybindComponent.keybind = keybind;
			modKeybindComponent.keyboard_binding = component2;
			modKeybindComponent.keyboard_binding_text = ((Component)((Component)component2).transform.Find("Text")).GetComponent<TextMeshProUGUI>();
			modKeybindComponent.redirect_binding = component;
			modKeybindComponent.clear_button = component4;
			return modKeybindComponent;
		}

		internal static KeybindContainer GenerateKeybindMenu(ModGunScript gun)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gun == (Object)null || string.IsNullOrEmpty(((GunScript)gun).weapon_group_name))
			{
				return null;
			}
			if (KeybindsManager.TryGetKeybinds(((GunScript)gun).weapon_group_name, out var keybind_container))
			{
				return keybind_container;
			}
			if ((Object)(object)KeybindsManager.keybinds_menu_banner == (Object)null)
			{
				KeybindsManager.keybinds_menu_banner = AddKeybindsCategory("Modded Gun Keybinds", 1f);
			}
			KeybindContainer keybindContainer = new KeybindContainer
			{
				gun_name = ((GunScript)gun).weapon_group_name,
				category_object = AddKeybindsCategory(gun.GetGunTactics().title, 0.75f)
			};
			List<Keybind> list = new List<Keybind>();
			foreach (FieldInfo runtimeField in ((object)gun).GetType().GetRuntimeFields())
			{
				if (!(runtimeField.FieldType != typeof(Keybind)))
				{
					if (!runtimeField.IsStatic)
					{
						Debug.LogError((object)("Field " + ((object)gun).GetType().Name + "." + runtimeField.Name + " isn't static. Keybind fields have to be static to work"));
					}
					Keybind keybind = runtimeField.GetValue(gun) as Keybind;
					keybind.gun_name = ((GunScript)gun).weapon_group_name;
					string text = ModdingKitConfig.BindKeybindConfig(keybind);
					KeyCode result2;
					if (int.TryParse(text, out var result))
					{
						keybind.key = new Keybind.KeyRedirect(result);
					}
					else if (Enum.TryParse<KeyCode>(text, ignoreCase: true, out result2))
					{
						keybind.key = new Keybind.KeyboardKey(result2);
					}
					else
					{
						keybind.key = new Keybind.KeyRedirect(keybind.fallback_action_id);
					}
					list.Add(keybind);
				}
			}
			keybindContainer.keybind_components = list.Select(AddKeybindField).ToArray();
			keybindContainer.SetActive(active: false);
			KeybindsManager.custom_keybinds.Add(keybindContainer);
			if ((Object)(object)KeybindsManager.keybinds_menu_space == (Object)null)
			{
				KeybindsManager.keybinds_menu_space = AddKeybindsCategory("", 1f);
				((Object)KeybindsManager.keybinds_menu_space).name = "Keybinds Space";
				((HorizontalOrVerticalLayoutGroup)KeybindsManager.keybinds_menu_space.GetComponent<HorizontalLayoutGroup>()).childControlHeight = true;
				KeybindsManager.keybinds_menu_space.GetComponentInChildren<LayoutElement>().preferredHeight = 200f;
			}
			((Transform)KeybindsManager.keybinds_menu_space.GetComponent<RectTransform>()).SetAsLastSibling();
			return keybindContainer;
		}

		internal static void ShowKeyBindDialog(string text)
		{
			GameObject val = GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group");
			((Component)val.transform.Find("New Keybinding Menu")).gameObject.SetActive(false);
			((Component)val.transform.Find("Bind Key Dialog")).gameObject.SetActive(true);
			((TMP_Text)((Component)val.transform.Find("Bind Key Dialog")).GetComponent<BindKeyDialogScript>().title_text).text = Locale.FormatUIString((LocaleUIString)221, new object[1] { text });
			((TMP_Text)((Component)val.transform.Find("Bind Key Dialog")).GetComponent<BindKeyDialogScript>().main_text).text = Locale.FormatUIString((LocaleUIString)220, new object[1] { text });
		}

		internal static void HideKeyBindDialog()
		{
			GameObject obj = GameObject.Find("ReceiverCore/Menus/Overlay Menu Canvas/Aspect Ratio Fitter/New Pause Menu/Backdrop1/Sub-Menu Layout Group");
			((Component)obj.transform.Find("New Keybinding Menu")).gameObject.SetActive(true);
			((Component)obj.transform.Find("Bind Key Dialog")).gameObject.SetActive(false);
		}
	}
	public class TransformDebugScope : IDisposable
	{
		private static bool enabled;

		public static string last_target { get; private set; }

		[HarmonyPatch(typeof(Transform), "Find")]
		[HarmonyPostfix]
		private static void PatchTransformFind(string n, Transform __result)
		{
			if (enabled && (Object)(object)__result == (Object)null)
			{
				last_target = n;
			}
		}

		public TransformDebugScope()
		{
			last_target = "";
			enabled = true;
		}

		public void Dispose()
		{
			enabled = false;
		}
	}
	[RequireComponent(typeof(InventorySlot))]
	public class TubeMagazineScript : MonoBehaviour
	{
		public Stack<ShellCasingScript> rounds = new Stack<ShellCasingScript>();

		public GameObject round_prefab;

		public Transform follower;

		public Transform first_round_position;

		public int capacity;

		public string insert_round_animation_path;

		public string remove_round_animation_path;

		public float cartridge_length = -1f;

		public float follower_offset;

		private GunScript gun;

		private Vector3 orig_follower_position;

		private bool removing_round;

		private float round_insert_time;

		private float last_round_inserted_time = float.NegativeInfinity;

		private float round_remove_time;

		private float last_round_removed_time = float.NegativeInfinity;

		public bool is_valid { get; private set; }

		public InventorySlot slot => ((Component)this).GetComponent<InventorySlot>();

		public bool busy
		{
			get
			{
				if (!(Time.time < last_round_inserted_time + round_insert_time + Time.deltaTime))
				{
					return removing_round;
				}
				return true;
			}
		}

		public bool ready_to_remove_round
		{
			get
			{
				if (removing_round)
				{
					return Time.time > last_round_removed_time + round_remove_time + Time.deltaTime;
				}
				return false;
			}
		}

		public int round_count
		{
			get
			{
				return rounds.Count;
			}
			set
			{
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				if (!is_valid || value == rounds.Count)
				{
					return;
				}
				foreach (ShellCasingScript round in rounds)
				{
					Object.Destroy((Object)(object)((Component)round).gameObject);
				}
				removing_round = false;
				last_round_inserted_time = float.NegativeInfinity;
				last_round_removed_time = float.NegativeInfinity;
				rounds.Clear();
				for (int i = 0; i < value; i++)
				{
					ShellCasingScript component = Object.Instantiate<GameObject>(round_prefab).GetComponent<ShellCasingScript>();
					((InventoryItem)component).Move(slot);
					rounds.Push(component);
					((Component)component).transform.SetParent(first_round_position);
					((Component)component).transform.localPosition = Vector3.zero;
					((Component)component).transform.localRotation = Quaternion.identity;
					if ((Object)(object)gun != (Object)null && !string.IsNullOrWhiteSpace(insert_round_animation_path))
					{
						gun.ApplyTransform(insert_round_animation_path, float.PositiveInfinity, ((Component)component).transform);
					}
					else
					{
						((Component)component).transform.localPosition = Vector3.zero;
					}
					Transform transform = ((Component)component).transform;
					transform.localPosition += Vector3.forward * cartridge_length * (float)i;
				}
			}
		}

		public float GetAnimationSpeed()
		{
			ReceiverCoreScript val = default(ReceiverCoreScript);
			if (ReceiverCoreScript.TryGetInstance(ref val))
			{
				return ((PlayerStats)(ref val.player_stats)).animation_speed;
			}
			return 1f;
		}

		private float GetAnimationTime(string path)
		{
			if ((Object)(object)gun == (Object)null)
			{
				return 0f;
			}
			float num = 0f;
			AnimIndex[] indices = gun.gun_animations.indices;
			foreach (AnimIndex val in indices)
			{
				if (val.path.Substring(0, val.path.LastIndexOf("/") - 1) == path)
				{
					num = Mathf.Max(num, gun.gun_animations.keyframes[val.index + (val.length - 1) * 2] - gun.gun_animations.keyframes[val.index]);
				}
			}
			return num;
		}

		public void Awake()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)first_round_position == (Object)null || (Object)(object)round_prefab == (Object)null || (Object)(object)follower == (Object)null)
			{
				Debug.LogError((object)"Some crucial fields were not populated, fix it");
				is_valid = false;
				return;
			}
			if ((Object)(object)round_prefab.GetComponent<ShellCasingScript>() == (Object)null)
			{
				Debug.LogError((object)"Supplied round_prefab doesn't have a ShellCasingScript component, fix it");
				is_valid = false;
				return;
			}
			gun = ((Component)this).GetComponentInParent<GunScript>();
			if ((Object)(object)gun == (Object)null)
			{
				Debug.LogWarning((object)("Magazine " + ((Object)this).name + " isn't a child of a GunScript object, animating rounds will be disabled"));
			}
			orig_follower_position = follower.localPosition;
			if (cartridge_length < 0f)
			{
				Collider component = round_prefab.GetComponent<Collider>();
				if ((Object)(object)component == (Object)null)
				{
					Debug.LogError((object)("Cartridge" + ((InventoryItem)round_prefab.GetComponent<ShellCasingScript>()).InternalName + " doesn't have a Collider component. Fix it"));
					is_valid = false;
					return;
				}
				Vector3 val = component.ClosestPoint(((Component)component).transform.position + ((Component)component).transform.forward);
				Vector3 val2 = component.ClosestPoint(((Component)component).transform.position - ((Component)component).transform.forward);
				cartridge_length = Vector3.Distance(val2, val);
			}
			if ((Object)(object)gun != (Object)null && !string.IsNullOrWhiteSpace(insert_round_animation_path))
			{
				round_insert_time = GetAnimationTime(insert_round_animation_path);
			}
			else
			{
				round_insert_time = 1f;
			}
			if ((Object)(object)gun != (Object)null && !string.IsNullOrWhiteSpace(remove_round_animation_path))
			{
				round_remove_time = GetAnimationTime(remove_round_animation_path);
			}
			else
			{
				round_remove_time = 1f;
			}
			is_valid = true;
		}

		private void UpdateRoundPositions()
		{
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			ShellCasingScript[] array = rounds.ToArray();
			int num = 0;
			float num2 = 0f;
			if (last_round_inserted_time + round_insert_time * GetAnimationSpeed() >= Time.time - Time.deltaTime)
			{
				float num3 = Time.time - last_round_inserted_time;
				if ((Object)(object)gun != (Object)null && !string.IsNullOrWhiteSpace(insert_round_animation_path))
				{
					ShellCasingScript val = rounds.Peek();
					gun.ApplyTransform(insert_round_animation_path, num3, ((Component)val).transform);
					num2 = Mathf.Clamp(Vector3.Dot(((Component)val).transform.localPosition, Vector3.forward), 0f - cartridge_length, float.PositiveInfinity);
					num = 1;
				}
				else
				{
					num2 = cartridge_length * Mathf.Clamp01(num3 / round_insert_time) - cartridge_length;
				}
			}
			else if (removing_round)
			{
				float num4 = Time.time - last_round_removed_time;
				if ((Object)(object)gun != (Object)null && !string.IsNullOrWhiteSpace(remove_round_animation_path))
				{
					ShellCasingScript val2 = rounds.Peek();
					gun.ApplyTransform(remove_round_animation_path, num4, ((Component)val2).transform);
					num2 = Mathf.Clamp(Vector3.Dot(((Component)val2).transform.localPosition, Vector3.forward), 0f - cartridge_length, float.PositiveInfinity);
					num = 1;
				}
				else
				{
					num2 = (0f - cartridge_length) * Mathf.Clamp01(num4 / round_insert_time);
				}
			}
			Vector3 val3 = first_round_position.position + ((Component)this).transform.forward * num2;
			val3 += ((Component)this).transform.forward * cartridge_length * (float)num;
			for (int i = num; i < array.Length; i++)
			{
				((Component)array[i]).transform.position = val3;
				val3 += ((Component)this).transform.forward * cartridge_length;
			}
			follower.position = val3 + ((Component)this).transform.forward * follower_offset;
		}

		private void Update()
		{
			UpdateRoundPositions();
		}

		public void InsertRound(ShellCasingScript round)
		{
			TryInsertRound(round);
		}

		public bool TryInsertRound(ShellCasingScript round)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (!is_valid || rounds.Count >= capacity || busy)
			{
				return false;
			}
			LocalAimHandler val = default(LocalAimHandler);
			if (LocalAimHandler.TryGetInstance(ref val))
			{
				val.MoveInventoryItem((InventoryItem)(object)round, slot);
			}
			else
			{
				((InventoryItem)round).Move(slot);
			}
			rounds.Push(round);
			((Component)round).transform.SetParent(first_round_position);
			((Component)round).transform.localScale = Vector3.one;
			((Component)round).transform.localPosition = Vector3.zero;
			((Component)round).transform.localRotation = Quaternion.identity;
			((Component)round).transform.localScale = Vector3.one;
			if ((Object)(object)gun != (Object)null && !string.IsNullOrWhiteSpace(insert_round_animation_path))
			{
				gun.ApplyTransform(insert_round_animation_path, 0f, ((Component)round).transform);
			}
			else
			{
				((Component)round).transform.localPosition = -Vector3.forward * cartridge_length;
			}
			last_round_inserted_time = Time.time;
			UpdateRoundPositions();
			return true;
		}

		public bool StartRemoveRound()
		{
			if (!is_valid || busy)
			{
				return false;
			}
			if (rounds.Count > 0)
			{
				last_round_removed_time = Time.time;
				removing_round = true;
				return true;
			}
			return false;
		}

		public ShellCasingScript RetrieveRound()
		{
			if (!is_valid || !ready_to_remove_round)
			{
				return null;
			}
			removing_round = false;
			return rounds.Pop();
		}

		public bool TryRetrieveRound(out ShellCasingScript round)
		{
			round = RetrieveRound();
			return (Object)(object)round != (Object)null;
		}
	}
}
namespace Receiver2ModdingKit.Thunderstore
{
	internal class ModSpec
	{
		private static readonly string[] ignored_files = new string[2] { "manifest\\.json", "modinfo\\.json" };

		public string Name { get; }

		public Sprite icon { get; }

		public bool Installed { get; private set; }

		public DirectoryInfo BaseDir { get; private set; }

		public JSONNode manifest { get; }

		public List<FileInfo> GlobalBaseConfigs { get; } = new List<FileInfo>();

		public List<FileInfo> Campaigns { get; } = new List<FileInfo>();

		public List<FileInfo> Loadouts { get; } = new List<FileInfo>();

		public List<FileInfo> WorldGenerationsConfigs { get; } = new List<FileInfo>();

		public List<FileInfo> Assets { get; } = new List<FileInfo>();

		public List<FileInfo> TapeSubtitles { get; } = new List<FileInfo>();

		public List<FileInfo> Tapes { get; } = new List<FileInfo>();

		private static bool CheckGBCFile(JSONNode json)
		{
			try
			{
				GlobalBaseConfiguration.Deserialize(json);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool CheckRPCFile(JSONNode json)
		{
			return json.HasKey("ranks");
		}

		private static bool CheckWGCFile(JSONNode json)
		{
			return json.HasKey("configuration_name");
		}

		private static bool CheckLoadoutFile(JSONNode json)
		{
			if (!json.HasKey("content"))
			{
				return false;
			}
			try
			{
				PlayerLoadout.Deserialize(json["content"]);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private ModSpec(string modName, JSONNode manifest, Sprite icon)
		{
			Name = modName;
			this.manifest = manifest;
			this.icon = icon;
		}

		public void InstallCampaign()
		{
			if (Installed)
			{
				return;
			}
			DirectoryInfo dir = new DirectoryInfo(Application.persistentDataPath);
			if (!dir.TryGetChild("GlobalBaseConfiguration", out var child_directory))
			{
				child_directory.Create();
			}
			if (!dir.TryGetChild("RankingProgressionCampaigns", out var child_directory2))
			{
				child_directory2.Create();
			}
			if (!dir.TryGetChild("PlayerLoadouts", out var child_directory3))
			{
				child_directory3.Create();
			}
			if (!dir.TryGetChild("WorldGenerationConfigurations", out var child_directory4))
			{
				child_directory4.Create();
			}
			for (int i = 0; i < GlobalBaseConfigs.Count; i++)
			{
				FileInfo fileInfo = GlobalBaseConfigs[i];
				try
				{
					string text = Path.Combine(child_directory.FullName, fileInfo.Name);
					if (File.Exists(text))
					{
						if (File.Exists(text + ".standaloneold"))
						{
							File.Delete(text + ".standaloneold");
						}
						File.Move(text, text + ".standaloneold");
					}
					GlobalBaseConfigs[i] = fileInfo.CopyTo(text, overwrite: true);
				}
				catch (Exception ex)
				{
					Debug.LogError((object)string.Concat("Couldn't copy Global Base Configuration file ", fileInfo.Name, " from ", BaseDir, " to ", child_directory.FullName));
					Debug.LogException(ex);
				}
			}
			for (int j = 0; j < Campaigns.Count; j++)
			{
				FileInfo fileInfo2 = Campaigns[j];
				try
				{
					string text2 = Path.Combine(child_directory2.FullName, fileInfo2.Name);
					if (File.Exists(text2))
					{
						if (File.Exists(text2 + ".standaloneold"))
						{
							File.Delete(text2 + ".standaloneold");
						}
						File.Move(text2, text2 + ".standaloneold");
					}
					Campaigns[j] = fileInfo2.CopyTo(text2, overwrite: true);
				}
				catch (Exception ex2)
				{
					Debug.LogError((object)string.Concat("Couldn't copy Ranking Progression Campaign file ", fileInfo2.Name, " from ", BaseDir, " to ", child_directory2.FullName));
					Debug.LogException(ex2);
				}
			}
			for (int k = 0; k < Loadouts.Count; k++)
			{
				FileInfo fileInfo3 = Loadouts[k];
				try
				{
					string text3 = Path.Combine(child_directory3.FullName, fileInfo3.Name);
					if (File.Exists(text3))
					{
						if (File.Exists(text3 + ".standaloneold"))
						{
							File.Delete(text3 + ".standaloneold");
						}
						File.Move(text3, text3 + ".standaloneold");
					}
					Loadouts[k] = fileInfo3.CopyTo(text3, overwrite: true);
				}
				catch (Exception ex3)
				{
					Debug.LogError((object)string.Concat("Couldn't copy Player Loadout file ", fileInfo3.Name, " from ", BaseDir, " to ", child_directory3.FullName));
					Debug.LogException(ex3);
				}
			}
			for (int l = 0; l < WorldGenerationsConfigs.Count; l++)
			{
				FileInfo fileInfo4 = WorldGenerationsConfigs[l];
				try
				{
					string text4 = Path.Combine(child_directory4.FullName, fileInfo4.Name);
					if (File.Exists(text4))
					{
						if (File.Exists(text4 + ".standaloneold"))
						{
							File.Delete(text4 + ".standaloneold");
						}
						File.Move(text4, text4 + ".standaloneold");
					}
					WorldGenerationsConfigs[l] = fileInfo4.CopyTo(text4, overwrite: true);
				}
				catch (Exception ex4)
				{
					Debug.LogError((object)string.Concat("Couldn't copy World Generation Configuration file ", fileInfo4.Name, " from ", BaseDir, " to ", child_directory4.FullName));
					Debug.LogException(ex4);
				}
			}
			Installed = true;
		}

		public void InstallGuns()
		{
			ReceiverCoreScript.Instance().LoadModGun(BaseDir.FullName, true);
		}

		public void InstallTapes(TapeManager instance)
		{
			instance.LoadModTape(BaseDir.FullName, true);
			foreach (FileInfo tapeSubtitle in TapeSubtitles)
			{
				ModTapeManager.RegisterSubtitles(tapeSubtitle.Name.Replace(".srt", ""), tapeSubtitle);
			}
		}

		public void InstallTiles(ModulePrefabsList instance)
		{
			instance.LoadModTile(BaseDir.FullName, true);
		}

		public void InstallGameModes()
		{
			((MonoBehaviour)ModGameModeManager.Instance).StartCoroutine(ModGameModeManager.Instance.FindGamemodes(BaseDir.FullName));
		}

		public void UninstallCampaign()
		{
			if (!Installed)
			{
				return;
			}
			foreach (FileInfo globalBaseConfig in GlobalBaseConfigs)
			{
				globalBaseConfig.Delete();
			}
			foreach (FileInfo campaign in Campaigns)
			{
				campaign.Delete();
			}
			foreach (FileInfo loadout in Loadouts)
			{
				loadout.Delete();
			}
			foreach (FileInfo worldGenerationsConfig in WorldGenerationsConfigs)
			{
				worldGenerationsConfig.Delete();
			}
		}

		public static ModSpec Create(DirectoryInfo mod_dir)
		{
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			FileInfo fileInfo = new FileInfo(Path.Combine(mod_dir.FullName, "manifest.json"));
			if (!fileInfo.Exists)
			{
				return null;
			}
			JSONNode val = ReceiverCoreScript.LoadJSONFile(fileInfo.FullName);
			Sprite val2 = null;
			if (File.Exists(Path.Combine(mod_dir.FullName, "icon.png")))
			{
				using FileStream fileStream = File.OpenRead(Path.Combine(mod_dir.FullName, "icon.png"));
				byte[] array = new byte[fileStream.Length];
				fileStream.Read(array, 0, (int)fileStream.Length);
				Texture2D val3 = new Texture2D(256, 256);
				ImageConversion.LoadImage(val3, array);
				val2 = Sprite.Create(val3, new Rect(0f, 0f, 256f, 256f), new Vector2(0.5f, 0.5f));
			}
			ModSpec modSpec = new ModSpec(mod_dir.Name, val, val2)
			{
				BaseDir = mod_dir
			};
			foreach (FileInfo mod_file in mod_dir.EnumerateFiles())
			{
				if (ignored_files.Any((string filename) => Regex.IsMatch(mod_file.Name, filename)))
				{
					continue;
				}
				switch (mod_file.Extension)
				{
				case ".json":
				{
					JSONNode json;
					try
					{
						json = ReceiverCoreScript.LoadJSONFile(mod_file.FullName);
					}
					catch (Exception ex)
					{
						Debug.Log((object)string.Concat("File ", mod_file, " couldn't be loaded"));
						Debug.LogError((object)ex);
						break;
					}
					if (CheckGBCFile(json))
					{
						modSpec.GlobalBaseConfigs.Add(mod_file);
					}
					else if (CheckRPCFile(json))
					{
						modSpec.Campaigns.Add(mod_file);
					}
					else if (CheckLoadoutFile(json))
					{
						modSpec.Loadouts.Add(mod_file);
					}
					else if (CheckWGCFile(json))
					{
						modSpec.WorldGenerationsConfigs.Add(mod_file);
					}
					break;
				}
				case ".ogg":
				case ".mp3":
				case ".wav":
					modSpec.Tapes.Add(mod_file);
					break;
				case ".srt":
					modSpec.TapeSubtitles.Add(mod_file);
					break;
				}
				if (mod_file.Extension == "." + ((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower())
				{
					modSpec.Assets.Add(mod_file);
				}
			}
			return modSpec;
		}
	}
	internal static class Thunderstore
	{
		private static bool initialized;

		private static bool m_launched_with_r2mm;

		private static DirectoryInfo m_r2mm_plugin_dir = null;

		private static List<ModSpec> installed_mods = new List<ModSpec>();

		public static bool LaunchedWithR2ModMan
		{
			get
			{
				if (!initialized)
				{
					Initialize();
				}
				return m_launched_with_r2mm;
			}
		}

		public static DirectoryInfo R2ModManPluginDir
		{
			get
			{
				if (!initialized)
				{
					Initialize();
				}
				return m_r2mm_plugin_dir;
			}
		}

		public static void Initialize()
		{
			string text = string.Join(" ", Environment.GetCommandLineArgs());
			if (text.Length <= 1)
			{
				return;
			}
			if (text.Contains("--doorstop-enable true") || text.Contains("--doorstop-enabled true"))
			{
				m_launched_with_r2mm = true;
				m_r2mm_plugin_dir = new DirectoryInfo(Paths.PluginPath);
				DirectoryInfo[] directories = m_r2mm_plugin_dir.GetDirectories();
				for (int i = 0; i < directories.Length; i++)
				{
					ModSpec modSpec = ModSpec.Create(directories[i]);
					if (modSpec != null)
					{
						installed_mods.Add(modSpec);
					}
				}
				initialized = true;
			}
			else
			{
				m_launched_with_r2mm = false;
				initialized = true;
			}
		}

		public static void InstallMods()
		{
			if (!LaunchedWithR2ModMan)
			{
				return;
			}
			foreach (ModSpec installed_mod in installed_mods)
			{
				installed_mod.InstallCampaign();
			}
		}

		public static void InstallGuns()
		{
			if (!LaunchedWithR2ModMan)
			{
				return;
			}
			foreach (ModSpec installed_mod in installed_mods)
			{
				try
				{
					installed_mod.InstallGuns();
				}
				catch (NullReferenceException)
				{
				}
			}
		}

		public static void InstallTapes(TapeManager instance)
		{
			if (!LaunchedWithR2ModMan)
			{
				return;
			}
			foreach (ModSpec installed_mod in installed_mods)
			{
				try
				{
					installed_mod.InstallTapes(instance);
				}
				catch (NullReferenceException)
				{
				}
			}
		}

		public static void InstallTiles(ModulePrefabsList instance)
		{
			if (!LaunchedWithR2ModMan)
			{
				return;
			}
			foreach (ModSpec installed_mod in installed_mods)
			{
				try
				{
					installed_mod.InstallTiles(instance);
				}
				catch (NullReferenceException)
				{
				}
			}
		}

		public static void InstallGameModes()
		{
			if (!LaunchedWithR2ModMan)
			{
				return;
			}
			foreach (ModSpec installed_mod in installed_mods)
			{
				try
				{
					installed_mod.InstallGameModes();
				}
				catch (NullReferenceException)
				{
				}
			}
		}

		public static void CleanupMods()
		{
			if (LaunchedWithR2ModMan)
			{
				foreach (ModSpec installed_mod in installed_mods)
				{
					installed_mod.UninstallCampaign();
				}
			}
			DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(Application.persistentDataPath, "GlobalBaseConfiguration"));
			FileInfo[] files;
			if (directoryInfo.Exists)
			{
				files = directoryInfo.GetFiles("*.json.standaloneold");
				foreach (FileInfo fileInfo in files)
				{
					try
					{
						fileInfo.MoveTo(Path.ChangeExtension(fileInfo.FullName, fileInfo.FullName.Replace(".standaloneold", "")));
					}
					catch
					{
					}
				}
			}
			DirectoryInfo directoryInfo2 = new DirectoryInfo(Path.Combine(Application.persistentDataPath, "PlayerLoadouts"));
			if (directoryInfo2.Exists)
			{
				files = directoryInfo2.GetFiles("*.json.standaloneold");
				foreach (FileInfo fileInfo2 in files)
				{
					try
					{
						fileInfo2.MoveTo(Path.ChangeExtension(fileInfo2.FullName, fileInfo2.FullName.Replace(".standaloneold", "")));
					}
					catch
					{
					}
				}
			}
			DirectoryInfo directoryInfo3 = new DirectoryInfo(Path.Combine(Application.persistentDataPath, "RankingProgressionCampaigns"));
			if (directoryInfo3.Exists)
			{
				files = directoryInfo3.GetFiles("*.json.standaloneold");
				foreach (FileInfo fileInfo3 in files)
				{
					try
					{
						fileInfo3.MoveTo(Path.ChangeExtension(fileInfo3.FullName, fileInfo3.FullName.Replace(".standaloneold", "")));
					}
					catch
					{
					}
				}
			}
			if (!new DirectoryInfo(Path.Combine(Application.persistentDataPath, "WorldGenerationConfigurations")).Exists)
			{
				return;
			}
			files = directoryInfo.GetFiles("*.json.standaloneold");
			foreach (FileInfo fileInfo4 in files)
			{
				try
				{
					fileInfo4.MoveTo(Path.ChangeExtension(fileInfo4.FullName, fileInfo4.FullName.Replace(".standaloneold", "")));
				}
				catch
				{
				}
			}
		}
	}
}
namespace Receiver2ModdingKit.ModInstaller
{
	public class ModInfoAsset
	{
		private static ModInfoAsset edited_asset = new ModInfoAsset();

		private static char[] mod_name_buffer = new char[256];

		private static char[] creator_name_buffer = new char[256];

		private static char[] mod_version_buffer = new char[16];

		private static char[] asset_path_buffer = new char[256];

		private static char[] plugin_path_buffer = new char[256];

		private static int os_index = 0;

		private static OperatingSystemFamily[] operating_systems;

		public string ModName { get; internal set; }

		public string CreatorName { get; internal set; }

		public string Version { get; internal set; }

		public string AssetBundleFolderPath { get; internal set; }

		public string PluginFolderPath { get; internal set; }

		public OperatingSystemFamily OperatingSystem { get; internal set; }

		public string GameVersion { get; internal set; }

		public string ModdingKitVersion { get; internal set; }

		internal unsafe static void DisplayImGuiControls()
		{
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			if (ImGui.BeginMenu("ModInfo generator"))
			{
				ImGui.InputText("Mod Name", mod_name_buffer, (ImGuiInputTextFlags)0, (ImGuiInputTextCallback)null);
				edited_asset.ModName = ImGuiUtility.AsString(mod_name_buffer);
				ImGui.InputText("Creator's Name", creator_name_buffer, (ImGuiInputTextFlags)0, (ImGuiInputTextCallback)null);
				edited_asset.CreatorName = ImGuiUtility.AsString(creator_name_buffer);
				char[] array = mod_version_buffer.Clone() as char[];
				ImGui.InputText("Mod Version", mod_version_buffer, (ImGuiInputTextFlags)0, (ImGuiInputTextCallback)null);
				string text = ImGuiUtility.AsString(mod_version_buffer);
				if (Regex.IsMatch(text, "[0-9]+\\.[0-9]+\\.[0-9]+$"))
				{
					edited_asset.Version = text;
				}
				else
				{
					mod_version_buffer = array;
				}
				ImGui.InputText("Assetbundle Folder Path", asset_path_buffer, (ImGuiInputTextFlags)0, (ImGuiInputTextCallback)null);
				edited_asset.AssetBundleFolderPath = ImGuiUtility.AsString(asset_path_buffer);
				ImGui.InputText("Plugin Folder Path", plugin_path_buffer, (ImGuiInputTextFlags)0, (ImGuiInputTextCallback)null);
				edited_asset.PluginFolderPath = ImGuiUtility.AsString(plugin_path_buffer);
				string[] array2 = operating_systems.Select((OperatingSystemFamily os) => ((object)(*(OperatingSystemFamily*)(&os))/*cast due to .constrained prefix*/).ToString()).ToArray();
				array2[3] = "All";
				ImGui.ListBox("Operating System", ref os_index, array2, 4);
				edited_asset.OperatingSystem = operating_systems[os_index];
				edited_asset.GameVersion = ReceiverCoreScript.Instance().build_info.version;
				edited_asset.ModdingKitVersion = ((BaseUnityPlugin)ModdingKitCorePlugin.instance).Info.Metadata.Version.ToString();
				if (ImGui.Button("Clear"))
				{
					edited_asset = new ModInfoAsset();
					mod_name_buffer = new char[256];
					creator_name_buffer = new char[256];
					mod_version_buffer = new char[16];
					asset_path_buffer = new char[256];
					plugin_path_buffer = new char[256];
					os_index = 0;
				}
				if (ImGui.Button("Copy .json file"))
				{
					JSONObject val = new JSONObject();
					((JSONNode)val)["modName"] = JSONNode.op_Implicit(edited_asset.ModName);
					((JSONNode)val)["creatorName"] = JSONNode.op_Implicit(edited_asset.CreatorName);
					((JSONNode)val)["version"] = JSONNode.op_Implicit(edited_asset.Version);
					((JSONNode)val)["assetBundleFolder"] = JSONNode.op_Implicit(edited_asset.AssetBundleFolderPath);
					((JSONNode)val)["pluginFolder"] = JSONNode.op_Implicit(edited_asset.PluginFolderPath);
					((JSONNode)val)["operatingSystem"] = JSONNode.op_Implicit(((object)edited_asset.OperatingSystem/*cast due to .constrained prefix*/).ToString());
					((JSONNode)val)["gameVersion"] = JSONNode.op_Implicit(edited_asset.GameVersion);
					((JSONNode)val)["moddingKitVersion"] = JSONNode.op_Implicit(edited_asset.ModdingKitVersion);
					TextEditor val2 = new TextEditor
					{
						text = ((object)val).ToString()
					};
					val2.SelectAll();
					val2.Copy();
				}
				ImGui.EndMenu();
			}
		}

		public static ModInfoAsset FromJSONFile(JSONNode jsonFile, string defaultName)
		{
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			ModInfoAsset modInfoAsset = new ModInfoAsset();
			if (jsonFile.HasKey("assetBundleFolder"))
			{
				modInfoAsset.AssetBundleFolderPath = JSONNode.op_Implicit(jsonFile["assetBundleFolder"]);
				if (jsonFile.HasKey("pluginFolder"))
				{
					modInfoAsset.PluginFolderPath = JSONNode.op_Implicit(jsonFile["pluginFolder"]);
					modInfoAsset.ModName = (jsonFile.HasKey("modName") ? JSONNode.op_Implicit(jsonFile["modName"]) : defaultName);
					modInfoAsset.CreatorName = (jsonFile.HasKey("creatorName") ? JSONNode.op_Implicit(jsonFile["creatorName"]) : "");
					modInfoAsset.Version = (jsonFile.HasKey("version") ? JSONNode.op_Implicit(jsonFile["version"]) : "");
					if (jsonFile.HasKey("operatingSystem"))
					{
						if (Enum.TryParse<OperatingSystemFamily>(JSONNode.op_Implicit(jsonFile["operatingSystem"]), out OperatingSystemFamily result))
						{
							modInfoAsset.OperatingSystem = result;
						}
						else if (jsonFile["operatingSystem"] == (object)"ALL")
						{
							modInfoAsset.OperatingSystem = (OperatingSystemFamily)0;
						}
						else
						{
							modInfoAsset.OperatingSystem = (OperatingSystemFamily)2;
						}
					}
					else
					{
						modInfoAsset.OperatingSystem = (OperatingSystemFamily)2;
					}
					modInfoAsset.GameVersion = (jsonFile.HasKey("gameVersion") ? JSONNode.op_Implicit(jsonFile["gameVersion"]) : "2.2.3");
					modInfoAsset.ModdingKitVersion = (jsonFile.HasKey("moddingKitVersion") ? JSONNode.op_Implicit(jsonFile["moddingKitVersion"]) : "0.0.0");
					return modInfoAsset;
				}
				Debug.LogError((object)"\"pluginFolder\" key is not present in the json file, mod will not be loaded");
				return null;
			}
			Debug.LogError((object)"\"assetBundleFolder\" key is not present in the json file, mod will not be loaded");
			return null;
		}

		private ModInfoAsset()
		{
		}

		static ModInfoAsset()
		{
			OperatingSystemFamily[] array = new OperatingSystemFamily[4];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			operating_systems = (OperatingSystemFamily[])(object)array;
		}
	}
	internal class ModInstallerObject : MonoBehaviour
	{
		internal class ModDirectoryInfo
		{
			public DirectoryInfo directory { get; private set; }

			public ModInfoAsset mod_info { get; private set; }

			public ModDirectoryInfo(DirectoryInfo directory, ModInfoAsset mod_info)
			{
				this.directory = directory;
				this.mod_info = mod_info;
			}
		}

		internal enum InstallerState
		{
			PickingDirectory,
			ReadyToInstall,
			InstallingMod,
			Finishing
		}

		private bool displaying_prompt;

		private string prompt_message = "";

		private bool? prompt_result;

		private bool successful = true;

		private InstallerState current_state;

		private DirectoryInfo current_path;

		private ModDirectoryInfo mod_dir_info;

		private bool plugins_loaded;

		private void CopyDirectory(string from, string to)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(from);
			if (!directoryInfo.Exists)
			{
				return;
			}
			try
			{
				string text = Path.Combine(to, directoryInfo.Name);
				if (!Directory.Exists(text))
				{
					Directory.CreateDirectory(text);
				}
				FileInfo[] files = directoryInfo.GetFiles();
				foreach (FileInfo fileInfo in files)
				{
					fileInfo.CopyTo(Path.Combine(text, fileInfo.Name), overwrite: true);
				}
				DirectoryInfo[] directories = directoryInfo.GetDirectories();
				foreach (DirectoryInfo directoryInfo2 in directories)
				{
					CopyDirectory(directoryInfo2.FullName, text);
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
			}
		}

		private void ShowPickDirectoryMenu()
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (!ImGui.Begin("Path selector", (ImGuiWindowFlags)32))
			{
				return;
			}
			if (current_path == null)
			{
				ImGui.Text("Current path: ");
				int totalWidth = Mathf.Min(20, Directory.GetLogicalDrives().Max((string drive) => drive.Length));
				ImGui.Separator();
				string[] logicalDrives = Directory.GetLogicalDrives();
				foreach (string text in logicalDrives)
				{
					if (ImGui.Button("|   \uf0a0   " + text.PadRight(totalWidth)))
					{
						current_path = new DirectoryInfo(text);
					}
				}
			}
			else
			{
				if (current_path.GetFiles("modinfo.json").Count() > 0)
				{
					ModInfoAsset modInfoAsset = ModInfoAsset.FromJSONFile(JSON.Parse(File.ReadAllText(current_path.FullName + "/modinfo.json")), current_path.Name);
					if (modInfoAsset != null && ((int)modInfoAsset.OperatingSystem == 0 || modInfoAsset.OperatingSystem == SystemInfo.operatingSystemFamily))
					{
						ImGui.Text("Located mod: " + modInfoAsset.ModName + ". Do you want to install it?");
						if (ImGui.Button("Install"))
						{
							mod_dir_info = new ModDirectoryInfo(current_path, modInfoAsset);
							current_state = InstallerState.ReadyToInstall;
						}
						ImGui.Separator();
					}
				}
				ImGui.Text("Current path: " + current_path.FullName);
				ImGui.Separator();
				if (ImGui.Button("<--"))
				{
					if (current_path.Parent == null)
					{
						current_path = null;
					}
					else
					{
						current_path = current_path.Parent;
					}
					ImGui.End();
					return;
				}
				if (current_path.GetDirectories().Length != 0)
				{
					int totalWidth2 = Mathf.Min(50, current_path.GetDirectories().Max((DirectoryInfo dir) => dir.Name.Length));
					DirectoryInfo[] directories = current_path.GetDirectories();
					foreach (DirectoryInfo directoryInfo in directories)
					{
						bool flag = false;
						bool flag2 = false;
						try
						{
							flag2 = directoryInfo.GetFiles("modinfo.json").Count() > 0;
						}
						catch (UnauthorizedAccessException)
						{
							flag = true;
							flag2 = false;
						}
						if (ImGui.Button("|" + (flag ? "\uf023 " : "   ") + "\uf07b" + (flag2 ? " \uf005 " : "   ") + directoryInfo.Name.PadRight(totalWidth2)) && !flag)
						{
							current_path = directoryInfo;
						}
					}
				}
				else
				{
					ImGui.Text("No subdirectories present");
				}
			}
			ImGui.Separator();
			if (ImGui.Button("Cancel"))
			{
				successful = false;
				current_state = InstallerState.Finishing;
			}
			ImGui.End();
		}

		private void InstallMod()
		{
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			if (mod_dir_info == null || mod_dir_info.directory == null || mod_dir_info.mod_info == null)
			{
				Debug.LogError((object)"Something went wrong, aborting installation");
				successful = false;
				current_state = InstallerState.Finishing;
				return;
			}
			ModInfoAsset mod_info = mod_dir_info.mod_info;
			if (mod_info.ModdingKitVersion != ((BaseUnityPlugin)ModdingKitCorePlugin.instance).Info.Metadata.Version.ToString())
			{
				if (!prompt_result.HasValue)
				{
					displaying_prompt = true;
					prompt_message = "It seems your mod was created using a different version of the Modding Kit, do you want to install it anyway?";
					return;
				}
				if (prompt_result != true)
				{
					current_state = InstallerState.Finishing;
					return;
				}
				mod_info.ModdingKitVersion = ((BaseUnityPlugin)ModdingKitCorePlugin.instance).Info.Metadata.Version.ToString();
				prompt_result = null;
			}
			if (mod_info.GameVersion != ReceiverCoreScript.Instance().build_info.version)
			{
				if (!prompt_result.HasValue)
				{
					displaying_prompt = true;
					prompt_message = "It seems your mod was created for a different version of the game, do you want to install it anyway?";
					return;
				}
				if (prompt_result != true)
				{
					current_state = InstallerState.Finishing;
					return;
				}
				mod_info.GameVersion = ReceiverCoreScript.Instance().build_info.version;
			}
			if (mod_info.PluginFolderPath != null)
			{
				string text = mod_dir_info.directory.FullName + "/" + mod_info.PluginFolderPath;
				if (Directory.Exists(text))
				{
					try
					{
						new DirectoryInfo(text).GetFiles("*.dll", SearchOption.AllDirectories);
						if (Directory.Exists(Path.Combine(Paths.PluginPath, new DirectoryInfo(text).Name)))
						{
							Directory.Delete(Path.Combine(Paths.PluginPath, new DirectoryInfo(text).Name));
						}
						CopyDirectory(text, Paths.PluginPath);
					}
					catch (IOException ex)
					{
						Debug.LogError((object)("Couldn't copy plugin files for mod: " + mod_info.ModName));
						Debug.LogError((object)("Error:\n" + ex.Message));
						try
						{
							if (Directory.Exists(Path.Combine(Paths.PluginPath, new DirectoryInfo(text).Name)))
							{
								Directory.Delete(Path.Combine(Paths.PluginPath, new DirectoryInfo(text).Name));
							}
						}
						catch
						{
						}
					}
					catch (UnauthorizedAccessException ex2)
					{
						Debug.LogError((object)("Couldn't copy plugin files for mod: " + mod_info.ModName));
						Debug.LogError((object)("Error:\n" + ex2.Message));
						try
						{
							if (Directory.Exists(Path.Combine(Paths.PluginPath, new DirectoryInfo(text).Name)))
							{
								Directory.Delete(Path.Combine(Paths.PluginPath, new DirectoryInfo(text).Name));
							}
						}
						catch
						{
						}
					}
				}
			}
			if (mod_info.AssetBundleFolderPath != null)
			{
				string text2 = mod_dir_info.directory.FullName + "/" + mod_info.AssetBundleFolderPath;
				if (Directory.Exists(text2))
				{
					try
					{
						new DirectoryInfo(text2).GetFiles("*." + ((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower());
						new DirectoryInfo(text2).GetDirectories();
						if (Directory.Exists(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name))
						{
							Directory.Delete(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name, recursive: true);
						}
						CopyDirectory(text2, Application.persistentDataPath + "/Guns/");
						int count = ((List<GameObject>)ReflectionManager.RCS_gun_prefabs_all.GetValue(ReceiverCoreScript.Instance())).Count;
						ReceiverCoreScript.Instance().LoadModGun(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name, true);
						List<GameObject> list = (List<GameObject>)ReflectionManager.RCS_gun_prefabs_all.GetValue(ReceiverCoreScript.Instance());
						if (count < list.Count && list.Last().GetComponent<GunScript>() is ModGunScript)
						{
							ModLoader.LoadGun(list.Last().GetComponent<ModGunScript>());
						}
					}
					catch (IOException ex3)
					{
						Debug.LogError((object)("Couldn't copy assets for mod: " + mod_info.ModName));
						Debug.LogError((object)("Error:\n" + ex3.Message));
						try
						{
							if (Directory.Exists(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name))
							{
								Directory.Delete(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name, recursive: true);
							}
						}
						catch
						{
						}
					}
					catch (UnauthorizedAccessException ex4)
					{
						Debug.LogError((object)("Couldn't copy assets for mod: " + mod_info.ModName));
						Debug.LogError((object)("Error:\n" + ex4.Message));
						try
						{
							if (Directory.Exists(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name))
							{
								Directory.Delete(Application.persistentDataPath + "/Guns/" + new DirectoryInfo(text2).Name, recursive: true);
							}
						}
						catch
						{
						}
					}
				}
			}
			current_state = InstallerState.Finishing;
		}

		private void DisplayPrompt()
		{
			if (ImGui.Begin("Installer", (ImGuiWindowFlags)32))
			{
				if (!string.IsNullOrEmpty(prompt_message))
				{
					ImGui.TextWrapped(prompt_message);
				}
				ImGui.Spacing();
				if (ImGui.Button("   Yes   "))
				{
					prompt_result = true;
					displaying_prompt = false;
				}
				ImGui.SameLine(0f, 20f);
				if (ImGui.Button("   No    "))
				{
					prompt_result = false;
					displaying_prompt = false;
				}
				ImGui.End();
			}
		}

		private void Finish()
		{
			if (!ImGui.Begin("Installer", (ImGuiWindowFlags)32))
			{
				return;
			}
			if (successful)
			{
				ImGui.Text("Installation finished");
				ImGui.Text("Restart the game to load installed addons");
			}
			else
			{
				ImGui.Text("Installation aborted");
			}
			ImGui.Spacing();
			if (plugins_loaded)
			{
				ImGui.Text("There are plugins waiting to be loaded, do you want to load them now?");
				if (ImGui.Button("Yes"))
				{
					plugins_loaded = false;
				}
				if (ImGui.Button("No"))
				{
					plugins_loaded = false;
				}
			}
			if (ImGui.Button("OK"))
			{
				ModLoader.mod_installer = null;
				Object.Destroy((Object)(object)this);
			}
			ImGui.End();
		}

		private void Awake()
		{
		}

		private void Update()
		{
			if (displaying_prompt)
			{
				DisplayPrompt();
				return;
			}
			switch (current_state)
			{
			case InstallerState.PickingDirectory:
				ShowPickDirectoryMenu();
				break;
			case InstallerState.ReadyToInstall:
				InstallMod();
				break;
			case InstallerState.Finishing:
				Finish();
				break;
			}
			prompt_result = null;
		}
	}
	public static class ModLoader
	{
		private static GameObject prefab_9mm;

		internal static ModInstallerObject mod_installer;

		internal static bool rcs_prefab_list_locked;

		internal static List<InventoryItem> prefab_list_queue = new List<InventoryItem>();

		public static void SearchForMod()
		{
			mod_installer = ((Component)ModdingKitCorePlugin.instance).gameObject.AddComponent<ModInstallerObject>();
		}

		public static bool IsGunModInstalled(string gunName)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Directory.Exists(Path.Combine(Application.persistentDataPath, "Guns", gunName)))
			{
				string[] files = Directory.GetFiles(Path.Combine(Application.persistentDataPath, "Guns", gunName));
				for (int i = 0; i < files.Length; i++)
				{
					if (files[i].Contains(((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower()))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static void LoadGun(ModGunScript gun)
		{
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Unknown result type (might be due to invalid IL or missing references)
			//IL_0777: Unknown result type (might be due to invalid IL or missing references)
			//IL_077c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_051f: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			if (IsGunLoaded((GunScript)(object)gun))
			{
				Debug.Log((object)("Gun " + ((InventoryItem)gun).InternalName + " is already loaded"));
				return;
			}
			rcs_prefab_list_locked = true;
			List<InventoryItem> items = new List<InventoryItem>(ReceiverCoreScript.Instance().generic_prefabs);
			if (gun.visible_in_spawnmenu)
			{
				items.Add((InventoryItem)(object)gun);
			}
			if (!Object.op_Implicit((Object)(object)prefab_9mm))
			{
				prefab_9mm = ((Component)items.First((InventoryItem item) => item is ShellCasingScript && (int)((ShellCasingScript)item).cartridge_type == 0 && (Object)(object)((ShellCasingScript)item).go_casing != (Object)null)).gameObject;
			}
			AssignVanillaMuzzleflash vanillaMuzzleflash = default(AssignVanillaMuzzleflash);
			if (((Component)gun).TryGetComponent<AssignVanillaMuzzleflash>(ref vanillaMuzzleflash) && (Object)(object)gun.muzzle_flash_prefab == (Object)null)
			{
				((GunScript)gun).pooled_muzzle_flash = ((GunScript)items.First((InventoryItem item) => item is GunScript && ((GunScript)item).gun_model == vanillaMuzzleflash.muzzleflashFromGun)).pooled_muzzle_flash;
				Object.DestroyImmediate((Object)(object)vanillaMuzzleflash);
			}
			InBuiltCartridge cartridge = ((Component)gun).GetComponent<InBuiltCartridge>();
			if (Object.op_Implicit((Object)(object)cartridge))
			{
				try
				{
					((GunScript)gun).loaded_cartridge_prefab = ((Component)items.First((InventoryItem item) => item is ShellCasingScript && ((ShellCasingScript)item).cartridge_type == cartridge.preset && (Object)(object)((ShellCasingScript)item).go_casing != (Object)null)).gameObject;
					Object.DestroyImmediate((Object)(object)cartridge);
				}
				catch (InvalidOperationException)
				{
					Debug.LogError((object)string.Concat("Error when setting cartridge for gun \"", ((InventoryItem)gun).InternalName, "\". Cannot find prefab for cartridge type \"", cartridge.preset, "\""));
				}
			}
			else if (Object.op_Implicit((Object)(object)((GunScript)gun).loaded_cartridge_prefab))
			{
				ShellCasingScript component = ((GunScript)gun).loaded_cartridge_prefab.GetComponent<ShellCasingScript>();
				if (!ModShellCasingScript.mod_cartridges.ContainsKey(component.cartridge_type))
				{
					if (component.cartridge_type > Enum.GetValues(typeof(Preset)).Cast<Preset>().Max())
					{
						if (Object.op_Implicit((Object)(object)((InventoryItem)component).glint_renderer) && ((Object)(object)((InventoryItem)component).glint_renderer.material == (Object)null || ((Object)((InventoryItem)component).glint_renderer.material).name != "ItemGlint (Instance)"))
						{
							((InventoryItem)component).glint_renderer.material = ((InventoryItem)prefab_9mm.GetComponent<ShellCasingScript>()).glint_renderer.material;
						}
						if (component is ModShellCasingScript modShellCasingScript)
						{
							ModShellCasingScript.mod_cartridges.Add(component.cartridge_type, modShellCasingScript.spec.CreateSpec());
							if (!ModdingKitCorePlugin.round_prefabs.ContainsKey(((ShellCasingScript)modShellCasingScript).cartridge_type))
							{
								ModdingKitCorePlugin.AddShellCasingScriptPrefab((ShellCasingScript)(object)modShellCasingScript);
							}
							if (modShellCasingScript.customRoundTypeParameters != null && (int)modShellCasingScript.customRoundTypeParameters.cartridge != 0)
							{
								CustomRoundTypes.RegisterCustomRound(modShellCasingScript.customRoundTypeParameters);
							}
						}
						else
						{
							Debug.LogWarning((object)("Gun " + ((InventoryItem)gun).InternalName + " adds a cartridge via ModGunScript.GetCustomCartridgeSpec(); Consider using ModShellCasingScript instead"));
							ModShellCasingScript.mod_cartridges.Add(component.cartridge_type, gun.GetCustomCartridgeSpec());
						}
						ItemWithGlint itemWithGlint = default(ItemWithGlint);
						if (((Component)component).TryGetComponent<ItemWithGlint>(ref itemWithGlint))
						{
							Object.Destroy((Object)(object)itemWithGlint);
						}
						items.Add((InventoryItem)(object)component);
					}
					else
					{
						Debug.LogError((object)string.Concat("Gun ", ((InventoryItem)gun).InternalName, " tried to overwrite cartridge ", component.cartridge_type, "; Inbuilt cartridge will be used instead"));
					}
				}
				else
				{
					Debug.LogWarning((object)("Possible redefinition of cartridge with type " + component.cartridge_type));
				}
			}
			else
			{
				Debug.LogWarning((object)("Gun " + ((InventoryItem)gun).InternalName + " doesn't specify a cartridge and doesn't contain an InBuiltCartridge component and will use a defaul 9mm round"));
				((GunScript)gun).loaded_cartridge_prefab = prefab_9mm;
			}
			Bounds val;
			if (((GunScript)gun).magazine_root_types.Length != 0)
			{
				List<MagazineScript> list = ((List<MagazineScript>)ReflectionManager.RCS_magazine_prefabs_all.GetValue(ReceiverCoreScript.Instance())).Where((MagazineScript mag) => !items.Contains((InventoryItem)(object)mag) && ((GunScript)gun).magazine_root_types.Contains(mag.magazine_root_type)).ToList();
				ItemWithGlint itemWithGlint2 = default(ItemWithGlint);
				foreach (MagazineScript item in list)
				{
					if ((Object)(object)item.round_prefab == (Object)null || (Object)(object)item.round_prefab.GetComponent<ShellCasingScript>() == (Object)null)
					{
						item.round_prefab = ((GunScript)gun).loaded_cartridge_prefab;
					}
					if (Object.op_Implicit((Object)(object)((InventoryItem)item).glint_renderer) && ((Object)(object)((InventoryItem)item).glint_renderer.material == (Object)null || ((Object)((InventoryItem)item).glint_renderer.material).name != "ItemGlint (Instance)"))
					{
						((InventoryItem)item).glint_renderer.material = ((InventoryItem)prefab_9mm.GetComponent<ShellCasingScript>()).glint_renderer.material;
					}
					if (((Component)item).TryGetComponent<ItemWithGlint>(ref itemWithGlint2))
					{
						Object.Destroy((Object)(object)itemWithGlint2);
					}
					if (!Object.op_Implicit((Object)(object)((Component)item).GetComponent<PegboardHangableItem>()) || !((Object)(object)((Component)item).GetComponent<PegboardHangableItem>().pegboard_hanger != (Object)null))
					{
						continue;
					}
					val = (Bounds)ReflectionManager.PH_bounds.GetValue(((Component)item).GetComponent<PegboardHangableItem>().pegboard_hanger);
					if (((Bounds)(ref val)).size == Vector3.zero)
					{
						PegboardHanger pegboard_hanger = ((Component)item).GetComponent<PegboardHangableItem>().pegboard_hanger;
						Bounds val2 = default(Bounds);
						MeshRenderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<MeshRenderer>();
						foreach (MeshRenderer val3 in componentsInChildren)
						{
							((Bounds)(ref val2)).Encapsulate(((Renderer)val3).bounds);
						}
						ReflectionManager.PH_bounds.SetValue(pegboard_hanger, val2);
					}
				}
				items.AddRange((IEnumerable<InventoryItem>)list);
			}
			if (!Locale.active_locale_tactics.ContainsKey(((GunScript)gun).weapon_group_name))
			{
				Locale.active_locale_tactics.Add(((GunScript)gun).weapon_group_name, gun.GetGunTactics());
			}
			ModHelpEntry gunHelpEntry = gun.GetGunHelpEntry();
			if (gunHelpEntry != null && !ModHelpEntryManager.entries.ContainsKey(((GunScript)gun).weapon_group_name))
			{
				ModHelpEntryManager.entries.Add(((GunScript)gun).weapon_group_name, gunHelpEntry);
			}
			if ((Object)(object)gun.audio != (Object)null)
			{
				gun.audio.Initialize(gun);
				foreach (FieldInfo item2 in from field in ((object)gun).GetType().GetFields(BindingFlags.Instance)
					where field.FieldType == typeof(string) && field.GetCustomAttribute<CustomEventRef>() != null
					select field)
				{
					gun.audio.BindField(item2);
				}
				string[] sound_events = gun.audio.sound_events;
				foreach (string text in sound_events)
				{
					if (text != "" && !text.StartsWith("event:/") && !ModAudioManager.GetAllEvents().Contains(text))
					{
						Debug.LogError((object)("Failed to load sound event \"" + text + "\", falling back on default sounds"));
						gun.audio.force_options = CustomSoundsList.ForceOptions.ForceDefaultSounds;
						break;
					}
				}
			}
			if (Object.op_Implicit((Object)(object)((Component)gun).GetComponent<PegboardHangableItem>()) && (Object)(object)((Component)gun).GetComponent<PegboardHangableItem>().pegboard_hanger != (Object)null)
			{
				PegboardHanger pegboard_hanger2 = ((Component)gun).GetComponent<PegboardHangableItem>().pegboard_hanger;
				val = (Bounds)ReflectionManager.PH_bounds.GetValue(pegboard_hanger2);
				if (((Bounds)(ref val)).size == Vector3.zero)
				{
					Bounds val4 = default(Bounds);
					MeshRenderer[] componentsInChildren = ((Component)gun).GetComponentsInChildren<MeshRenderer>();
					foreach (MeshRenderer val5 in componentsInChildren)
					{
						((Bounds)(ref val4)).Encapsulate(((Renderer)val5).bounds);
					}
					ReflectionManager.PH_bounds.SetValue(pegboard_hanger2, val4);
				}
			}
			try
			{
				gun.BaseInitializeGun();
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)("Error accured while initializing gun " + ((InventoryItem)gun).InternalName + ":"));
				Debug.LogException(ex2);
			}
			if (gun.spawns_in_dreaming)
			{
				ReceiverCoreScript.Instance().PlayerData.unlocked_gun_names.Add(((InventoryItem)gun).InternalName);
			}
			rcs_prefab_list_locked = false;
			if (prefab_list_queue.Count > 0)
			{
				items.AddRange(prefab_list_queue);
				prefab_list_queue.Clear();
			}
			ReceiverCoreScript.Instance().generic_prefabs = items.ToArray();
		}

		public static void Finish()
		{
			InventoryItem[] generic_prefabs = ReceiverCoreScript.Instance().generic_prefabs;
			InventoryItem val = default(InventoryItem);
			for (int i = 0; i < generic_prefabs.Length; i++)
			{
				ItemWithGlint[] componentsInChildren = ((Component)generic_prefabs[i]).GetComponentsInChildren<ItemWithGlint>();
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					if (((Component)componentsInChildren[j]).TryGetComponent<InventoryItem>(ref val) && (Object)(object)val.glint_renderer != (Object)null && ((Object)(object)val.glint_renderer.material == (Object)null || ((Object)val.glint_renderer.material).name != "ItemGlint (Instance)"))
					{
						val.glint_renderer.material = prefab_9mm.GetComponent<InventoryItem>().glint_renderer.sharedMaterial;
					}
				}
			}
		}

		public static bool IsGunLoaded(GunScript gun)
		{
			InventoryItem[] generic_prefabs = ReceiverCoreScript.Instance().generic_prefabs;
			foreach (InventoryItem val in generic_prefabs)
			{
				if (val is GunScript && val.InternalName == ((InventoryItem)gun).InternalName)
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsGunLoaded(string gunName)
		{
			InventoryItem[] generic_prefabs = ReceiverCoreScript.Instance().generic_prefabs;
			foreach (InventoryItem val in generic_prefabs)
			{
				if (val is GunScript && val.InternalName == gunName)
				{
					return true;
				}
			}
			return false;
		}
	}
	public class ScriptEngine
	{
		private static GameObject scriptManager;

		public static string ScriptDirectory => Path.Combine(Paths.BepInExRootPath, "./guns-temp");

		public static void ReloadPlugins()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			if ((Object)(object)scriptManager != (Object)null)
			{
				Object.Destroy((Object)(object)scriptManager);
			}
			scriptManager = new GameObject($"ScriptEngine_{DateTime.Now.Ticks}");
			Object.DontDestroyOnLoad((Object)(object)scriptManager);
			if (Directory.GetFiles(ScriptDirectory, "*.dll").Length != 0)
			{
				string[] files = Directory.GetFiles(ScriptDirectory, "*.dll");
				for (int i = 0; i < files.Length; i++)
				{
					LoadDLL(files[i], scriptManager);
				}
			}
		}

		private static void LoadDLL(string path, GameObject obj)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			DefaultAssemblyResolver val = new DefaultAssemblyResolver();
			((BaseAssemblyResolver)val).AddSearchDirectory(ScriptDirectory);
			((BaseAssemblyResolver)val).AddSearchDirectory(Paths.ManagedPath);
			((BaseAssemblyResolver)val).AddSearchDirectory(Paths.BepInExAssemblyDirectory);
			AssemblyDefinition val2 = AssemblyDefinition.ReadAssembly(path, new ReaderParameters
			{
				AssemblyResolver = (IAssemblyResolver)(object)val
			});
			try
			{
				((AssemblyNameReference)val2.Name).Name = $"{((AssemblyNameReference)val2.Name).Name}-{DateTime.Now.Ticks}";
				using MemoryStream memoryStream = new MemoryStream();
				val2.Write((Stream)memoryStream);
				foreach (Type type in GetTypesSafe(Assembly.Load(memoryStream.ToArray())))
				{
					try
					{
						if (!typeof(BaseUnityPlugin).IsAssignableFrom(type))
						{
							continue;
						}
						BepInPlugin metadata = MetadataHelper.GetMetadata(type);
						if (metadata != null)
						{
							PluginInfo value = Chainloader.ToPluginInfo(((IEnumerable<TypeDefinition>)val2.MainModule.Types).First((TypeDefinition x) => ((MemberReference)x).FullName == type.FullName));
							Chainloader.PluginInfos[metadata.GUID] = value;
							Debug.Log((object)("Loading " + metadata.GUID));
							((MonoBehaviour)ModdingKitCorePlugin.instance).StartCoroutine(DelayAction(delegate
							{
							}));
						}
					}
					catch (Exception arg)
					{
						Debug.LogError((object)$"Failed to load plugin {type.Name} because of exception: {arg}");
					}
				}
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}

		private static IEnumerable<Type> GetTypesSafe(Assembly ass)
		{
			try
			{
				return ass.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("\r\n-- LoaderExceptions --");
				Exception[] loaderExceptions = ex.LoaderExceptions;
				foreach (Exception ex2 in loaderExceptions)
				{
					stringBuilder.AppendLine(ex2.ToString());
				}
				stringBuilder.AppendLine("\r\n-- StackTrace --");
				stringBuilder.AppendLine(ex.StackTrace);
				Debug.LogError((object)stringBuilder.ToString());
				return ex.Types.Where((Type x) => x != null);
			}
		}

		private static IEnumerator DelayAction(Action action)
		{
			yield return null;
			action();
		}
	}
}
namespace Receiver2ModdingKit.Logging
{
	public class ExtendedLogEventArgs : LogEventArgs
	{
		public ConsoleColor ConsoleColor { get; protected set; }

		public string LevelName { get; protected set; }

		public ExtendedLogEventArgs(object data, LogLevel level, ILogSource source, ConsoleColor consoleColor, string levelName = null)
			: base(data, level, source)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			ConsoleColor = consoleColor;
			LevelName = levelName;
		}

		public ExtendedLogEventArgs(object data, LogLevel level, ILogSource source, string levelName = null)
			: base(data, level, source)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			LevelName = levelName;
		}

		public override string ToString()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return $"[{LevelName ?? Enum.GetName(typeof(LogLevel), ((LogEventArgs)this).Level),-7}:{((LogEventArgs)this).Source.SourceName,10}] {((LogEventArgs)this).Data}";
		}
	}
	public class ExtendedManualLogSource : ManualLogSource
	{
		public event EventHandler<LogEventArgs> LogEvent;

		public ExtendedManualLogSource(string sourceName)
			: base(sourceName)
		{
			Logger.Sources.Add((ILogSource)(object)this);
		}

		public ExtendedManualLogSource(string sourceName, ManualLogSource manualLogSource)
			: base(sourceName)
		{
			this.LogEvent = AccessTools.FieldRefAccess<ManualLogSource, EventHandler<LogEventArgs>>("LogEvent").Invoke(manualLogSource);
		}

		public void Log(LogLevel level, object data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ManualLogSource)this).Log(level, data);
		}

		public void LogWithColor(LogLevel level, object data, ConsoleColor color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, level, (ILogSource)(object)this, color));
		}

		public void LogWithLevelName(LogLevel level, object data, string levelName)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, level, (ILogSource)(object)this, levelName));
		}

		public void LogFatal(object data)
		{
			Log((LogLevel)1, data);
		}

		public void LogFatalWithColor(object data, ConsoleColor color)
		{
			LogWithColor((LogLevel)1, data, color);
		}

		public void LogFatalWithLevelName(object data, string levelName)
		{
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, (LogLevel)1, (ILogSource)(object)this, levelName));
		}

		public void LogError(object data)
		{
			Log((LogLevel)2, data);
		}

		public void LogErrorWithColor(object data, ConsoleColor color)
		{
			LogWithColor((LogLevel)2, data, color);
		}

		public void LogErrorWithLevelName(object data, string levelName)
		{
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, (LogLevel)2, (ILogSource)(object)this, levelName));
		}

		public void LogWarning(object data)
		{
			Log((LogLevel)4, data);
		}

		public void LogWarningWithColor(object data, ConsoleColor color)
		{
			LogWithColor((LogLevel)4, data, color);
		}

		public void LogWarningWithLevelName(object data, string levelName)
		{
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, (LogLevel)4, (ILogSource)(object)this, levelName));
		}

		public void LogMessage(object data)
		{
			Log((LogLevel)8, data);
		}

		public void LogMessageWithColor(object data, ConsoleColor color)
		{
			LogWithColor((LogLevel)8, data, color);
		}

		public void LogMessageWithLevelName(object data, string levelName)
		{
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, (LogLevel)8, (ILogSource)(object)this, levelName));
		}

		public void LogInfo(object data)
		{
			Log((LogLevel)16, data);
		}

		public void LogInfoWithColor(object data, ConsoleColor color)
		{
			LogWithColor((LogLevel)16, data, color);
		}

		public void LogInfoWithLevelName(object data, string levelName)
		{
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, (LogLevel)16, (ILogSource)(object)this, levelName));
		}

		public void LogDebug(object data)
		{
			Log((LogLevel)32, data);
		}

		public void LogDebugWithColor(object data, ConsoleColor color)
		{
			LogWithColor((LogLevel)32, data, color);
		}

		public void LogDebugWithLevelName(object data, string levelName)
		{
			this.LogEvent?.Invoke(this, (LogEventArgs)(object)new ExtendedLogEventArgs(data, (LogLevel)32, (ILogSource)(object)this, levelName));
		}
	}
	public static class FMODLogger
	{
		private delegate void UnityLogMethod(object message);

		public static DEBUG_FLAGS log_flags = (DEBUG_FLAGS)462343;

		private const DEBUG_FLAGS ALL = (DEBUG_FLAGS)462599u;

		public static bool Initialize()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			return (int)Debug.Initialize((DEBUG_FLAGS)462599, (DEBUG_MODE)2, new DEBUG_CALLBACK(DEBUG_CALLBACK), (string)null) == 0;
		}

		private unsafe static RESULT DEBUG_CALLBACK(DEBUG_FLAGS flags, StringWrapper file, int line, StringWrapper func, StringWrapper message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected I4, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((flags & log_flags) != 0)
			{
				DEBUG_FLAGS val = (DEBUG_FLAGS)(flags & -8);
				switch (val - 1)
				{
				}
				new StringBuilder().AppendLine(((object)(*(DEBUG_FLAGS*)(&flags))/*cast due to .constrained prefix*/).ToString()).AppendLine($"{line}: {StringWrapper.op_Implicit(file)}: {StringWrapper.op_Implicit(func)}").AppendLine(StringWrapper.op_Implicit(message));
			}
			return (RESULT)0;
		}
	}
}
namespace Receiver2ModdingKit.Helpers
{
	public static class AssetHelper
	{
		public static bool FindAssetBundle<T>(string path, out T asset) where T : class
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			asset = null;
			Debug.Log((object)path);
			if (Directory.Exists(path))
			{
				string[] files = Directory.GetFiles(path);
				foreach (string fileName in files)
				{
					if (!fileName.Contains(((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower()))
					{
						continue;
					}
					AssetBundle val = AssetBundle.GetAllLoadedAssetBundles().FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle bundle) => ((Object)bundle).name.Contains(Path.GetFileNameWithoutExtension(fileName))));
					if ((Object)(object)val == (Object)null)
					{
						val = AssetBundle.LoadFromFile(fileName);
						if ((Object)(object)val == (Object)null)
						{
							Debug.LogWarning((object)("Failed to load AssetBundle " + fileName));
							return false;
						}
					}
					string[] allAssetNames = val.GetAllAssetNames();
					foreach (string text in allAssetNames)
					{
						GameObject val2 = val.LoadAsset<GameObject>(text);
						if ((Object)(object)val2 != (Object)null && val2.TryGetComponent<T>(ref asset))
						{
							Debug.Log((object)("Found " + asset.GetType().ToString() + " bundle"));
							return true;
						}
					}
				}
			}
			else
			{
				Debug.LogError((object)"Specified path doesn't exist");
			}
			return false;
		}

		public static bool FindAssetBundle<T>(out T asset) where T : class
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			asset = null;
			string directoryName = Path.GetDirectoryName(Assembly.GetCallingAssembly().Location);
			Debug.Log((object)directoryName);
			if (Directory.Exists(directoryName))
			{
				string[] files = Directory.GetFiles(directoryName);
				foreach (string fileName in files)
				{
					if (!fileName.Contains(((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower()))
					{
						continue;
					}
					AssetBundle val = AssetBundle.GetAllLoadedAssetBundles().FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle bundle) => ((Object)bundle).name.Contains(Path.GetFileNameWithoutExtension(fileName))));
					if ((Object)(object)val == (Object)null)
					{
						val = AssetBundle.LoadFromFile(fileName);
						if ((Object)(object)val == (Object)null)
						{
							Debug.LogWarning((object)("Failed to load AssetBundle " + fileName));
							return false;
						}
					}
					string[] allAssetNames = val.GetAllAssetNames();
					foreach (string text in allAssetNames)
					{
						GameObject val2 = val.LoadAsset<GameObject>(text);
						if ((Object)(object)val2 != (Object)null && val2.TryGetComponent<T>(ref asset))
						{
							Debug.Log((object)("Found " + asset.GetType().ToString() + " bundle"));
							return true;
						}
					}
				}
			}
			else
			{
				Debug.LogError((object)"Specified path doesn't exist");
			}
			return false;
		}
	}
	public static class CodeMatcherExtensions
	{
		private static FieldRef<CodeMatcher, ILGenerator> codeMatcherILGeneratorField = AccessTools.FieldRefAccess<CodeMatcher, ILGenerator>("generator");

		private static FieldRef<object, CecilILGenerator> ilGeneratorMethodInfoField;

		private static List<string> originalInstructionsHelp = new List<string>();

		private static List<string> currentInstructionsHelp = new List<string>();

		public static void Print(this CodeMatcher matcher, ManualLogSource logger = null, ConsoleColor consoleColor = ConsoleColor.Gray)
		{
			CodeInstruction[] array = matcher.InstructionEnumeration().ToArray();
			ILGenerator iLGenerator = codeMatcherILGeneratorField.Invoke(matcher);
			if (iLGenerator != null)
			{
				if (ilGeneratorMethodInfoField == null)
				{
					ilGeneratorMethodInfoField = AccessTools.FieldRefAccess<CecilILGenerator>(iLGenerator.GetType(), "Target");
				}
				MethodDefinition method = ilGeneratorMethodInfoField.Invoke((object)iLGenerator).IL.Body.Method;
				if (method != null)
				{
					string text = "------ " + ((MemberReference)method).Name + " ------";
					if (logger == null)
					{
						Debug.Log((object)"");
						Debug.Log((object)text);
						Debug.Log((object)"");
					}
					else
					{
						logger.LogInfoWithColor("", consoleColor);
						logger.LogInfoWithColor(text, consoleColor);
						logger.LogInfoWithColor("", consoleColor);
					}
				}
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (logger == null)
				{
					Debug.Log((object)array[i]);
				}
				else
				{
					logger.LogInfoWithColor(array[i], consoleColor);
				}
			}
		}

		public static void Print(this MethodBase method, ManualLogSource logger, CodeMatcher currentMatcher, ConsoleColor differenceColor = ConsoleColor.Yellow, ConsoleColor duplicateColor = ConsoleColor.DarkGray)
		{
			List<CodeInstruction> originalInstructions = PatchProcessor.GetOriginalInstructions(method, (ILGenerator)null);
			List<CodeInstruction> list = currentMatcher.InstructionEnumeration().ToList();
			for (int i = 0; i < originalInstructions.Count; i++)
			{
				originalInstructionsHelp.Add(originalInstructions[i].opcode.ToString() + " " + ((originalInstructions[i].operand == null) ? "" : originalInstructions[i].operand.ToString()));
			}
			for (int j = 0; j < list.Count; j++)
			{
				currentInstructionsHelp.Add(list[j].opcode.ToString() + " " + ((list[j].operand == null) ? "" : list[j].operand.ToString()));
			}
			int num = 0;
			for (int k = 0; k < list.Count; k++)
			{
				if (list[k].opcode == originalInstructions[k - num].opcode && list[k].operand == originalInstructions[k - num].operand)
				{
					logger.LogInfoWithColor(list[k], duplicateColor);
					continue;
				}
				logger.LogInfoWithColor(list[k], differenceColor);
				logger.LogInfoWithColor($"{list[k]} doesn't match with {originalInstructions[k - num]}", ConsoleColor.DarkYellow);
				num++;
			}
		}

		public static MethodInfo GetMethod(this Type type, string method_signature)
		{
			string text = method_signature;
			BindingFlags bindingFlags = BindingFlags.Default;
			Type type2 = null;
			string text2 = "";
			new List<Tuple<Type, ParameterModifier>>();
			Match match = Regex.Match(text, "^\\s*(public|protected|private)\\s*", RegexOptions.Multiline);
			bindingFlags = ((!match.Success) ? (bindingFlags | (BindingFlags.Public | BindingFlags.NonPublic)) : ((BindingFlags)((int)bindingFlags | ((match.ToString() == "public") ? 16 : 32))));
			text = text.Remove(0, match.Length);
			Match match2 = Regex.Match(text, "^\\s*static\\s*", RegexOptions.Multiline);
			bindingFlags = ((!match2.Success) ? (bindingFlags | BindingFlags.Instance) : (bindingFlags | BindingFlags.Static));
			text = text.Remove(0, match2.Length);
			Match match3 = Regex.Match(text, "(\\w|\\.)+(?=\\.\\w+\\()", RegexOptions.Multiline);
			if (match3.Success)
			{
				type2 = Type.GetType(match3.ToString());
				if (type2 == null)
				{
					Debug.LogError((object)("Couldn't find a type with name " + match3.ToString() + " Check if you formatted it properly"));
					return null;
				}
				text = text.Remove(0, match3.Index + match3.Length + 1);
				Match match4 = Regex.Match(text, "\\w+(?=\\(.+\\))");
				if (match4.Success)
				{
					text2 = match4.ToString();
					text = text.Remove(0, match3.Index + match3.Length + 1);
					try
					{
						return type2.GetMethod(text2, bindingFlags);
					}
					catch (AmbiguousMatchException)
					{
					}
					text = text.TrimStart(Array.Empty<char>()).TrimStart(new char[1] { '(' }).TrimStart(Array.Empty<char>());
					if (text[0] == ')')
					{
						return type2.GetMethod(text2, new Type[0]);
					}
					Match match5 = Regex.Match(text, "(ref|out)\\s+(\\w+\\.\\w*)");
					if (match5.Success)
					{
						_ = Type.GetType(match5.Groups[1].ToString()) == null;
						return null;
					}
					return null;
				}
				Debug.LogError((object)("Couldn't find a method name in method signature " + method_signature + " Check if you formatted it properly"));
				return null;
			}
			Debug.LogError((object)("Couldn't find class name in method signature " + method_signature + " Check if you formatted it properly"));
			return null;
		}
	}
	public static class FMODLookForTapeFilterBytes
	{
		[StructLayout(LayoutKind.Explicit, Size = 24)]
		private struct UnknownArrayElement
		{
			[FieldOffset(0)]
			public byte fullOfMilk;

			[FieldOffset(16)]
			public uint lengthOfSomethingIThink;

			[FieldOffset(20)]
			public uint eventLength;
		}

		private static readonly byte[] pattern = new byte[288]
		{
			0, 88, 219, 250, 206, 65, 203, 76, 161, 5,
			223, 236, 49, 64, 2, 19, 0, 249, 21, 0,
			0, 249, 21, 0, 15, 117, 62, 208, 228, 72,
			187, 76, 168, 81, 110, 73, 168, 106, 115, 214,
			0, 0, 0, 0, 0, 249, 21, 0, 26, 9,
			165, 144, 39, 106, 228, 64, 191, 195, 18, 94,
			80, 216, 143, 84, 0, 0, 0, 0, 185, 189,
			43, 0, 26, 80, 229, 42, 97, 248, 228, 68,
			162, 126, 128, 159, 203, 236, 232, 3, 0, 242,
			43, 0, 0, 249, 21, 0, 96, 33, 197, 1,
			51, 14, 241, 70, 185, 238, 224, 104, 66, 64,
			214, 115, 0, 214, 131, 0, 128, 14, 8, 0,
			128, 62, 89, 173, 250, 253, 86, 67, 158, 234,
			170, 237, 77, 247, 19, 99, 0, 228, 87, 0,
			0, 249, 21, 0, 159, 81, 79, 146, 243, 164,
			119, 78, 174, 13, 15, 130, 13, 75, 33, 2,
			0, 221, 109, 0, 0, 249, 21, 0, 176, 29,
			82, 245, 139, 207, 107, 70, 191, 143, 0, 192,
			242, 246, 95, 207, 74, 59, 131, 0, 54, 169,
			8, 0, 202, 71, 135, 89, 106, 150, 219, 71,
			141, 147, 89, 251, 129, 226, 210, 55, 145, 125,
			87, 0, 185, 189, 43, 0, 208, 170, 8, 192,
			50, 53, 24, 64, 144, 196, 187, 77, 58, 161,
			13, 134, 185, 189, 43, 0, 185, 189, 43, 0,
			219, 123, 25, 11, 13, 78, 116, 75, 177, 14,
			102, 234, 191, 227, 196, 153, 0, 0, 0, 0,
			128, 228, 139, 0, 248, 128, 136, 9, 100, 110,
			111, 66, 189, 95, 7, 161, 149, 235, 114, 236,
			0, 235, 65, 0, 0, 249, 21, 0
		};

		private const string k_PatchedName = "Tapes Bank-Patched";

		[HarmonyPatch(typeof(RuntimeManager), "LoadBank", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static void SleightOfHand(ref string bankName)
		{
			if (!(bankName == "Tapes Bank"))
			{
				return;
			}
			if (!File.Exists(Path.Combine(Application.streamingAssetsPath, "Tapes Bank-Patched.bank")))
			{
				if (!SwapAndPatchBank())
				{
					Debug.LogError((object)"Failed to swap and patch bank");
				}
				else
				{
					Debug.Log((object)"Successfully patched Tapes Bank");
				}
			}
			bankName = "Tapes Bank-Patched";
		}

		private unsafe static bool SwapAndPatchBank()
		{
			File.Copy(Path.Combine(Application.streamingAssetsPath, "Tapes Bank.bank"), Path.Combine(Application.streamingAssetsPath, "Tapes Bank-Patched.bank"));
			using (FileStream fileStream = File.Open(Path.Combine(Application.streamingAssetsPath, "Tapes Bank-Patched.bank"), FileMode.Open, FileAccess.ReadWrite, FileShare.None))
			{
				byte[] array = new byte[8];
				bool flag = false;
				long offset = 0L;
				while (fileStream.Position < fileStream.Length && !flag)
				{
					offset = fileStream.Position;
					for (int num = 0; num < 8; num = fileStream.Read(array, num, 8))
					{
					}
					for (int i = 0; array[0] == pattern[i] && array[1] == pattern[i + 1] && array[2] == pattern[i + 2] && array[3] == pattern[i + 3] && array[4] == pattern[i + 4] && array[5] == pattern[i + 5] && array[6] == pattern[i + 6] && array[7] == pattern[i + 7]; i += 8)
					{
						fileStream.Read(array, 0, 8);
						if (i == pattern.Length - 8)
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					byte[] array2 = new byte[pattern.Length];
					Array.Copy(pattern, 0, array2, 0, pattern.Length);
					for (int j = 0; j < array2.Length; j += 24)
					{
						fixed (byte* ptr = &array2[j])
						{
							UnknownArrayElement* ptr2 = (UnknownArrayElement*)ptr;
							ptr2->eventLength = uint.MaxValue;
						}
					}
					fileStream.Seek(offset, SeekOrigin.Begin);
					fileStream.Write(array2, 0, pattern.Length);
					fileStream.Flush();
					return true;
				}
			}
			return false;
		}
	}
	public static class FMODUnityExplorerHelper
	{
		private static class EventInstance
		{
			private static T GetUserData<T>(EventInstance eventInstance)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				IntPtr ptr = default(IntPtr);
				if (!Utility.IsError(((EventInstance)(ref eventInstance)).getUserData(ref ptr), "GetUserData"))
				{
					return Marshal.PtrToStructure<T>(ptr);
				}
				return default(T);
			}

			private static EventDescription GetEventDescription(EventInstance eventInstance)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				EventDescription result = default(EventDescription);
				if (!Utility.IsError(((EventInstance)(ref eventInstance)).getDescription(ref result), "GetEventDescription"))
				{
					return result;
				}
				return default(EventDescription);
			}

			private static void SetTimelinePosition(EventInstance eventInstance, int position)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				Utility.IsError(((EventInstance)(ref eventInstance)).setTimelinePosition(position), "SetTimelinePosition");
			}

			private static float GetParameterByID(EventInstance eventInstance, PARAMETER_ID id)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				float result = default(float);
				if (!Utility.IsError(((EventInstance)(ref eventInstance)).getParameterByID(id, ref result)))
				{
					return result;
				}
				return 0f;
			}

			private static (float, float) GetParametersByID(EventInstance eventInstance, PARAMETER_ID id)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				float item = default(float);
				float item2 = default(float);
				if (!Utility.IsError(((EventInstance)(ref eventInstance)).getParameterByID(id, ref item, ref item2)))
				{
					return (item, item2);
				}
				return (0f, 0f);
			}

			private static ChannelGroup GetChannelGroup(EventInstance eventInstance)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				ChannelGroup result = default(ChannelGroup);
				if (!Utility.IsError(((EventInstance)(ref eventInstance)).getChannelGroup(ref result)))
				{
					return result;
				}
				return default(ChannelGroup);
			}
		}

		private static class ChannelGroup
		{
			private static MODE GetMode(ChannelGroup group)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				MODE result = default(MODE);
				if (!Utility.IsError(((ChannelGroup)(ref group)).getMode(ref result)))
				{
					return result;
				}
				return (MODE)0;
			}

			private static ChannelGroup GetChannelGroup(ChannelGroup group, int index)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				ChannelGroup result = default(ChannelGroup);
				if (!Utility.IsError(((ChannelGroup)(ref group)).getGroup(index, ref result)))
				{
					return result;
				}
				return default(ChannelGroup);
			}

			private static int GetNumGroups(ChannelGroup group)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				int result = default(int);
				if (!Utility.IsError(((ChannelGroup)(ref group)).getNumGroups(ref result)))
				{
					return result;
				}
				return 0;
			}

			private static Sound[] DebugLogGroups(ChannelGroup group)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				int num = default(int);
				if (!Utility.IsError(((ChannelGroup)(ref group)).getNumGroups(ref num), "DebugLogGroups"))
				{
					List<Sound> list = new List<Sound>();
					ChannelGroup val = default(ChannelGroup);
					string text = default(string);
					for (int i = 0; i < num; i++)
					{
						if (!Utility.IsError(((ChannelGroup)(ref group)).getGroup(i, ref val), "DebugLogGroups 1") && !Utility.IsError(((ChannelGroup)(ref group)).getName(ref text, 256), "DebugLogGroups 2"))
						{
							Debug.Log((object)text);
							DebugLogGroups(val);
							list.AddRange(DebugLogChannels(val));
						}
					}
					return list.ToArray();
				}
				return null;
			}

			private static Sound[] DebugLogChannels(ChannelGroup group)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				int num = default(int);
				if (!Utility.IsError(((ChannelGroup)(ref group)).getNumChannels(ref num), "DebugLogChannels"))
				{
					Debug.Log((object)$"numchannel: {num}");
					List<Sound> list = new List<Sound>();
					Channel val = default(Channel);
					MODE val2 = default(MODE);
					Sound item = default(Sound);
					string text = default(string);
					uint num2 = default(uint);
					int num3 = default(int);
					uint num4 = default(uint);
					uint num5 = default(uint);
					uint num6 = default(uint);
					for (int i = 0; i < num; i++)
					{
						if (Utility.IsError(((ChannelGroup)(ref group)).getChannel(i, ref val), "DebugLogChannels 1"))
						{
							continue;
						}
						if (!Utility.IsError(((Channel)(ref val)).getMode(ref val2), "DebugLogChannels 2"))
						{
							Debug.Log((object)val2);
						}
						if (!Utility.IsError(((Channel)(ref val)).getCurrentSound(ref item), "DebugLogChannels 3"))
						{
							if (!Utility.IsError(((Sound)(ref item)).getName(ref text, 256), "DebugLogChannels 3.1"))
							{
								Debug.Log((object)text);
							}
							if (!Utility.IsError(((Sound)(ref item)).getLength(ref num2, (TIMEUNIT)1), "DebugLogChannels 3.2"))
							{
								Debug.Log((object)$"length: {num2}");
							}
							if (!Utility.IsError(((Sound)(ref item)).getLoopCount(ref num3), "DebugLogChannels 3.3"))
							{
								Debug.Log((object)$"loop count: {num3}");
								if (!Utility.IsError(((Sound)(ref item)).getLoopPoints(ref num4, (TIMEUNIT)1, ref num5, (TIMEUNIT)1)))
								{
									Debug.Log((object)$"loop start: {num4}");
									Debug.Log((object)$"loop end: {num5}");
								}
							}
							list.Add(item);
						}
						if (!Utility.IsError(((Channel)(ref val)).getPosition(ref num6, (TIMEUNIT)1), "DebugLogChannels 4"))
						{
							Debug.Log((object)$"pos: {num6}");
						}
					}
					return list.ToArray();
				}
				return null;
			}
		}

		private static class Channel
		{
		}

		private static class EventDescription
		{
			private static int GetLength(EventDescription eventDescription)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				int result = default(int);
				if (!Utility.IsError(((EventDescription)(ref eventDescription)).getLength(ref result), "GetLength"))
				{
					return result;
				}
				return 0;
			}

			private static void DebugLogParameters(EventDescription eventDescription)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				int num = default(int);
				if (Utility.IsError(((EventDescription)(ref eventDescription)).getParameterDescriptionCount(ref num), "DebugLogParameters"))
				{
					return;
				}
				PARAMETER_DESCRIPTION val = default(PARAMETER_DESCRIPTION);
				for (int i = 0; i < num; i++)
				{
					if (!Utility.IsError(((EventDescription)(ref eventDescription)).getParameterDescriptionByIndex(i, ref val), StringWrapper.op_Implicit(val.name)))
					{
						Debug.Log((object)("name: " + StringWrapper.op_Implicit(val.name)));
						Debug.Log((object)$"id data 1: {val.id.data1}");
						Debug.Log((object)$"id data 2: {val.id.data2}");
						Debug.Log((object)$"minimum: {val.minimum}");
						Debug.Log((object)$"default: {val.defaultvalue}");
						Debug.Log((object)$"maximum: {val.maximum}");
						Debug.Log((object)$"type: {val.type}");
						Debug.Log((object)$"flags: {val.flags}");
					}
				}
			}
		}

		private static class Sound
		{
			private static int GetLoopCount(Sound sound)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				int result = default(int);
				if (!Utility.IsError(((Sound)(ref sound)).getLoopCount(ref result), "GetLoopCount"))
				{
					return result;
				}
				return 0;
			}
		}

		private static class System
		{
			private static Bank[] GetBanks(System system)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				Bank[] result = default(Bank[]);
				if (!Utility.IsError(((System)(ref system)).getBankList(ref result)))
				{
					return result;
				}
				return null;
			}
		}

		public static object KetsupBlast(IntPtr handle)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			System coreSystem = RuntimeManager.CoreSystem;
			if (coreSystem.handle == handle)
			{
				return coreSystem;
			}
			IntPtr intPtr = default(IntPtr);
			if ((int)((System)(ref coreSystem)).getOutputHandle(ref intPtr) == 0 && intPtr == handle)
			{
				return handle;
			}
			ChannelGroup val = default(ChannelGroup);
			if ((int)((System)(ref coreSystem)).getMasterChannelGroup(ref val) == 0)
			{
				if (val.handle == handle)
				{
					return val;
				}
				object obj = RecurseThroughChannelGroup(val);
				if (obj != null)
				{
					return obj;
				}
			}
			SoundGroup val2 = default(SoundGroup);
			if ((int)((System)(ref coreSystem)).getMasterSoundGroup(ref val2) == 0)
			{
				if (val2.handle == handle)
				{
					return val2;
				}
				int num = default(int);
				((SoundGroup)(ref val2)).getNumSounds(ref num);
				Sound val3 = default(Sound);
				for (int i = 0; i < num; i++)
				{
					((SoundGroup)(ref val2)).getSound(i, ref val3);
					if (val3.handle == handle)
					{
						return handle;
					}
					object obj2 = RecurseThroughSound(val3);
					if (obj2 != null)
					{
						return obj2;
					}
				}
			}
			IntPtr intPtr2 = default(IntPtr);
			if ((int)((System)(ref coreSystem)).getUserData(ref intPtr2) == 0 && intPtr2 == handle)
			{
				return intPtr2;
			}
			System studioSystem = RuntimeManager.StudioSystem;
			if (studioSystem.handle == handle)
			{
				return studioSystem;
			}
			Bank[] array = default(Bank[]);
			if ((int)((System)(ref studioSystem)).getBankList(ref array) == 0)
			{
				int num2 = array.Length;
				EventDescription[] array2 = default(EventDescription[]);
				for (int j = 0; j < num2; j++)
				{
					((Bank)(ref array[j])).getEventList(ref array2);
					int num3 = array2.Length;
					for (int k = 0; k < num3; k++)
					{
						if (array2[k].handle == handle)
						{
							return array2[k];
						}
					}
				}
			}
			return null;
			object RecurseThroughChannelGroup(ChannelGroup channelGroup)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				int num4 = default(int);
				((ChannelGroup)(ref channelGroup)).getNumChannels(ref num4);
				Channel val4 = default(Channel);
				Sound val5 = default(Sound);
				for (int l = 0; l < num4; l++)
				{
					if ((int)((ChannelGroup)(ref channelGroup)).getChannel(l, ref val4) == 0)
					{
						if (val4.handle == handle)
						{
							return val4;
						}
						if ((int)((Channel)(ref val4)).getCurrentSound(ref val5) == 0 && val5.handle == handle)
						{
							return val5;
						}
					}
				}
				int num5 = default(int);
				((ChannelGroup)(ref channelGroup)).getNumGroups(ref num5);
				ChannelGroup channelGroup2 = default(ChannelGroup);
				for (int m = 0; m < num5; m++)
				{
					if ((int)((ChannelGroup)(ref channelGroup)).getGroup(m, ref channelGroup2) == 0)
					{
						object obj3 = RecurseThroughChannelGroup(channelGroup2);
						if (obj3 != null)
						{
							return obj3;
						}
					}
				}
				return null;
			}
			object RecurseThroughSound(Sound sound)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				int num4 = default(int);
				if ((int)((Sound)(ref sound)).getNumSubSounds(ref num4) == 0)
				{
					Sound val4 = default(Sound);
					SoundGroup val5 = default(SoundGroup);
					for (int l = 0; l < num4; l++)
					{
						if ((int)((Sound)(ref sound)).getSubSound(l, ref val4) == 0)
						{
							if (val4.handle == handle)
							{
								return val4;
							}
							if ((int)((Sound)(ref val4)).getSoundGroup(ref val5) == 0 && val5.handle == handle)
							{
								return val5;
							}
							object obj3 = RecurseThroughSound(val4);
							if (obj3 != null)
							{
								return obj3;
							}
						}
					}
				}
				return null;
			}
		}
	}
	public static class LinuxELFExecstackPatcher
	{
		public static bool PatchFlag(string filePath)
		{
			if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
			{
				Debug.LogWarning((object)"Patch ELF Flags called on non-linux platform");
				return false;
			}
			Debug.Log((object)filePath);
			using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
			{
				uint num = 0u;
				byte[] array = new byte[8];
				fileStream.Seek(32L, SeekOrigin.Begin);
				fileStream.Read(array, 0, 8);
				num = BitConverter.ToUInt32(array, 0);
				int num2 = 0;
				byte[] array2 = new byte[2];
				fileStream.Seek(54L, SeekOrigin.Begin);
				fileStream.Read(array2, 0, 2);
				num2 = BitConverter.ToUInt16(array2, 0);
				int num3 = 0;
				byte[] array3 = new byte[2];
				fileStream.Seek(56L, SeekOrigin.Begin);
				fileStream.Read(array3, 0, 2);
				num3 = BitConverter.ToUInt16(array3, 0);
				byte[] array4 = new byte[4];
				for (long num4 = 0L; num4 < num3; num4++)
				{
					fileStream.Seek(num + num4 * num2, SeekOrigin.Begin);
					fileStream.Read(array4, 0, 4);
					if (BitConverter.ToUInt32(array4, 0) == 1685382481)
					{
						Debug.Log((object)"found gnu stack ident");
						byte[] array5 = new byte[4];
						fileStream.Seek(num + num4 * num2 + 4, SeekOrigin.Begin);
						fileStream.Read(array5, 0, 4);
						if ((array5[0] & 1) == 0)
						{
							Debug.Log((object)"flag is already patched, skipping");
							return false;
						}
						array5[0] &= 254;
						fileStream.Seek(num + num4 * num2 + 4, SeekOrigin.Begin);
						fileStream.Write(array5, 0, 4);
						fileStream.Flush();
						fileStream.Close();
						Debug.Log((object)"patched flag");
						return true;
					}
				}
				Debug.Log((object)"failed to find gnu stack entry, sorry!");
			}
			return false;
		}
	}
	public class SmartCodeMatcher
	{
		public class Condition
		{
		}

		public CodeMatcher matcher;

		public int Pos
		{
			get
			{
				return matcher.Pos;
			}
			set
			{
				Start();
				Advance(value);
			}
		}

		public int Length => matcher.Length;

		public bool IsValid => matcher.IsValid;

		public bool IsInvalid => matcher.IsInvalid;

		public int Remaining => matcher.Remaining;

		public ref OpCode Opcode => ref matcher.Opcode;

		public ref object Operand => ref matcher.Operand;

		public ref List<Label> Labels => ref matcher.Labels;

		public ref List<ExceptionBlock> Blocks => ref matcher.Blocks;

		public CodeInstruction Instruction => matcher.Instruction;

		public SmartCodeMatcher()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			matcher = new CodeMatcher();
		}

		public SmartCodeMatcher(IEnumerable<CodeInstruction> instructions, ILGenerator generator = null)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			matcher = new CodeMatcher(instructions, generator);
		}

		public SmartCodeMatcher Clone()
		{
			return new SmartCodeMatcher
			{
				matcher = matcher.Clone()
			};
		}

		public CodeInstruction InstructionAt(int offset)
		{
			return matcher.InstructionAt(offset);
		}

		public List<CodeInstruction> Instructions()
		{
			return matcher.Instructions();
		}

		public IEnumerable<CodeInstruction> InstructionEnumeration()
		{
			return matcher.InstructionEnumeration();
		}

		public List<CodeInstruction> Instructions(int count)
		{
			return matcher.Instructions(count);
		}

		public List<CodeInstruction> InstructionsInRange(int start, int end)
		{
			return matcher.InstructionsInRange(start, end);
		}

		public List<CodeInstruction> InstructionsWithOffsets(int startOffset, int endOffset)
		{
			return InstructionsInRange(Pos + startOffset, Pos + endOffset);
		}

		public List<Label> DistinctLabels(IEnumerable<CodeInstruction> instructions)
		{
			return matcher.DistinctLabels(instructions);
		}

		public bool ReportFailure(MethodBase method, Action<string> logger)
		{
			return matcher.ReportFailure(method, logger);
		}

		public SmartCodeMatcher ContinueIfValid(MethodBase method, Action<string> logger)
		{
			if (!ReportFailure(method, logger))
			{
				return this;
			}
			return null;
		}

		public SmartCodeMatcher ThrowIfInvalid(string explanation)
		{
			matcher.ThrowIfInvalid(explanation);
			return this;
		}

		public SmartCodeMatcher ThrowIfNotMatch(string explanation, params CodeMatch[] matches)
		{
			matcher.ThrowIfNotMatch(explanation, matches);
			return this;
		}

		public SmartCodeMatcher ThrowIfNotMatchForward(string explanation, params CodeMatch[] matches)
		{
			matcher.ThrowIfNotMatchForward(explanation, matches);
			return this;
		}

		public SmartCodeMatcher ThrowIfNotMatchBack(string explanation, params CodeMatch[] matches)
		{
			matcher.ThrowIfNotMatchBack(explanation, matches);
			return this;
		}

		public SmartCodeMatcher ThrowIfFalse(string explanation, Func<CodeMatcher, bool> stateCheckFunc)
		{
			matcher.ThrowIfFalse(explanation, stateCheckFunc);
			return this;
		}

		public SmartCodeMatcher SetInstruction(CodeInstruction instruction)
		{
			if (matcher.IsValid)
			{
				matcher.SetInstruction(instruction);
			}
			return this;
		}

		public SmartCodeMatcher SetInstructionAndAdvance(CodeInstruction instruction)
		{
			if (matcher.IsValid)
			{
				matcher.SetInstructionAndAdvance(instruction);
			}
			return this;
		}

		public SmartCodeMatcher Set(OpCode opcode, object operand)
		{
			if (matcher.IsValid)
			{
				matcher.Set(opcode, operand);
			}
			return this;
		}

		public SmartCodeMatcher SetAndAdvance(OpCode opcode, object operand)
		{
			if (matcher.IsValid)
			{
				matcher.SetAndAdvance(opcode, operand);
			}
			return this;
		}

		public SmartCodeMatcher SetOpcodeAndAdvance(OpCode opcode)
		{
			if (matcher.IsValid)
			{
				matcher.SetOpcodeAndAdvance(opcode);
			}
			return this;
		}

		public SmartCodeMatcher SetOperandAndAdvance(object operand)
		{
			if (matcher.IsValid)
			{
				matcher.SetOperandAndAdvance(operand);
			}
			return this;
		}

		public SmartCodeMatcher CreateLabel(out Label label)
		{
			if (matcher.IsValid)
			{
				matcher.CreateLabel(ref label);
			}
			return this;
		}

		public SmartCodeMatcher CreateLabelAt(int position, out Label label)
		{
			matcher.CreateLabelAt(position, ref label);
			return this;
		}

		public SmartCodeMatcher AddLabels(IEnumerable<Label> labels)
		{
			if (matcher.IsValid)
			{
				matcher.AddLabels(labels);
			}
			return this;
		}

		public SmartCodeMatcher AddLabelsAt(int position, IEnumerable<Label> labels)
		{
			matcher.AddLabelsAt(position, labels);
			return this;
		}

		public SmartCodeMatcher SetJumpTo(OpCode opcode, int destination, out Label label)
		{
			if (matcher.IsValid)
			{
				matcher.SetJumpTo(opcode, destination, ref label);
			}
			return this;
		}

		public SmartCodeMatcher Insert(OpCode opcode, object operand = null)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (matcher.IsValid)
			{
				matcher.Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(opcode, operand)
				});
			}
			return this;
		}

		public SmartCodeMatcher Insert(params CodeInstruction[] instructions)
		{
			if (matcher.IsValid)
			{
				matcher.Insert(instructions);
			}
			return this;
		}

		public SmartCodeMatcher Insert(IEnumerable<CodeInstruction> instructions)
		{
			if (matcher.IsValid)
			{
				matcher.Insert(instructions);
			}
			return this;
		}

		public SmartCodeMatcher InsertBranch(OpCode opcode, int destination)
		{
			if (matcher.IsValid)
			{
				matcher.InsertBranch(opcode, destination);
			}
			return this;
		}

		public SmartCodeMatcher InsertAndAdvance(OpCode opcode, object operand = null)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (matcher.IsValid)
			{
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(opcode, operand)
				});
			}
			return this;
		}

		public SmartCodeMatcher InsertAndAdvance(params CodeInstruction[] instructions)
		{
			if (matcher.IsValid)
			{
				matcher.InsertAndAdvance(instructions);
			}
			return this;
		}

		public SmartCodeMatcher InsertAndAdvance(IEnumerable<CodeInstruction> instructions)
		{
			if (matcher.IsValid)
			{
				matcher.InsertAndAdvance(instructions);
			}
			return this;
		}

		public SmartCodeMatcher InsertBranchAndAdvance(OpCode opcode, int destination)
		{
			if (matcher.IsValid)
			{
				matcher.InsertBranchAndAdvance(opcode, destination);
			}
			return this;
		}

		public SmartCodeMatcher RemoveInstruction()
		{
			if (matcher.IsValid)
			{
				matcher.RemoveInstruction();
			}
			return this;
		}

		public SmartCodeMatcher RemoveInstructions(int count)
		{
			if (matcher.IsValid)
			{
				matcher.RemoveInstructions(count);
			}
			return this;
		}

		public SmartCodeMatcher RemoveInstructionsInRange(int start, int end)
		{
			matcher.RemoveInstructionsInRange(start, end);
			return this;
		}

		public SmartCodeMatcher RemoveInstructionsWithOffsets(int startOffset, int endOffset)
		{
			if (matcher.IsValid)
			{
				matcher.RemoveInstructionsWithOffsets(startOffset, endOffset);
			}
			return this;
		}

		public SmartCodeMatcher Advance(int offset = 1)
		{
			if (matcher.IsValid)
			{
				matcher.Advance(offset);
			}
			return this;
		}

		public SmartCodeMatcher Start()
		{
			matcher.Start();
			return this;
		}

		public SmartCodeMatcher End()
		{
			matcher.End();
			return this;
		}

		public SmartCodeMatcher SearchForward(Func<CodeInstruction, bool> predicate)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.SearchForward(predicate);
			return this;
		}

		public SmartCodeMatcher SearchBack(Func<CodeInstruction, bool> predicate)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.SearchBack(predicate);
			return this;
		}

		public SmartCodeMatcher MatchForward(bool useEnd, params CodeMatch[] matches)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.MatchForward(useEnd, matches);
			return this;
		}

		public SmartCodeMatcher MatchBack(bool useEnd, params CodeMatch[] matches)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.MatchBack(useEnd, matches);
			return this;
		}

		public SmartCodeMatcher MatchStartForward(params CodeMatch[] matches)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.MatchStartForward(matches);
			return this;
		}

		public SmartCodeMatcher MatchEndForward(params CodeMatch[] matches)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.MatchEndForward(matches);
			return this;
		}

		public SmartCodeMatcher MatchStartBackwards(params CodeMatch[] matches)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.MatchStartBackwards(matches);
			return this;
		}

		public SmartCodeMatcher MatchEndBackwards(params CodeMatch[] matches)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.MatchEndBackwards(matches);
			return this;
		}

		public SmartCodeMatcher Repeat(Action<CodeMatcher> matchAction, Action<string> notFoundAction = null)
		{
			if (matcher.IsInvalid)
			{
				matcher.Start();
			}
			matcher.Repeat(matchAction, notFoundAction);
			return this;
		}

		public CodeInstruction NamedMatch(string name)
		{
			return matcher.NamedMatch(name);
		}

		public SmartCodeMatcher CreateBranch(OpCode branch_opcode, CodeInstruction[] if_true, CodeInstruction[] if_false = null)
		{
			Insert(OpCodes.Nop);
			InsertBranchAndAdvance(branch_opcode, Pos);
			InsertAndAdvance(if_true);
			if (if_false != null)
			{
				InsertBranchAndAdvance(OpCodes.Br, Pos + 1);
				Advance();
				InsertAndAdvance(if_false);
			}
			return this;
		}

		public static implicit operator CodeMatcher(SmartCodeMatcher matcher)
		{
			return matcher.matcher;
		}
	}
}
namespace Receiver2ModdingKit.Gamemodes
{
	public class DummyGameMode : GameModeBase
	{
		public override GameMode GetGameMode()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ModGameModeBase.ModGameMode;
		}

		public override void StartLevel()
		{
			if ((Object)(object)ModGameModeManager.CurrentGameMode != (Object)null)
			{
				((GameModeBase)ModGameModeManager.CurrentGameMode).StartLevel();
			}
		}

		public override void PostResetLevel()
		{
			if ((Object)(object)ModGameModeManager.CurrentGameMode != (Object)null)
			{
				((GameModeBase)ModGameModeManager.CurrentGameMode).PostResetLevel();
			}
		}

		public override void Restart(bool complete_reset, bool reset_checkpoint)
		{
			if ((Object)(object)ModGameModeManager.CurrentGameMode != (Object)null)
			{
				((GameModeBase)ModGameModeManager.CurrentGameMode).Restart(complete_reset, reset_checkpoint);
			}
		}

		public override JSONObject StoreCheckpoint(CheckpointTrigger trigger_name)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if ((Object)(object)ModGameModeManager.CurrentGameMode != (Object)null)
			{
				return ((GameModeBase)ModGameModeManager.CurrentGameMode).StoreCheckpoint(trigger_name);
			}
			return new JSONObject();
		}

		public override void LoadCheckpoint(JSONObject checkpoint_data)
		{
			if ((Object)(object)ModGameModeManager.CurrentGameMode != (Object)null)
			{
				((GameModeBase)ModGameModeManager.CurrentGameMode).LoadCheckpoint(checkpoint_data);
			}
		}
	}
	public struct GameModeMusicSpec
	{
		public float target_global_gain;

		public float gain_recover_delay;

		public float danger;

		public float mystical;
	}
	public abstract class ModGameModeBase : GameModeBase
	{
		public static readonly GameMode ModGameMode = (GameMode)5;

		public abstract string GameModeName { get; }

		public abstract string SceneName { get; }

		public abstract string SceneAssetBundleName { get; }

		public override GameMode GetGameMode()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ModGameMode;
		}

		public virtual GameModeMusicSpec GetMusicParams()
		{
			return default(GameModeMusicSpec);
		}
	}
	public class ModGameModeManager : MonoBehaviour
	{
		public class ModGameModeLoadData
		{
			public ModGameModeBase game_mode;

			public FileInfo scene_bundle_file;

			public AssetBundle scene_bundle;
		}

		public static bool DisplayGameModeMenu = false;

		public static bool SuppressMenu = false;

		private static ModGameModeBase chosen_gamemode;

		private static SensoryTank mod_gamemode_tank;

		private static ModGameModeLoadData current_game_mode;

		public static ModGameModeManager Instance { get; private set; }

		public static Dictionary<string, ModGameModeLoadData> GameModes { get; private set; } = new Dictionary<string, ModGameModeLoadData>();

		public static ModGameModeBase CurrentGameMode
		{
			get
			{
				if (current_game_mode != null)
				{
					return current_game_mode.game_mode;
				}
				return null;
			}
		}

		internal IEnumerator FindGamemodes(string path)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(path);
			if (!directoryInfo.Exists)
			{
				directoryInfo.Create();
			}
			ModGameModeBase gamemode = default(ModGameModeBase);
			foreach (FileInfo game_mode_file in directoryInfo.EnumerateFiles("*." + ((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower(), SearchOption.AllDirectories))
			{
				IEnumerable<AssetBundle> source = from e in Resources.FindObjectsOfTypeAll<AssetBundle>()
					where game_mode_file.Name.Contains(((Object)e).name)
					select e;
				Debug.Log((object)("Searching file " + game_mode_file.Name));
				AssetBundle bundle;
				if (!source.Any())
				{
					AssetBundleCreateRequest bundle_request = AssetBundle.LoadFromFileAsync(game_mode_file.FullName);
					while (!((AsyncOperation)bundle_request).isDone)
					{
						yield return null;
					}
					bundle = bundle_request.assetBundle;
				}
				else
				{
					bundle = source.First();
				}
				if (bundle.isStreamedSceneAssetBundle)
				{
					bundle.Unload(true);
					continue;
				}
				GameObject[] array = bundle.LoadAllAssets<GameObject>();
				GameObject[] array2 = array;
				for (int num = 0; num < array2.Length; num++)
				{
					if (array2[num].TryGetComponent<ModGameModeBase>(ref gamemode))
					{
						FileInfo fileInfo = new FileInfo(Path.Combine(game_mode_file.Directory.FullName, gamemode.SceneAssetBundleName + "." + ((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower()));
						if (fileInfo.Exists)
						{
							GameModes[gamemode.GameModeName] = new ModGameModeLoadData
							{
								game_mode = gamemode,
								scene_bundle_file = fileInfo
							};
							while ((Object)(object)ReceiverCoreScript.Instance() == (Object)null || (Object)(object)ReceiverCoreScript.Instance().level_manager == (Object)null)
							{
								yield return null;
							}
							ReceiverCoreScript.Instance().level_manager.level_list.scenes.Add(new SceneReferenceInstance
							{
								id = gamemode.GameModeName,
								name = gamemode.SceneName
							});
						}
						else
						{
							Debug.LogError((object)("Could not load file " + fileInfo.FullName));
						}
					}
					gamemode = null;
				}
				bundle.Unload(false);
			}
			Debug.Log((object)("Found gamemodes: " + GameModes.Count));
		}

		private GameModeBase PrepareDummyGameMode()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			GameObject val = new GameObject("Dummy Game Mode Prefab");
			Object.DontDestroyOnLoad((Object)val);
			return (GameModeBase)(object)val.AddComponent<DummyGameMode>();
		}

		private void Awake()
		{
			Instance = this;
			ModdingKitEvents.AddTaskAtCoreStartup(delegate
			{
				((MonoBehaviour)this).StartCoroutine(FindGamemodes(Path.Combine(Application.persistentDataPath, "Gamemodes")));
				ReceiverCoreScript.Instance().game_mode_prefabs.Add(PrepareDummyGameMode());
			});
		}

		private void Update()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if (DisplayGameModeMenu)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
				if (ReInput.players.SystemPlayer.GetButtonDown(510))
				{
					mod_gamemode_tank.ToggleDoor();
					return;
				}
				ImGui.SetNextWindowSize(new Vector2(400f, 300f), (ImGuiCond)4);
				Resolution currentResolution = Screen.currentResolution;
				float num = ((Resolution)(ref currentResolution)).width / 2 - 200;
				currentResolution = Screen.currentResolution;
				ImGui.SetNextWindowPos(new Vector2(num, (float)(((Resolution)(ref currentResolution)).height / 2 - 150)));
				if (!ImGui.Begin("Select Target Gamemode", (ImGuiWindowFlags)32))
				{
					return;
				}
				foreach (KeyValuePair<string, ModGameModeLoadData> gameMode in GameModes)
				{
					ModGameModeBase game_mode = gameMode.Value.game_mode;
					bool flag = (Object)(object)game_mode == (Object)(object)chosen_gamemode;
					if ((Object)(object)game_mode != (Object)null && ImGui.Checkbox(game_mode.GameModeName, ref flag))
					{
						chosen_gamemode = game_mode;
					}
				}
				ImGui.Separator();
				if (ImGui.Button("Launch"))
				{
					ReceiverCoreScript.Instance().StartGameMode(ModGameModeBase.ModGameMode);
					DisplayGameModeMenu = false;
					SuppressMenu = false;
				}
				if (ImGui.Button("Exit"))
				{
					chosen_gamemode = null;
					mod_gamemode_tank.ToggleDoor();
				}
				ImGui.End();
			}
			else
			{
				SuppressMenu = false;
			}
		}

		public static bool RegisterGameMode(string gamemodeSceneAssetBundleName)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			AssetBundle val = (from e in AssetBundle.GetAllLoadedAssetBundles()
				where ((Object)e).name.Contains(gamemodeSceneAssetBundleName)
				select e).FirstOrDefault();
			if ((Object)(object)val == (Object)null)
			{
				string[] files = Directory.GetFiles(new StackTrace().GetFrame(0).GetMethod().DeclaringType.Assembly.Location, "*", SearchOption.AllDirectories);
				foreach (string text in files)
				{
					if (text.EndsWith(gamemodeSceneAssetBundleName + "." + ((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower()))
					{
						val = AssetBundle.LoadFromFile(text);
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				return true;
			}
			return false;
		}

		public static void StartModGameMode(ModGameModeBase game_mode, JSONObject checkpoint)
		{
			if (!((Object)(object)game_mode != (Object)null) || !GameModes.ContainsKey(game_mode.GameModeName))
			{
				return;
			}
			current_game_mode = GameModes[game_mode.GameModeName];
			if ((Object)(object)current_game_mode.scene_bundle == (Object)null && current_game_mode.scene_bundle_file.Exists)
			{
				try
				{
					current_game_mode.scene_bundle = AssetBundle.LoadFromFile(current_game_mode.scene_bundle_file.FullName);
				}
				catch
				{
				}
			}
			ReceiverCoreScript.Instance().level_manager.LoadLevel(current_game_mode.game_mode.GameModeName);
		}

		internal static JSONObject ChooseGameModeFromJSON(JSONObject game_mode_data)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between I4 and Unknown
			if (((JSONNode)game_mode_data)["id"].AsInt == (int)ModGameModeBase.ModGameMode)
			{
				string key = JSONNode.op_Implicit(((JSONNode)game_mode_data)["name"]);
				if (!GameModes.ContainsKey(key))
				{
					Debug.LogError((object)"Attempting to load into a nonexisting mod game mode, falling back on the campaign");
					((JSONNode)game_mode_data).Add("id", JSONNode.op_Implicit(2));
					((JSONNode)game_mode_data).Add("checkpoint", (JSONNode)null);
					return game_mode_data;
				}
				chosen_gamemode = GameModes[key].game_mode;
			}
			return game_mode_data;
		}

		internal unsafe static string GetGameModeName()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			GameMode gameMode = ReceiverCoreScript.Instance().game_mode.GetGameMode();
			if (gameMode != ModGameModeBase.ModGameMode)
			{
				return ((object)(*(GameMode*)(&gameMode))/*cast due to .constrained prefix*/).ToString();
			}
			if ((Object)(object)CurrentGameMode == (Object)null)
			{
				return "";
			}
			return CurrentGameMode.GameModeName;
		}

		private static void UnloadModGameModeBundle()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)CurrentGameMode != (Object)null))
			{
				return;
			}
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				Debug.Log((object)((Object)allLoadedAssetBundle).name);
				if (((Object)allLoadedAssetBundle).name == CurrentGameMode.SceneAssetBundleName + "." + ((object)SystemInfo.operatingSystemFamily/*cast due to .constrained prefix*/).ToString().ToLower())
				{
					Debug.Log((object)("Bundle found" + ((Object)allLoadedAssetBundle).name));
				}
			}
		}

		[HarmonyPatch(typeof(ReceiverCoreScript), "StartGameMode", new Type[]
		{
			typeof(GameMode),
			typeof(JSONObject)
		})]
		[HarmonyPostfix]
		private static void StartModGameModePatch(GameMode mode, JSONObject checkpoint)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (mode != ModGameModeBase.ModGameMode)
			{
				if (current_game_mode != null && (Object)(object)current_game_mode.scene_bundle != (Object)null)
				{
					current_game_mode.scene_bundle.Unload(true);
					current_game_mode.scene_bundle = null;
				}
				chosen_gamemode = null;
				current_game_mode = null;
			}
			else
			{
				StartModGameMode(chosen_gamemode, checkpoint);
			}
		}

		[HarmonyPatch(typeof(SensoryTank), "Start")]
		[HarmonyPostfix]
		private static void SetSensoryTankTarget(SensoryTank __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)__instance).name == "SensoryTank (2)")
			{
				mod_gamemode_tank = __instance;
				((Component)__instance).GetComponent<GameModeTransitionUtility>().target_gamemode = ModGameModeBase.ModGameMode;
			}
		}

		[HarmonyPatch(typeof(SensoryTank), "OnPlayerStay")]
		[HarmonyPrefix]
		private static bool SensoryTankPlayerStay(SensoryTank __instance, bool ___is_open, float ___closed_time)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)__instance).GetComponent<GameModeTransitionUtility>().target_gamemode == ModGameModeBase.ModGameMode)
			{
				if (!___is_open && ___closed_time + 4.1f < Time.time)
				{
					DisplayGameModeMenu = true;
					SuppressMenu = true;
					((Behaviour)LocalAimHandler.player_instance).enabled = false;
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(SensoryTank), "ToggleDoor")]
		[HarmonyPrefix]
		private static void SensoryTankPlayerOpenDoor()
		{
			if (DisplayGameModeMenu)
			{
				DisplayGameModeMenu = false;
				((Behaviour)LocalAimHandler.player_instance).enabled = true;
			}
		}

		[HarmonyPatch(typeof(Player), "GetButtonDown", new Type[] { typeof(int) })]
		[HarmonyPrefix]
		private static bool SuppressMenuWhenInPod(ref int actionId, ref bool __result)
		{
			if (SuppressMenu)
			{
				if (actionId == 51)
				{
					__result = false;
					return false;
				}
				if (actionId == 510)
				{
					actionId = 51;
				}
			}
			return true;
		}
	}
}
namespace Receiver2ModdingKit.Editor
{
	public class AnimatedComponent : MonoBehaviour
	{
		[Serializable]
		public struct Keyframe
		{
			public float time;

			public float value;
		}

		public string path;

		public string mover_name;

		public Keyframe[] X_pos_keyframes;

		public Keyframe[] Y_pos_keyframes;

		public Keyframe[] Z_pos_keyframes;

		public Keyframe[] X_rot_keyframes;

		public Keyframe[] Y_rot_keyframes;

		public Keyframe[] Z_rot_keyframes;
	}
	[RequireComponent(typeof(Collider))]
	public class AssignPhysicsMaterial : MonoBehaviour
	{
		public enum Receiver2PhysicsMaterials
		{
			Brass_Physics,
			Brick,
			Cardboard_Box,
			Ceramic,
			Cloth,
			Concrete,
			Dirt,
			Drywall,
			Flesh,
			Glass,
			Glass_Bulletproof,
			Hard_Metal,
			Metal,
			Metal_Fence,
			Metal_Target_Large,
			Metal_Target_Small,
			Metal_Target_Triple,
			No_Friction,
			Paper,
			Pillow,
			Plant,
			Plastic,
			Pool_Ball,
			Rubber,
			Tile,
			Wood
		}

		public Collider colliderToModify;

		public Receiver2PhysicsMaterials physicsMaterial;

		private static PhysicsMaterialManager physicsMaterialManager;

		private void Awake()
		{
			if ((Object)(object)colliderToModify == (Object)null)
			{
				colliderToModify = ((Component)this).GetComponent<Collider>();
			}
			colliderToModify.sharedMaterial = GetPhysicMaterialForEnum(physicsMaterial);
			Object.Destroy((Object)(object)this);
		}

		private static PhysicMaterial GetPhysicMaterialForEnum(Receiver2PhysicsMaterials receiver2PhysicsMaterials)
		{
			PhysicMaterial result = null;
			if (!Object.op_Implicit((Object)(object)physicsMaterialManager))
			{
				physicsMaterialManager = Object.FindObjectOfType<PhysicsMaterialManager>();
			}
			switch (receiver2PhysicsMaterials)
			{
			case Receiver2PhysicsMaterials.Brass_Physics:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "brass_physics");
				break;
			}
			case Receiver2PhysicsMaterials.Brick:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "brick");
				break;
			}
			case Receiver2PhysicsMaterials.Cardboard_Box:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "cardboard_box");
				break;
			}
			case Receiver2PhysicsMaterials.Ceramic:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "ceramic");
				break;
			}
			case Receiver2PhysicsMaterials.Cloth:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "cloth");
				break;
			}
			case Receiver2PhysicsMaterials.Concrete:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "concrete");
				break;
			}
			case Receiver2PhysicsMaterials.Dirt:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "dirt");
				break;
			}
			case Receiver2PhysicsMaterials.Drywall:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "drywall");
				break;
			}
			case Receiver2PhysicsMaterials.Flesh:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "flesh");
				break;
			}
			case Receiver2PhysicsMaterials.Glass:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "glass");
				break;
			}
			case Receiver2PhysicsMaterials.Glass_Bulletproof:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "glass_bulletproof");
				break;
			}
			case Receiver2PhysicsMaterials.Hard_Metal:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "hard_metal");
				break;
			}
			case Receiver2PhysicsMaterials.Metal:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "metal");
				break;
			}
			case Receiver2PhysicsMaterials.Metal_Fence:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "metal_fence");
				break;
			}
			case Receiver2PhysicsMaterials.Metal_Target_Large:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "metal_target_large");
				break;
			}
			case Receiver2PhysicsMaterials.Metal_Target_Small:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "metal_target_small");
				break;
			}
			case Receiver2PhysicsMaterials.Metal_Target_Triple:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "metal_target_triple");
				break;
			}
			case Receiver2PhysicsMaterials.No_Friction:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "no friction");
				break;
			}
			case Receiver2PhysicsMaterials.Paper:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "paper");
				break;
			}
			case Receiver2PhysicsMaterials.Pillow:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "pillow");
				break;
			}
			case Receiver2PhysicsMaterials.Plant:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "plant");
				break;
			}
			case Receiver2PhysicsMaterials.Plastic:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "plastic");
				break;
			}
			case Receiver2PhysicsMaterials.Pool_Ball:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "pool_ball");
				break;
			}
			case Receiver2PhysicsMaterials.Rubber:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "rubber");
				break;
			}
			case Receiver2PhysicsMaterials.Tile:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "tile");
				break;
			}
			case Receiver2PhysicsMaterials.Wood:
			{
				PhysicMaterial val;
				result = physicsMaterialManager.physics_materials.First((PhysicMaterial material) => (val = material) != null && ((Object)val).name == "wood");
				break;
			}
			}
			return result;
		}
	}
	public class AssignVanillaMuzzleflash : MonoBehaviour
	{
		public GunModel muzzleflashFromGun;
	}
	[CreateAssetMenu(fileName = "Custom Bank list", menuName = "Receiver 2 Modding/Custom Bank List")]
	public class BankList : ScriptableObject, INotifiedByAssetbundleBuild
	{
		public Object[] banks;

		public List<byte> bank_data = new List<byte>();

		public List<int> offsets = new List<int>();

		public bool ready = true;

		public Queue<string> bank_load_queue = new Queue<string>();

		public async void LoadBanks()
		{
		}

		public void ReloadBanks()
		{
		}

		public void ReloadBanksSynchronous()
		{
		}

		public List<byte[]> GetBanks()
		{
			List<byte[]> list = new List<byte[]>();
			for (int i = 0; i < offsets.Count; i++)
			{
				if (i == offsets.Count - 1)
				{
					byte[] array = new byte[bank_data.Count - offsets[i]];
					array = bank_data.GetRange(offsets[i], array.Length).ToArray();
					list.Add(array);
				}
				else
				{
					byte[] array2 = new byte[offsets[i + 1] - offsets[i]];
					array2 = bank_data.GetRange(offsets[i], array2.Length).ToArray();
					list.Add(array2);
				}
			}
			return list;
		}

		public void PreAssetbundleBuild()
		{
			ReloadBanksSynchronous();
		}
	}
	[CreateAssetMenu(fileName = "Custom Sounds list", menuName = "Receiver 2 Modding/Custom Sounds list")]
	public class CustomSoundsList : ScriptableObject
	{
		public enum ForceOptions
		{
			Nothing,
			ForceModdedSounds,
			ForceDefaultSounds
		}

		public static readonly Dictionary<string, int> sound_event_lookup = new Dictionary<string, int>
		{
			{ "sound_event_gunshot", 0 },
			{ "sound_dry_fire", 1 },
			{ "sound_safety_on", 2 },
			{ "sound_safety_off", 3 },
			{ "sound_start_insert_mag", 4 },
			{ "sound_insert_mag_empty", 5 },
			{ "sound_insert_mag_loaded", 6 },
			{ "sound_eject_mag_empty", 7 },
			{ "sound_eject_mag_loaded", 8 },
			{ "sound_double_feed", 9 },
			{ "sound_double_feed_mag_release", 10 },
			{ "sound_extractor_rod_extend", 11 },
			{ "sound_extractor_rod_retract", 12 },
			{ "sound_round_start_eject", 13 },
			{ "sound_cylinder_open", 14 },
			{ "sound_cylinder_close", 15 },
			{ "sound_cylinder_index", 16 },
			{ "sound_press_check_start", 17 },
			{ "sound_press_check_end", 18 },
			{ "sound_barrel_lock", 19 },
			{ "sound_barrel_unlock", 20 },
			{ "sound_eject_bullet", 21 },
			{ "sound_slide_back", 22 },
			{ "sound_slide_back_partial", 23 },
			{ "sound_slide_hit_lock", 24 },
			{ "sound_slide_released", 25 },
			{ "sound_cocked", 26 },
			{ "sound_decock", 27 },
			{ "sound_trigger_forwards", 28 },
			{ "sound_trigger_blocked", 29 },
			{ "sound_trigger_reset", 30 }
		};

		[Tooltip("Prefix used with your sounds")]
		public string prefix;

		[Tooltip("Path to the folder where your sounds are located starting in game's AppData folder")]
		public string sound_path;

		public string[] sound_events = new string[31];

		public string[] fallback_events = new string[31];

		public List<string> custom_event_names = new List<string>();

		public List<string> custom_event_values = new List<string>();

		public List<string> custom_event_fallback_values = new List<string>();

		public ForceOptions force_options;

		private ModGunScript gun;

		private FieldInfo[] sound_fields;

		private List<FieldInfo> custom_sound_fields = new List<FieldInfo>();

		private Dictionary<FieldInfo, string> custom_sound_events_queue = new Dictionary<FieldInfo, string>();

		public void Initialize(ModGunScript gun)
		{
			sound_fields = (from field in typeof(ModGunScript).GetFields(BindingFlags.Instance | BindingFlags.Public)
				where ((MemberInfo)field).GetCustomAttributes<EventRefAttribute>().Count() > 0
				select field).ToArray();
			if (string.IsNullOrEmpty(prefix))
			{
				Debug.LogError((object)("Prefix for gun " + ((InventoryItem)gun).InternalName + "is empty, falling back to gun's name"));
				prefix = ((InventoryItem)gun).InternalName.Substring(prefix.IndexOf(".") + 1);
			}
			if (ModAudioManager.IsPrefixPresent(prefix))
			{
				string text = prefix;
				int num;
				for (num = 1; ModAudioManager.IsPrefixPresent(prefix + "_" + num); num++)
				{
					if (num > 32)
					{
						Debug.LogError((object)("CustomSoundsList.Initialize(): Prefix \"" + prefix + "\" was loaded over 32 times and the next attempt was aborted, something probably went wrong"));
						return;
					}
				}
				string text2 = prefix;
				prefix = prefix + "_" + num;
				FieldInfo[] array = sound_fields;
				foreach (FieldInfo obj in array)
				{
					string text3 = (string)obj.GetValue(gun);
					if (text3.Contains(text2))
					{
						text3.Replace(text2, prefix);
					}
					obj.SetValue(gun, text3);
				}
				Debug.LogWarning((object)("Tried to load sounds with a duplicate prefix \"" + text + "\". They were loaded with \"" + prefix + "\" instead"));
			}
			if (!string.IsNullOrEmpty(sound_path))
			{
				ModAudioManager.LoadCustomEvents(prefix, Path.IsPathRooted(sound_path) ? sound_path : Path.Combine(Application.persistentDataPath, sound_path));
			}
			else
			{
				Debug.LogError((object)("sound_path of audio list for gun " + ((InventoryItem)gun).InternalName + " is empty, falling back on default sounds"));
				force_options = ForceOptions.ForceDefaultSounds;
			}
			if (custom_event_names.Count > custom_event_values.Count)
			{
				custom_event_values.AddRange(new string[custom_event_values.Count - custom_event_names.Count]);
			}
			if (custom_event_names.Count > custom_event_fallback_values.Count)
			{
				custom_event_fallback_values.AddRange(new string[custom_event_fallback_values.Count - custom_event_names.Count]);
			}
			if (Chainloader.PluginInfos.ContainsKey("R2CustomSounds"))
			{
				((object)Chainloader.PluginInfos["R2CustomSounds"].Instance).GetType().Assembly.GetType("R2CustomSounds.ModAudioManager").GetMethod("LoadCustomEvents").Invoke(null, new object[2]
				{
					prefix,
					Path.IsPathRooted(sound_path) ? sound_path : Path.Combine(Application.persistentDataPath, sound_path)
				});
			}
		}

		public void SetSoundEvents()
		{
			if ((Object)(object)gun == (Object)null)
			{
				Debug.LogError((object)"CustomSoundsList.SetSoundEvents(): Attempted to set sound events before calling Initialize()");
				return;
			}
			bool flag = (ModdingKitConfig.use_custom_sounds.Value || force_options == ForceOptions.ForceModdedSounds) && force_options != ForceOptions.ForceDefaultSounds;
			foreach (KeyValuePair<string, int> sound_pair in sound_event_lookup)
			{
				sound_fields.First((FieldInfo info) => info.Name == sound_pair.Key).SetValue(gun, flag ? sound_events[sound_pair.Value] : fallback_events[sound_pair.Value]);
			}
			foreach (FieldInfo custom_sound_field in custom_sound_fields)
			{
				custom_sound_field.SetValue(gun, GetCustomSoundEvent(custom_sound_field.Name));
			}
		}

		public string GetCustomSoundEvent(string name)
		{
			int num = custom_event_names.IndexOf(name);
			if (num < 0)
			{
				return "";
			}
			if (!ModdingKitConfig.use_custom_sounds.Value)
			{
				return custom_event_fallback_values[num];
			}
			return custom_event_values[num];
		}

		internal void BindField(FieldInfo field)
		{
			int num = custom_event_names.IndexOf(field.Name);
			if (num >= 0)
			{
				custom_sound_fields.Add(field);
				custom_sound_events_queue.Add(field, ModdingKitConfig.use_custom_sounds.Value ? custom_event_values[num] : custom_event_fallback_values[num]);
			}
			else
			{
				Debug.LogError((object)("CustomSoundsList.SetSoundEvents(): No custom sound event with a name \"" + field.Name + "\""));
			}
		}

		public void SetGun(ModGunScript gun)
		{
			this.gun = gun;
		}
	}
	public class DoubleStackMagazine : MagazineScript
	{
	}
	public class GunTester : MonoBehaviour
	{
		protected GunScript gun;

		public void Awake()
		{
		}

		public void Update()
		{
		}
	}
	public interface INotifiedByAssetbundleBuild
	{
		void PreAssetbundleBuild();
	}
	public class InBuiltCartridge : MonoBehaviour
	{
		public Preset preset;
	}
	public class ItemWithGlint : MonoBehaviour
	{
	}
}
namespace Receiver2ModdingKit.CustomSounds
{
	public class CustomEventRef : Attribute
	{
		private CustomEventRef()
		{
		}
	}
	public class InstanceAsset
	{
		public EventInstance instance;

		public uint length;

		public InstanceAsset(EventInstance instance, uint length)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			this.instance = instance;
			this.length = length;
		}

		public InstanceAsset(SoundAsset asset)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			instance = RuntimeManager.CreateInstance(asset.type.getEventPath());
			IntPtr userData = GCHandle.ToIntPtr(GCHandle.Alloc(new ModAudioManager.CustomEventInstanceUserData
			{
				sound_handle = asset.sound.handle
			}, GCHandleType.Pinned));
			((EventInstance)(ref instance)).setUserData(userData);
			((EventInstance)(ref instance)).setCallback(ModAudioManager.CUSTOM_SOUNDS_CALLBACK, (EVENT_CALLBACK_TYPE)384);
			length = asset.length;
		}
	}
	public static class ModAudioManager
	{
		public class CustomEventInstanceUserData
		{
			public IntPtr sound_handle;
		}

		public static readonly EVENT_CALLBACK CUSTOM_SOUNDS_CALLBACK = (EVENT_CALLBACK)delegate(EVENT_CALLBACK_TYPE type, EventInstance instance, IntPtr parameters)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			IntPtr value = default(IntPtr);
			((EventInstance)(ref instance)).getUserData(ref value);
			GCHandle gCHandle = GCHandle.FromIntPtr(value);
			CustomEventInstanceUserData customEventInstanceUserData = gCHandle.Target as CustomEventInstanceUserData;
			if ((int)type == 256)
			{
				gCHandle.Free();
				((EventInstance)(ref instance)).stop((STOP_MODE)1);
			}
			else
			{
				PROGRAMMER_SOUND_PROPERTIES structure = Marshal.PtrToStructure<PROGRAMMER_SOUND_PROPERTIES>(parameters);
				structure.sound = customEventInstanceUserData.sound_handle;
				Marshal.StructureToPtr<PROGRAMMER_SOUND_PROPERTIES>(structure, parameters, fDeleteOld: false);
			}
			return (RESULT)0;
		};

		private static Dictionary<string, SoundAsset> customEvents = new Dictionary<string, SoundAsset>();

		private static List<string> prefixes = new List<string>();

		private static Bus[] busList;

		public static System mod_system;

		public static void Initialize()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			if (Utility.IsError(System.create(ref mod_system), "Create system") || Utility.IsError(((System)(ref mod_system)).initialize(512, (INITFLAGS)0, (INITFLAGS)0, IntPtr.Zero)))
			{
				return;
			}
			string text = typeof(RuntimeUtils).GetMethod("GetPluginPath", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[1] { "resonanceaudio" }) as string;
			System val = default(System);
			if (!Utility.IsError(((System)(ref mod_system)).getCoreSystem(ref val), "Couldn't get core system, whatever"))
			{
				uint num = default(uint);
				Utility.IsError(((System)(ref val)).loadPlugin(text, ref num, 0u), "Couldn't load resonance audio, whatever");
			}
			using (Stream stream = ModdingKitCorePlugin.GetResourceStream("MainModBank.bank"))
			{
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
				Bank val2 = default(Bank);
				if (Utility.IsError(((System)(ref mod_system)).loadBankMemory(array, (LOAD_BANK_FLAGS)4, ref val2), "FMOD load master bank") || Utility.IsError(((Bank)(ref val2)).getBusList(ref busList), "FMOD Get Bus List"))
				{
					return;
				}
			}
			using Stream stream2 = ModdingKitCorePlugin.GetResourceStream("MainModBank.strings.bank");
			byte[] array2 = new byte[stream2.Length];
			stream2.Read(array2, 0, array2.Length);
			Bank val3 = default(Bank);
			Utility.IsError(((System)(ref mod_system)).loadBankMemory(array2, (LOAD_BANK_FLAGS)4, ref val3), "FMOD load strings bank");
		}

		public static Bank[] LoadBanksFromLists(params BankList[] bank_lists)
		{
			if (!((System)(ref mod_system)).isValid())
			{
				Debug.LogError((object)"ModAudioManager: Tried to load banks before the mod audio system was initialized");
				return null;
			}
			List<Bank> list = new List<Bank>();
			foreach (BankList bankList in bank_lists)
			{
				List<byte[]> banks = bankList.GetBanks();
				if (banks.Count == 0)
				{
					Debug.LogError((object)("ModAudioManager: Bank list " + ((Object)bankList).name + " contains no banks"));
				}
				banks = ReorderBankList(banks);
				if (!TryLoadReceiverFMODProjectBanks(banks, out var loaded_banks))
				{
					loaded_banks = LoadLegacyProjectBanks(banks, ((Object)bankList).name);
				}
				list.AddRange(loaded_banks);
			}
			if (list.Count == 0)
			{
				return null;
			}
			return list.ToArray();
		}

		private static List<byte[]> ReorderBankList(List<byte[]> banks)
		{
			List<byte[]> list = new List<byte[]>();
			List<byte[]> list2 = new List<byte[]>();
			for (int i = 0; i < banks.Count; i++)
			{
				if (BitConverter.ToUInt32(banks[i], 84) == 4)
				{
					list2.Add(banks[i]);
				}
				else
				{
					list.Add(banks[i]);
				}
			}
			list.AddRange(list2);
			return list;
		}

		private static bool TryLoadReceiverFMODProjectBanks(List<byte[]> banks, out List<Bank> loaded_banks)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			loaded_banks = new List<Bank>();
			Bank item = default(Bank);
			foreach (byte[] bank in banks)
			{
				System studioSystem = RuntimeManager.StudioSystem;
				if ((int)((System)(ref studioSystem)).loadBankMemory(bank, (LOAD_BANK_FLAGS)0, ref item) != 0 || (int)((Bank)(ref item)).loadSampleData() != 0)
				{
					if (((Bank)(ref item)).isValid())
					{
						((Bank)(ref item)).unload();
					}
					foreach (Bank loaded_bank in loaded_banks)
					{
						Bank current2 = loaded_bank;
						((Bank)(ref current2)).unload();
					}
					return false;
				}
				loaded_banks.Add(item);
			}
			return true;
		}

		private static List<Bank> LoadLegacyProjectBanks(List<byte[]> banks, string bank_list_name)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"using mod studio system for banks");
			List<Bank> list = new List<Bank>();
			int num = 0;
			Bank item = default(Bank);
			foreach (byte[] bank in banks)
			{
				if (Utility.IsError(((System)(ref mod_system)).loadBankMemory(bank, (LOAD_BANK_FLAGS)0, ref item)) || Utility.IsError(((Bank)(ref item)).loadSampleData()))
				{
					if (((Bank)(ref item)).isValid())
					{
						((Bank)(ref item)).unload();
					}
					Debug.LogError((object)$"ModAudioManager: Bank at index {num} from bank list {bank_list_name} is invalid and will not be loaded");
				}
				else
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static void Update()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			if (!((System)(ref mod_system)).isValid())
			{
				return;
			}
			Bus[] array = busList;
			string text = default(string);
			System studioSystem;
			Bus val2 = default(Bus);
			float volume = default(float);
			bool paused = default(bool);
			for (int i = 0; i < array.Length; i++)
			{
				Bus val = array[i];
				if (!Utility.IsError(((Bus)(ref val)).getPath(ref text), "Get Mod Bus Path " + text))
				{
					studioSystem = RuntimeManager.StudioSystem;
					if (!Utility.IsError(((System)(ref studioSystem)).getBus(text, ref val2), "Get Game Bus named " + text) && !Utility.IsError(((Bus)(ref val2)).getVolume(ref volume), "Get Volume of Bus named " + text) && !Utility.IsError(((Bus)(ref val)).setVolume(volume), "Set Volume of Bus named " + text) && !Utility.IsError(((Bus)(ref val2)).getPaused(ref paused), "Get Paused Status of Bus named " + text))
					{
						Utility.IsError(((Bus)(ref val)).setPaused(paused), "Set Paused Status of Bus named " + text);
					}
				}
			}
			studioSystem = RuntimeManager.StudioSystem;
			int num = default(int);
			if (!Utility.IsError(((System)(ref studioSystem)).getNumListeners(ref num)))
			{
				ATTRIBUTES_3D val3 = default(ATTRIBUTES_3D);
				for (int j = 0; j < num; j++)
				{
					studioSystem = RuntimeManager.StudioSystem;
					((System)(ref studioSystem)).getListenerAttributes(j, ref val3);
					((System)(ref mod_system)).setListenerAttributes(j, val3);
				}
				((System)(ref mod_system)).update();
			}
		}

		public static void Release()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			((System)(ref mod_system)).release();
		}

		internal static void DrawImGUIDebug()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			ImGui.Separator();
			ImGui.Text("Modded sounds debug:");
			List<string> active_instances = new List<string>();
			Bank[] array = default(Bank[]);
			if (Utility.IsError(((System)(ref mod_system)).getBankList(ref array)))
			{
				return;
			}
			Bank[] array2 = array;
			EventDescription[] array3 = default(EventDescription[]);
			EventInstance[] array5 = default(EventInstance[]);
			for (int i = 0; i < array2.Length; i++)
			{
				Bank val = array2[i];
				if (!Utility.CheckResult(((Bank)(ref val)).getEventList(ref array3)))
				{
					continue;
				}
				EventDescription[] array4 = array3;
				for (int j = 0; j < array4.Length; j++)
				{
					EventDescription event_description = array4[j];
					if (!Utility.CheckResult(((EventDescription)(ref event_description)).getInstanceList(ref array5)))
					{
						continue;
					}
					CollectionExtensions.Do<EventInstance>((IEnumerable<EventInstance>)array5, (Action<EventInstance>)delegate
					{
						//IL_0008: Unknown result type (might be due to invalid IL or missing references)
						string item = default(string);
						if (Utility.CheckResult(((EventDescription)(ref event_description)).getPath(ref item)))
						{
							active_instances.Add(item);
						}
					});
				}
			}
			if (ImGui.TreeNode("Active Instances: " + active_instances.Count))
			{
				foreach (string item2 in active_instances)
				{
					ImGui.Text(item2);
				}
				ImGui.TreePop();
			}
			array2 = array;
			string text = default(string);
			EventDescription[] array6 = default(EventDescription[]);
			string text2 = default(string);
			for (int i = 0; i < array2.Length; i++)
			{
				Bank val2 = array2[i];
				if (!Utility.CheckResult(((Bank)(ref val2)).getPath(ref text)) || !ImGui.TreeNode(text))
				{
					continue;
				}
				ImGui.Text("Events:");
				((Bank)(ref val2)).getEventList(ref array6);
				EventDescription[] array4 = array6;
				for (int j = 0; j < array4.Length; j++)
				{
					EventDescription val3 = array4[j];
					if (Utility.CheckResult(((EventDescription)(ref val3)).getPath(ref text2)))
					{
						ImGui.Text(text2);
					}
				}
				ImGui.TreePop();
			}
		}

		public static void LoadCustomEvents(string prefix, string directory)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			DirectoryInfo directoryInfo;
			try
			{
				directoryInfo = new DirectoryInfo(directory);
			}
			catch (ArgumentNullException)
			{
				Debug.LogError((object)"ModAudioManager.LoadCustomEvents(string, string): Provided directory path is null");
				return;
			}
			catch (SecurityException)
			{
				Debug.LogError((object)("ModAudioManager.LoadCustomEvents(string, string): You do not have the permission to access directory at path " + directory));
				return;
			}
			catch (ArgumentException)
			{
				Debug.LogError((object)("ModAudioManager.LoadCustomEvents(string, string): Path \"" + directory + "\" contains invalid characters"));
				return;
			}
			catch (PathTooLongException)
			{
				Debug.LogError((object)("ModAudioManager.LoadCustomEvents(string, string): Path \"" + directory + "\" is too long (> 260 characters)"));
				return;
			}
			if (!directoryInfo.Exists)
			{
				Debug.LogError((object)("ModAudioManager.LoadCustomEvents(string, string): Directory \"" + directory + "\" doesn't exist"));
				return;
			}
			if (prefix == "")
			{
				Debug.LogWarning((object)"ModAudioManager.LoadCustomEvents(string, string): Parameter \"assetBundleName\" shouldn't be empty");
			}
			FileInfo[] files = directoryInfo.GetFiles("*", SearchOption.AllDirectories);
			Sound sound = default(Sound);
			foreach (FileInfo fileInfo in files)
			{
				string fullName = fileInfo.FullName;
				fullName = "custom:/" + prefix.ToLower() + fullName.Substring(directoryInfo.FullName.Length, fullName.Length - fileInfo.Extension.Length - directoryInfo.FullName.Length).Replace('\\', '/').ToLower();
				System coreSystem = RuntimeManager.CoreSystem;
				if ((int)((System)(ref coreSystem)).createSound(fileInfo.FullName, (MODE)0, ref sound) == 0)
				{
					if (customEvents.ContainsKey(fullName))
					{
						Debug.LogWarning((object)("ModAudioManager.LoadCustomEvents(string, string): Asset \"" + fullName + "\" already exists and will be overriden"));
						customEvents[fullName] = new SoundAsset(fullName, sound);
					}
					else
					{
						customEvents.Add(fullName, new SoundAsset(fullName, sound));
					}
				}
			}
			prefixes.Add(prefix);
		}

		public static string[] GetAllEvents()
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, SoundAsset> customEvent in customEvents)
			{
				list.Add(customEvent.Key);
			}
			return list.ToArray();
		}

		public static string[] GetAllEventsWithPrefix(string prefix)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, SoundAsset> customEvent in customEvents)
			{
				if (customEvent.Key.Length > 8 && customEvent.Key.Substring(8, prefix.Length).Equals(prefix, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(customEvent.Key);
				}
			}
			return list.ToArray();
		}

		public static string[] GetAllPrefixes()
		{
			return prefixes.ToArray();
		}

		public static bool IsPrefixPresent(string prefix)
		{
			return prefixes.Contains(prefix);
		}

		public static IEnumerator PlayCustomEvent(EventInstance instance, uint length)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			((EventInstance)(ref instance)).setPaused(false);
			((EventInstance)(ref instance)).start();
			((EventInstance)(ref instance)).release();
			yield return (object)new WaitForSeconds((float)length / 1000f);
			((EventInstance)(ref instance)).stop((STOP_MODE)1);
		}

		public static IEnumerator PlayCustomEvent(InstanceAsset asset)
		{
			if (asset == null)
			{
				throw new ArgumentNullException("asset", "ModAudioManager.playCustomEvent(InstanceAsset): Parameter \"asset\" can't be null");
			}
			((EventInstance)(ref asset.instance)).setPaused(false);
			((EventInstance)(ref asset.instance)).start();
			((EventInstance)(ref asset.instance)).release();
			yield return (object)new WaitForSeconds((float)asset.length / 1000f);
			((EventInstance)(ref asset.instance)).stop((STOP_MODE)1);
		}

		public static InstanceAsset CreateInstance(string sound_event)
		{
			if (!customEvents.ContainsKey(sound_event))
			{
				Debug.LogError((object)("ModAudioManager.CreateInstance(string): Tried to play an event that doesn't exist: \"" + sound_event + "\"\nDid you load it using ModAudioManager.LoadCustomEvents(string, string); ?"));
				return null;
			}
			return new InstanceAsset(customEvents[sound_event]);
		}

		public static InstanceAsset Play(string sound_event, float volume = 1f)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (!customEvents.ContainsKey(sound_event))
			{
				Debug.LogError((object)("ModAudioManager.Play(string, float): Tried to play an event that doesn't exist: \"" + sound_event + "\"\nDid you load it using ModAudioManager.LoadCustomEvents(string, string); ?"));
				return null;
			}
			InstanceAsset instanceAsset = new InstanceAsset(customEvents[sound_event]);
			((EventInstance)(ref instanceAsset.instance)).setVolume(volume);
			((EventInstance)(ref instanceAsset.instance)).start();
			return instanceAsset;
		}

		public static void PlayOneShot(string sound_event, float volume = 1f)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (sound_event == "")
			{
				Debug.LogWarning((object)"ModAudioManager.PlayOneShot(string, float): Tried to pass an empty string as event name");
				return;
			}
			if (sound_event.Substring(0, "event:/".Length) == "event:/")
			{
				AudioManager.PlayOneShot(sound_event, volume);
				return;
			}
			if (!customEvents.ContainsKey(sound_event))
			{
				Debug.LogError((object)("ModAudioManager.PlayOneShot(string, float): Tried to play an event that doesn't exist: \"" + sound_event + "\"\nDid you load it using ModAudioManager.LoadCustomEvents(string, string); ?"));
				return;
			}
			SoundAsset soundAsset = customEvents[sound_event];
			EventInstance val = RuntimeManager.CreateInstance(soundAsset.type.getEventPath());
			IntPtr userData = GCHandle.ToIntPtr(GCHandle.Alloc(new CustomEventInstanceUserData
			{
				sound_handle = soundAsset.sound.handle
			}, GCHandleType.Pinned));
			((EventInstance)(ref val)).setUserData(userData);
			((EventInstance)(ref val)).setCallback(CUSTOM_SOUNDS_CALLBACK, (EVENT_CALLBACK_TYPE)384);
			((EventInstance)(ref val)).setVolume(volume);
			((EventInstance)(ref val)).setPaused(false);
			((EventInstance)(ref val)).start();
			((EventInstance)(ref val)).release();
		}

		public static void PlayOneShot3D(string sound_event, Vector3 pos, float volume = 1f, float pitch = 1f)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (sound_event == "")
			{
				Debug.LogWarning((object)"ModAudioManager.PlayOneShot3D(string, Vector3, float, float): Tried to pass an empty string as event name");
				return;
			}
			if (sound_event.Substring(0, "event:/".Length) == "event:/")
			{
				AudioManager.PlayOneShot3D(sound_event, pos, volume, pitch);
				return;
			}
			if (!customEvents.ContainsKey(sound_event))
			{
				Debug.LogError((object)("ModAudioManager.PlayOneShot3D(string, Vector3, float, float): Tried to play an event that doesn't exist: \"" + sound_event + "\"\nDid you load it using ModAudioManager.LoadCustomEvents(string, string); ?"));
				return;
			}
			SoundAsset soundAsset = customEvents[sound_event];
			EventInstance val = RuntimeManager.CreateInstance(soundAsset.type.getEventPath());
			IntPtr userData = GCHandle.ToIntPtr(GCHandle.Alloc(new CustomEventInstanceUserData
			{
				sound_handle = soundAsset.sound.handle
			}, GCHandleType.Pinned));
			((EventInstance)(ref val)).setUserData(userData);
			((EventInstance)(ref val)).setCallback(CUSTOM_SOUNDS_CALLBACK, (EVENT_CALLBACK_TYPE)384);
			((EventInstance)(ref val)).set3DAttributes(RuntimeUtils.To3DAttributes(pos));
			((EventInstance)(ref val)).setVolume(volume);
			((EventInstance)(ref val)).setPitch(pitch);
			((EventInstance)(ref val)).setPaused(false);
			((EventInstance)(ref val)).start();
			((EventInstance)(ref val)).release();
		}

		public static void PlayOneShotAttached(string sound_event, GameObject obj)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (sound_event == "")
			{
				Debug.LogWarning((object)"ModAudioManager.PlayOneShotAttached(string, GameObject): Tried to pass an empty string as event name");
				return;
			}
			if (sound_event.Substring(0, "event:/".Length) == "event:/")
			{
				AudioManager.PlayOneShotAttached(sound_event, obj);
				return;
			}
			if (!customEvents.ContainsKey(sound_event))
			{
				Debug.LogError((object)("ModAudioManager.PlayOneShotAttached(string, GameObject): Tried to play an event that doesn't exist: \"" + sound_event + "\"\nDid you load it using ModAudioManager.LoadCustomEvents(string, string); ?"));
				return;
			}
			SoundAsset soundAsset = customEvents[sound_event];
			EventInstance val = RuntimeManager.CreateInstance(soundAsset.type.getEventPath());
			IntPtr userData = GCHandle.ToIntPtr(GCHandle.Alloc(new CustomEventInstanceUserData
			{
				sound_handle = soundAsset.sound.handle
			}, GCHandleType.Pinned));
			((EventInstance)(ref val)).setUserData(userData);
			((EventInstance)(ref val)).setCallback(CUSTOM_SOUNDS_CALLBACK, (EVENT_CALLBACK_TYPE)384);
			RuntimeManager.AttachInstanceToGameObject(val, obj.transform, obj.GetComponent<Rigidbody>());
			((EventInstance)(ref val)).setPaused(false);
			((EventInstance)(ref val)).start();
			((EventInstance)(ref val)).release();
		}

		public static void PlayOneShotAttached(string sound_event, Transform transform)
		{
			PlayOneShotAttached(sound_event, ((Component)transform).gameObject);
		}

		public static void PlayOneShotAttached(string sound_event, GameObject obj, float volume)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (sound_event == "")
			{
				Debug.LogWarning((object)"ModAudioManager.PlayOneShotAttached(string, GameObject, float): Tried to pass an empty string as event name");
				return;
			}
			if (sound_event.Substring(0, "event:/".Length) == "event:/")
			{
				AudioManager.PlayOneShotAttached(sound_event, obj, volume);
				return;
			}
			if (!customEvents.ContainsKey(sound_event))
			{
				Debug.LogError((object)("ModAudioManager.PlayOneShotAttached(string, GameObject, float): Tried to play an event that doesn't exist: \"" + sound_event + "\"\nDid you load it using ModAudioManager.LoadCustomEvents(string, string); ?"));
				return;
			}
			SoundAsset soundAsset = customEvents[sound_event];
			EventInstance val = RuntimeManager.CreateInstance(soundAsset.type.getEventPath());
			IntPtr userData = GCHandle.ToIntPtr(GCHandle.Alloc(new CustomEventInstanceUserData
			{
				sound_handle = soundAsset.sound.handle
			}, GCHandleType.Pinned));
			((EventInstance)(ref val)).setUserData(userData);
			((EventInstance)(ref val)).setCallback(CUSTOM_SOUNDS_CALLBACK, (EVENT_CALLBACK_TYPE)384);
			((EventInstance)(ref val)).setVolume(volume);
			RuntimeManager.AttachInstanceToGameObject(val, obj.transform, obj.GetComponent<Rigidbody>());
			((EventInstance)(ref val)).setPaused(false);
			((EventInstance)(ref val)).start();
			((EventInstance)(ref val)).release();
		}

		public static void PlayOneShotAttached(string sound_event, Transform transform, float volume)
		{
			PlayOneShotAttached(sound_event, ((Component)transform).gameObject, volume);
		}
	}
	internal class ModAudioPatches
	{
		[HarmonyPatch(typeof(AudioManager), "PlayOneShot")]
		[HarmonyPrefix]
		private static bool PatchPlayOneShot(string sound_event, float volume)
		{
			if (sound_event == "")
			{
				Debug.LogWarning((object)"AudioManager.PlayOneShot(string, float): Tried to pass an empty string as event name");
				return false;
			}
			if (sound_event.Substring(0, "custom:/".Length) == "custom:/")
			{
				ModAudioManager.PlayOneShot(sound_event, volume);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(AudioManager), "PlayOneShot3D", new Type[]
		{
			typeof(string),
			typeof(Vector3),
			typeof(float),
			typeof(float)
		})]
		[HarmonyPrefix]
		private static bool PatchPlayOneShot3D(string sound_event, Vector3 pos, float volume = 1f, float pitch = 1f)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (sound_event == "")
			{
				Debug.LogWarning((object)"AudioManager.PlayOneShot3D(string, Vector3, float, float): Tried to pass an empty string as event name");
				return false;
			}
			if (sound_event.Substring(0, "custom:/".Length) == "custom:/")
			{
				ModAudioManager.PlayOneShot3D(sound_event, pos, volume, pitch);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(AudioManager), "PlayOneShotAttached", new Type[]
		{
			typeof(string),
			typeof(GameObject)
		})]
		[HarmonyPrefix]
		private static bool PatchPlayOneShotAttached(string sound_event, GameObject obj)
		{
			if (sound_event == "")
			{
				Debug.LogWarning((object)"AudioManager.PlayOneShotAttached(string, GameObject): Tried to pass an empty string as event name");
				return false;
			}
			if (sound_event.Substring(0, "custom:/".Length) == "custom:/")
			{
				ModAudioManager.PlayOneShotAttached(sound_event, obj);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(AudioManager), "PlayOneShotAttached", new Type[]
		{
			typeof(string),
			typeof(GameObject),
			typeof(float)
		})]
		[HarmonyPrefix]
		private static bool PatchPlayOneShotAttached(string sound_event, GameObject obj, float volume)
		{
			if (sound_event == "")
			{
				Debug.LogWarning((object)"AudioManager.PlayOneShotAttached(string, GameObject, float): Tried to pass an empty string as event name");
				return false;
			}
			if (sound_event.Substring(0, "custom:/".Length) == "custom:/")
			{
				ModAudioManager.PlayOneShotAttached(sound_event, obj, volume);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(System), "lookupID")]
		[HarmonyPostfix]
		private static RESULT PatchLookupID(RESULT __result, System __instance, string path, ref Guid id)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!((System)(ref ModAudioManager.mod_system)).isValid() || ModAudioManager.mod_system.handle == __instance.handle)
			{
				return __result;
			}
			if ((int)__result == 74)
			{
				__result = ((System)(ref ModAudioManager.mod_system)).lookupID(path, ref id);
			}
			return __result;
		}

		[HarmonyPatch(typeof(System), "getEventByID")]
		[HarmonyPostfix]
		private static RESULT PatchGetEventByID(RESULT __result, System __instance, Guid id, ref EventDescription _event)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			bool num = !((System)(ref ModAudioManager.mod_system)).isValid();
			bool flag = ModAudioManager.mod_system.handle == __instance.handle;
			if (num || flag)
			{
				return __result;
			}
			if ((int)__result == 74)
			{
				__result = ((System)(ref ModAudioManager.mod_system)).getEventByID(id, ref _event);
			}
			return __result;
		}
	}
	public class SoundAsset
	{
		public string asset_name { get; private set; }

		public Sound sound { get; private set; }

		public uint length { get; private set; }

		public SoundType type { get; private set; }

		public SoundAsset(string asset_name, Sound sound, SoundType type = SoundType.Sound)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			this.asset_name = asset_name;
			this.sound = sound;
			uint num = default(uint);
			((Sound)(ref sound)).getLength(ref num, (TIMEUNIT)1);
			length = num;
			this.type = type;
		}

		public SoundAsset(string asset_name, string asset_file, SoundType type = SoundType.Sound)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			this.asset_name = asset_name;
			System coreSystem = RuntimeManager.CoreSystem;
			Sound val = default(Sound);
			((System)(ref coreSystem)).createSound(asset_file, (MODE)0, ref val);
			sound = val;
			Sound val2 = sound;
			uint num = default(uint);
			((Sound)(ref val2)).getLength(ref num, (TIMEUNIT)1);
			length = num;
			this.type = type;
		}
	}
	public enum SoundType
	{
		Root,
		Music,
		Sound,
		SoundExternal,
		SoundExternalLoud,
		SoundExternalLoudCubehead,
		SoundExternalLoudBalloon,
		SoundExternalLoudShots,
		SoundExternalQuiet,
		SoundExternalQuietSteps,
		UI,
		Voice
	}
	public static class SoundTypeExtensions
	{
		private static string[] event_path_lookup = new string[13]
		{
			"event:/Blank - Root", "event:/Blank - Music", "event:/Blank - Sound", "event:/Blank - SoundExternal", "event:/Blank - SoundExternalLoud", "event:/Blank - SoundExternalLoudCubehead", "event:/Blank - SoundExternalLoudBalloon", "event:/Blank - SoundExternalLoudShots", "event:/Blank - SoundExternalQuiet", "event:/Blank - SoundExternalQuietSteps",
			"event:/Blank - UI", "event:/Blank - Voice", "event:/Test"
		};

		public static string getEventPath(this SoundType type)
		{
			return event_path_lookup[(int)type];
		}
	}
	public static class Utility
	{
		public static bool IsError(RESULT result, string errMessage = "")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((int)result == 0)
			{
				return false;
			}
			if (errMessage != "")
			{
				Debug.LogError((object)(errMessage + " => " + Error.String(result)));
			}
			else
			{
				Debug.LogError((object)Error.String(result));
			}
			return true;
		}

		public static bool CheckResult(RESULT result, string errMessage = "")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return !IsError(result, errMessage);
		}
	}
}
namespace Receiver2ModdingKit.CustomRounds
{
	[Serializable]
	public class CustomRoundDefinition
	{
		public float extra_rotation_x;

		public float extra_rotation_y;

		public float extra_recoil_x;

		public float extra_recoil_y;

		public float extra_stovepipe_chance;

		public float extra_doublefeed_chance;

		public float extra_ftf_chance;

		public float extra_wrongly_seated_mag_chance;

		public float extra_out_of_battery_chance;

		public float extra_slamfire_chance;

		public float extra_slide_fire_speed;

		public float extra_wedged_amount;

		[Range(0f, 2f)]
		public float spawn_chance = 1f;

		public Preset baseVariant;

		public Preset cartridge;

		public string clean_name;

		public Action<GunScript> onRoundFired;

		public Func<bool> checkUnlockCondition;

		public Texture2D shootingRangeAmmoBoxTexture;

		public bool IsUnlocked
		{
			get
			{
				if (checkUnlockCondition != null)
				{
					if (checkUnlockCondition != null)
					{
						return checkUnlockCondition();
					}
					return false;
				}
				return true;
			}
		}
	}
	public static class CustomRoundTypes
	{
		internal static class Patches
		{
			private static readonly CodeInstruction[] insertGetRandomRoundInstructions = (CodeInstruction[])(object)new CodeInstruction[4]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(ShellCasingScript) })),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetRandomRound", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Component), "gameObject"))
			};

			private static readonly FieldInfo _lah_loose_bullets = typeof(LocalAimHandler).GetField("loose_bullets", BindingFlags.Instance | BindingFlags.NonPublic);

			private static readonly MethodInfo _list_get_count_info = _lah_loose_bullets.FieldType.GetProperty("Count", BindingFlags.Instance | BindingFlags.Public).GetMethod;

			private static readonly MethodInfo _list_get_item_info = _lah_loose_bullets.FieldType.GetProperty("Item", BindingFlags.Instance | BindingFlags.Public).GetMethod;

			private static readonly FieldInfo _boolet_display_spring_info = _lah_loose_bullets.FieldType.GetGenericArguments()[0].GetField("spring", BindingFlags.Instance | BindingFlags.Public);

			private static readonly FieldInfo _boolet_display_item_info = _lah_loose_bullets.FieldType.GetGenericArguments()[0].GetField("item", BindingFlags.Instance | BindingFlags.Public);

			private const EquipmentType k_CustomRoundEquipmentType = (EquipmentType)1000;

			private const EquipmentType k_CustomChamberEquipmentType = (EquipmentType)1001;

			[HarmonyPatch(typeof(Balloon), "DoPop")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchBalloonPopping(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Expected O, but got Unknown
				MethodInfo methodInfo = typeof(Object).GetMethods(AccessTools.all).First((MethodInfo mi) => mi.GetGenericArguments().Length == 1 && mi.GetParameters().Length == 1).MakeGenericMethod(typeof(GameObject));
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ReceiverCoreScript), "Instance", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ReceiverCoreScript), "RoundPrefab"), (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(ShellCasingScript) }), (string)null), new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null)).Advance(2).InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(BossPlatformElevatorScript), "Spawn")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchBossPlatformScriptSpawn(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Expected O, but got Unknown
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				MethodInfo methodInfo = typeof(Object).GetMethods(AccessTools.all).First((MethodInfo mi) => mi.GetGenericArguments().Length == 1 && mi.GetParameters().Length == 3 && mi.GetParameters()[1].ParameterType == typeof(Vector3) && mi.GetParameters()[2].ParameterType == typeof(Quaternion)).MakeGenericMethod(typeof(GameObject));
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ReceiverCoreScript), "Instance", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ReceiverCoreScript), "RoundPrefab"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Random), "rotation"), (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)).ContinueIfValid(__originalMethod, (Action<string>)Debug.LogError).Advance(2)
					.InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(/*Could not decode attribute arguments.*/)]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchClassicBulletPileScript(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Expected O, but got Unknown
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Expected O, but got Unknown
				MethodInfo methodInfo = typeof(Object).GetMethods(AccessTools.all).First((MethodInfo mi) => mi.GetGenericArguments().Length == 1 && mi.GetParameters().Length == 3 && mi.GetParameters()[1].ParameterType == typeof(Vector3) && mi.GetParameters()[2].ParameterType == typeof(Quaternion)).MakeGenericMethod(typeof(GameObject));
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ReceiverCoreScript), "Instance", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ReceiverCoreScript), "RoundPrefab"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)).ContinueIfValid(__originalMethod, (Action<string>)Debug.LogError).Advance(2)
					.InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(Pumpkin), "OnShot")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchPumpkinOnShot(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Expected O, but got Unknown
				MethodInfo methodInfo = typeof(Object).GetMethods(AccessTools.all).First((MethodInfo mi) => mi.GetGenericArguments().Length == 1 && mi.GetParameters().Length == 1).MakeGenericMethod(typeof(GameObject));
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ReceiverCoreScript), "Instance", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ReceiverCoreScript), "RoundPrefab"), (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(ShellCasingScript) }), (string)null), new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null)).ContinueIfValid(__originalMethod, (Action<string>)Debug.LogError).Advance(2)
					.InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(RuntimeTileLevelGenerator), "InstantiateRound")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchRTLGInstantiateRound(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Expected O, but got Unknown
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Expected O, but got Unknown
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ReceiverCoreScript), "Instance", (Type[])null, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ReceiverCoreScript), "RoundPrefab"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null)).ContinueIfValid(__originalMethod, (Action<string>)Debug.LogError).Advance(2)
					.InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(AmmoBoxScript), "Start")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchAmmoBoxStart(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Expected O, but got Unknown
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(AmmoBoxScript), "round_prefab"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0f, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0f, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)360f, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Random), "Range", new Type[2]
				{
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null)).ContinueIfValid(__originalMethod, (Action<string>)Debug.LogError).Advance(2)
					.InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(ChamberState), "SpawnBulletOnChamber")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> PatchSpawnBulletOnChamber(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				return new SmartCodeMatcher(instructions, iLGenerator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ChamberState), "cylinder"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(CylinderScript), "gun_script"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "loaded_cartridge_prefab"), (string)null)).ContinueIfValid(__originalMethod, (Action<string>)Debug.LogError).Advance(4)
					.InsertAndAdvance(insertGetRandomRoundInstructions)
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "GetTotalMass")]
			[HarmonyPrefix]
			private static bool PatchGunGetTotalMass(GunScript __instance, ref float __result)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				float num = __instance.mass;
				float num2 = 0f;
				CartridgeSpec val = default(CartridgeSpec);
				if ((Object)(object)__instance.round_in_chamber != (Object)null)
				{
					((CartridgeSpec)(ref val)).SetFromPreset(__instance.round_in_chamber.cartridge_type);
					num2 += val.extra_mass;
					if (!__instance.round_in_chamber.IsSpent())
					{
						num2 += val.mass;
					}
				}
				if ((Object)(object)__instance.magazine_instance_in_gun != (Object)null)
				{
					num += 0.1f;
					for (int i = 0; i < __instance.magazine_instance_in_gun.rounds.Count; i++)
					{
						((CartridgeSpec)(ref val)).SetFromPreset(__instance.magazine_instance_in_gun.rounds[i].cartridge_type);
						num2 += val.extra_mass;
						if (!__instance.magazine_instance_in_gun.rounds[i].IsSpent())
						{
							num2 += val.mass;
						}
					}
				}
				if (__instance.HasCylinder())
				{
					for (int j = 0; j < __instance.cylinder.chambers.Length; j++)
					{
						ChamberState val2 = __instance.cylinder.chambers[j];
						if (val2.HasBullet())
						{
							((CartridgeSpec)(ref val)).SetFromPreset(val2.GetBullet().cartridge_type);
							num2 += val.extra_mass;
							if (!val2.GetBullet().IsSpent())
							{
								num2 += val.mass;
							}
						}
					}
				}
				__result = num + num2 * 0.001f;
				return false;
			}

			[HarmonyPatch(typeof(GunScript), "FireBullet")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> AddExtraDoubleFeedChances(IEnumerable<CodeInstruction> instructions, ILGenerator iLGenerator, MethodBase __originalMethod)
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Expected O, but got Unknown
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected O, but got Unknown
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Expected O, but got Unknown
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Expected O, but got Unknown
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Expected O, but got Unknown
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Expected O, but got Unknown
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Expected O, but got Unknown
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Expected O, but got Unknown
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Expected O, but got Unknown
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Expected O, but got Unknown
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Expected O, but got Unknown
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Expected O, but got Unknown
				//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Expected O, but got Unknown
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0218: Expected O, but got Unknown
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Expected O, but got Unknown
				//IL_0283: Unknown result type (might be due to invalid IL or missing references)
				//IL_0289: Expected O, but got Unknown
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_029d: Expected O, but got Unknown
				//IL_02be: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c4: Expected O, but got Unknown
				//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d8: Expected O, but got Unknown
				//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fb: Expected O, but got Unknown
				//IL_0303: Unknown result type (might be due to invalid IL or missing references)
				//IL_0309: Expected O, but got Unknown
				//IL_0323: Unknown result type (might be due to invalid IL or missing references)
				//IL_0329: Expected O, but got Unknown
				//IL_0337: Unknown result type (might be due to invalid IL or missing references)
				//IL_033d: Expected O, but got Unknown
				//IL_035e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Expected O, but got Unknown
				//IL_037b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0381: Expected O, but got Unknown
				//IL_0398: Unknown result type (might be due to invalid IL or missing references)
				//IL_039e: Expected O, but got Unknown
				//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e6: Expected O, but got Unknown
				//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fa: Expected O, but got Unknown
				//IL_041b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0421: Expected O, but got Unknown
				//IL_0445: Unknown result type (might be due to invalid IL or missing references)
				//IL_044b: Expected O, but got Unknown
				//IL_045d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0463: Expected O, but got Unknown
				//IL_046b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0471: Expected O, but got Unknown
				//IL_048c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0492: Expected O, but got Unknown
				//IL_04af: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b5: Expected O, but got Unknown
				//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c9: Expected O, but got Unknown
				//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d7: Expected O, but got Unknown
				//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f8: Expected O, but got Unknown
				//IL_0515: Unknown result type (might be due to invalid IL or missing references)
				//IL_051b: Expected O, but got Unknown
				//IL_0537: Unknown result type (might be due to invalid IL or missing references)
				//IL_053d: Expected O, but got Unknown
				//IL_0550: Unknown result type (might be due to invalid IL or missing references)
				//IL_0556: Expected O, but got Unknown
				//IL_0570: Unknown result type (might be due to invalid IL or missing references)
				//IL_0576: Expected O, but got Unknown
				//IL_0584: Unknown result type (might be due to invalid IL or missing references)
				//IL_058a: Expected O, but got Unknown
				//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b1: Expected O, but got Unknown
				//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ce: Expected O, but got Unknown
				//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_05eb: Expected O, but got Unknown
				//IL_062d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0633: Expected O, but got Unknown
				//IL_0641: Unknown result type (might be due to invalid IL or missing references)
				//IL_0647: Expected O, but got Unknown
				//IL_0664: Unknown result type (might be due to invalid IL or missing references)
				//IL_066a: Expected O, but got Unknown
				//IL_0672: Unknown result type (might be due to invalid IL or missing references)
				//IL_0678: Expected O, but got Unknown
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions, iLGenerator);
				LocalBuilder localBuilder = iLGenerator.DeclareLocal(typeof(float));
				LocalBuilder localBuilder2 = iLGenerator.DeclareLocal(typeof(float));
				smartCodeMatcher.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(GunScript), "CanMalfunction"), (string)null), new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "gun_type"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Beq, (object)null, (string)null)).CreateLabel(out var label).InsertAndAdvance(new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Ldarg_1, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_1, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(CustomRoundDefinition), "extra_doublefeed_chance")), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex))
					.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)1f, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Random), "Range", new Type[2]
					{
						typeof(float),
						typeof(float)
					}, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "doubleFeedProbability"), (string)null), new CodeMatch((OpCode?)OpCodes.Blt, (object)null, (string)null))
					.InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null))
					.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Dup, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ChamberState), "wedged"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0f, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.5f, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Random), "Range", new Type[2]
					{
						typeof(float),
						typeof(float)
					}, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Add, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(ChamberState), "wedged"), (string)null))
					.CreateLabel(out var label2)
					.InsertAndAdvance(new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder2.LocalIndex), new CodeInstruction(OpCodes.Ldarg_1, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label2), new CodeInstruction(OpCodes.Ldarg_1, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(CustomRoundDefinition), "extra_wedged_amount")), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder2.LocalIndex))
					.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Dup, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ChamberState), "wedged"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0f, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.5f, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Random), "Range", new Type[2]
					{
						typeof(float),
						typeof(float)
					}, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Add, (object)null, (string)null))
					.Insert(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder2.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null));
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "UpdateSlide")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> ForTheLoveOfGodAddStovePipeProbabilities(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Expected O, but got Unknown
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Expected O, but got Unknown
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Expected O, but got Unknown
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Expected O, but got Unknown
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Expected O, but got Unknown
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Expected O, but got Unknown
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Expected O, but got Unknown
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Expected O, but got Unknown
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Expected O, but got Unknown
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Expected O, but got Unknown
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Expected O, but got Unknown
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Expected O, but got Unknown
				//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Expected O, but got Unknown
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Expected O, but got Unknown
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_022d: Expected O, but got Unknown
				//IL_024b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Expected O, but got Unknown
				//IL_026d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Expected O, but got Unknown
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Expected O, but got Unknown
				//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ac: Expected O, but got Unknown
				//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d5: Expected O, but got Unknown
				//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fe: Expected O, but got Unknown
				//IL_0306: Unknown result type (might be due to invalid IL or missing references)
				//IL_030c: Expected O, but got Unknown
				//IL_0326: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: Expected O, but got Unknown
				//IL_034f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0355: Expected O, but got Unknown
				//IL_0378: Unknown result type (might be due to invalid IL or missing references)
				//IL_037e: Expected O, but got Unknown
				//IL_0386: Unknown result type (might be due to invalid IL or missing references)
				//IL_038c: Expected O, but got Unknown
				LocalBuilder localBuilder = generator.DeclareLocal(typeof(float));
				Label? label2 = default(Label?);
				Label label;
				return new SmartCodeMatcher(instructions, generator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "transform_chambered_round"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null)).Advance(5).CreateLabel(out label)
					.Insert(new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(CustomRoundDefinition), "extra_stovepipe_chance")), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex))
					.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "StovePipeProbability", (Type[])null, (Type[])null), (string)null))
					.Advance()
					.Insert(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null))
					.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "StovePipeProbability", (Type[])null, (Type[])null), (string)null))
					.Advance()
					.Insert(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "FireBullet")]
			[HarmonyPostfix]
			private static void AddExtraRecoil(GunScript __instance, ShellCasingScript round)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				CustomRoundDefinition definitionForRound = GetDefinitionForRound(round.cartridge_type);
				if (definitionForRound != null)
				{
					__instance.rotation_transfer_x += Random.Range(0f, definitionForRound.extra_rotation_x * Mathf.Sign(__instance.rotation_transfer_x));
					__instance.rotation_transfer_y += definitionForRound.extra_rotation_y;
					__instance.recoil_transfer_x -= definitionForRound.extra_recoil_x;
					__instance.recoil_transfer_y += Random.Range(0f, definitionForRound.extra_recoil_y * Mathf.Sign(__instance.recoil_transfer_y));
					LinearMover slide = __instance.slide;
					((SimpleMover)slide).vel = ((SimpleMover)slide).vel + definitionForRound.extra_slide_fire_speed;
					if (definitionForRound.onRoundFired != null)
					{
						definitionForRound.onRoundFired(__instance);
					}
				}
			}

			[HarmonyPatch(typeof(LocalAimHandler), "GetLastMatchingLooseBullet")]
			[HarmonyPrefix]
			private static void AddCompatibleDimensions(ref Preset[] cartridge_dimensions)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Invalid comparison between Unknown and I4
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Expected I4, but got Unknown
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Expected I4, but got Unknown
				int num = cartridge_dimensions.Length;
				Preset[] siblingCartridgeTypes = GetSiblingCartridgeTypes(cartridge_dimensions);
				if ((int)inventory_selected_cartridge != int.MaxValue)
				{
					Preset[] array = cartridge_dimensions;
					foreach (Preset val in array)
					{
						if (val == inventory_selected_cartridge)
						{
							cartridge_dimensions = (Preset[])(object)new Preset[1] { (Preset)(int)val };
							return;
						}
					}
					array = siblingCartridgeTypes;
					foreach (Preset val2 in array)
					{
						if (val2 == inventory_selected_cartridge)
						{
							cartridge_dimensions = (Preset[])(object)new Preset[1] { (Preset)(int)val2 };
							return;
						}
					}
					cartridge_dimensions = Array.Empty<Preset>();
				}
				else if (siblingCartridgeTypes != null && siblingCartridgeTypes.Length != 0)
				{
					Array.Resize(ref cartridge_dimensions, cartridge_dimensions.Length + siblingCartridgeTypes.Length);
					for (int j = num; j < cartridge_dimensions.Length; j++)
					{
						cartridge_dimensions[j] = siblingCartridgeTypes[j - num];
					}
				}
			}

			[HarmonyPatch(typeof(GunScript), "Update")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> AddExtraWronglySeatedMagProbability(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Expected O, but got Unknown
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Expected O, but got Unknown
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Expected O, but got Unknown
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Expected O, but got Unknown
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Expected O, but got Unknown
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Expected O, but got Unknown
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Expected O, but got Unknown
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Expected O, but got Unknown
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Expected O, but got Unknown
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Expected O, but got Unknown
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f2: Expected O, but got Unknown
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Expected O, but got Unknown
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Expected O, but got Unknown
				//IL_023f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Expected O, but got Unknown
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0254: Expected O, but got Unknown
				//IL_0270: Unknown result type (might be due to invalid IL or missing references)
				//IL_0276: Expected O, but got Unknown
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_0298: Expected O, but got Unknown
				//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bc: Expected O, but got Unknown
				//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02de: Expected O, but got Unknown
				//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f7: Expected O, but got Unknown
				//IL_031a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Expected O, but got Unknown
				//IL_0328: Unknown result type (might be due to invalid IL or missing references)
				//IL_032e: Expected O, but got Unknown
				LocalBuilder localBuilder = generator.DeclareLocal(typeof(float));
				Label label;
				return new SmartCodeMatcher(instructions, generator).MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "WronglySeatedMagProbability", (Type[])null, (Type[])null), (string)null)).CreateLabel(out label).InsertAndAdvance(new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(MagazineScript), "NumRounds", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MagazineScript), "rounds")), new CodeInstruction(OpCodes.Ldc_I4_0, (object)null), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(List<ShellCasingScript>), "Item")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MagazineScript), "rounds")), new CodeInstruction(OpCodes.Ldc_I4_0, (object)null), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(List<ShellCasingScript>), "Item")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(CustomRoundDefinition), "extra_wrongly_seated_mag_chance")), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex))
					.Advance(3)
					.Insert(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null))
					.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "UpdateSlide")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> AddOutOfBatteryChance(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Expected O, but got Unknown
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Expected O, but got Unknown
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Expected O, but got Unknown
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Expected O, but got Unknown
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Expected O, but got Unknown
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Expected O, but got Unknown
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Expected O, but got Unknown
				//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Expected O, but got Unknown
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Expected O, but got Unknown
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_0226: Expected O, but got Unknown
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Expected O, but got Unknown
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0257: Expected O, but got Unknown
				//IL_0264: Unknown result type (might be due to invalid IL or missing references)
				//IL_026a: Expected O, but got Unknown
				//IL_0272: Unknown result type (might be due to invalid IL or missing references)
				//IL_0278: Expected O, but got Unknown
				//IL_0293: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Expected O, but got Unknown
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bd: Expected O, but got Unknown
				//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d1: Expected O, but got Unknown
				//IL_02da: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e0: Expected O, but got Unknown
				//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0302: Expected O, but got Unknown
				//IL_031e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0324: Expected O, but got Unknown
				//IL_032d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0333: Expected O, but got Unknown
				//IL_034f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0355: Expected O, but got Unknown
				//IL_0371: Unknown result type (might be due to invalid IL or missing references)
				//IL_0377: Expected O, but got Unknown
				//IL_0395: Unknown result type (might be due to invalid IL or missing references)
				//IL_039b: Expected O, but got Unknown
				//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_03af: Expected O, but got Unknown
				//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_03be: Expected O, but got Unknown
				//IL_03da: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e0: Expected O, but got Unknown
				//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0402: Expected O, but got Unknown
				//IL_040b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0411: Expected O, but got Unknown
				//IL_042d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0433: Expected O, but got Unknown
				//IL_044f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0455: Expected O, but got Unknown
				//IL_0473: Unknown result type (might be due to invalid IL or missing references)
				//IL_0479: Expected O, but got Unknown
				//IL_0495: Unknown result type (might be due to invalid IL or missing references)
				//IL_049b: Expected O, but got Unknown
				//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b4: Expected O, but got Unknown
				//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04dd: Expected O, but got Unknown
				//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0504: Expected O, but got Unknown
				//IL_0526: Unknown result type (might be due to invalid IL or missing references)
				//IL_052c: Expected O, but got Unknown
				//IL_053a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0540: Expected O, but got Unknown
				//IL_0561: Unknown result type (might be due to invalid IL or missing references)
				//IL_0567: Expected O, but got Unknown
				//IL_0589: Unknown result type (might be due to invalid IL or missing references)
				//IL_058f: Expected O, but got Unknown
				//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ac: Expected O, but got Unknown
				//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c9: Expected O, but got Unknown
				//IL_060b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0611: Expected O, but got Unknown
				//IL_0620: Unknown result type (might be due to invalid IL or missing references)
				//IL_0626: Expected O, but got Unknown
				//IL_064a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0650: Expected O, but got Unknown
				//IL_0673: Unknown result type (might be due to invalid IL or missing references)
				//IL_0679: Expected O, but got Unknown
				//IL_0681: Unknown result type (might be due to invalid IL or missing references)
				//IL_0687: Expected O, but got Unknown
				LocalBuilder localBuilder = generator.DeclareLocal(typeof(float));
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions, generator);
				Label? label2 = default(Label?);
				List<Label> labels = CodeInstructionExtensions.ExtractLabels(smartCodeMatcher.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(GunScript), "CanMalfunction"), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "malfunction"), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0f, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)1f, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Random), "Range", new Type[2]
				{
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "OutOfBatteryProbability", (Type[])null, (Type[])null), (string)null)).Instruction);
				smartCodeMatcher.CreateLabel(out var label).Insert(new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Ldnull, (object)null), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(MagazineScript), "NumRounds", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MagazineScript), "rounds")), new CodeInstruction(OpCodes.Ldc_I4_0, (object)null), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(List<ShellCasingScript>), "Item")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "magazine_instance_in_gun")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MagazineScript), "rounds")), new CodeInstruction(OpCodes.Ldc_I4_0, (object)null), new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(List<ShellCasingScript>), "Item")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(CustomRoundDefinition), "extra_out_of_battery_chance")), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex)).AddLabels(labels);
				smartCodeMatcher.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(GunScript), "CanMalfunction"), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "malfunction"), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0f, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)1f, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Random), "Range", new Type[2]
				{
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(GunScript), "OutOfBatteryProbability", (Type[])null, (Type[])null), (string)null)).Advance().Insert(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null));
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "UpdateSlide")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> AddSlamfireChance(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Expected O, but got Unknown
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Expected O, but got Unknown
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Expected O, but got Unknown
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Expected O, but got Unknown
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Expected O, but got Unknown
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Expected O, but got Unknown
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Expected O, but got Unknown
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Expected O, but got Unknown
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Expected O, but got Unknown
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Expected O, but got Unknown
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Expected O, but got Unknown
				//IL_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_0219: Expected O, but got Unknown
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_023a: Expected O, but got Unknown
				//IL_0242: Unknown result type (might be due to invalid IL or missing references)
				//IL_0248: Expected O, but got Unknown
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_026b: Expected O, but got Unknown
				//IL_0278: Unknown result type (might be due to invalid IL or missing references)
				//IL_027e: Expected O, but got Unknown
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Expected O, but got Unknown
				//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ad: Expected O, but got Unknown
				//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cf: Expected O, but got Unknown
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Expected O, but got Unknown
				//IL_0301: Unknown result type (might be due to invalid IL or missing references)
				//IL_0307: Expected O, but got Unknown
				//IL_0310: Unknown result type (might be due to invalid IL or missing references)
				//IL_0316: Expected O, but got Unknown
				//IL_0332: Unknown result type (might be due to invalid IL or missing references)
				//IL_0338: Expected O, but got Unknown
				//IL_0354: Unknown result type (might be due to invalid IL or missing references)
				//IL_035a: Expected O, but got Unknown
				//IL_0378: Unknown result type (might be due to invalid IL or missing references)
				//IL_037e: Expected O, but got Unknown
				//IL_039a: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a0: Expected O, but got Unknown
				//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b9: Expected O, but got Unknown
				//IL_0400: Unknown result type (might be due to invalid IL or missing references)
				//IL_0406: Expected O, but got Unknown
				//IL_041d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0423: Expected O, but got Unknown
				//IL_0445: Unknown result type (might be due to invalid IL or missing references)
				//IL_044b: Expected O, but got Unknown
				//IL_0459: Unknown result type (might be due to invalid IL or missing references)
				//IL_045f: Expected O, but got Unknown
				//IL_0480: Unknown result type (might be due to invalid IL or missing references)
				//IL_0486: Expected O, but got Unknown
				//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ae: Expected O, but got Unknown
				//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c2: Expected O, but got Unknown
				//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e9: Expected O, but got Unknown
				//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04fd: Expected O, but got Unknown
				//IL_0521: Unknown result type (might be due to invalid IL or missing references)
				//IL_0527: Expected O, but got Unknown
				//IL_054a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0550: Expected O, but got Unknown
				//IL_055f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0565: Expected O, but got Unknown
				//IL_0587: Unknown result type (might be due to invalid IL or missing references)
				//IL_058d: Expected O, but got Unknown
				//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b6: Expected O, but got Unknown
				//IL_05be: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c4: Expected O, but got Unknown
				LocalBuilder localBuilder = generator.DeclareLocal(typeof(float));
				SmartCodeMatcher smartCodeMatcher = new SmartCodeMatcher(instructions, generator);
				Label? label2 = default(Label?);
				List<Label> labels = CodeInstructionExtensions.ExtractLabels(smartCodeMatcher.MatchForward(false, new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.8f, (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "malfunction"), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "slamfire_probability"), (string)null)).Instruction);
				smartCodeMatcher.CreateLabel(out var label).Insert(new CodeInstruction(OpCodes.Ldc_R4, (object)0f), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber")), new CodeInstruction(OpCodes.Ldnull, (object)null), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Brfalse_S, (object)label), new CodeInstruction(OpCodes.Ldarg_0, (object)null), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber")), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShellCasingScript), "cartridge_type")), new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomRoundTypes), "GetDefinitionForRound", (Type[])null, (Type[])null)), new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(CustomRoundDefinition), "extra_slamfire_chance")), new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder.LocalIndex)).AddLabels(labels);
				Debug.Log((object)$"labels: {smartCodeMatcher.Instruction.labels.Count}");
				smartCodeMatcher.MatchForward(true, new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.8f, (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "malfunction"), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "round_in_chamber"), (string)null), new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null), (string)null), new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instr) => CodeInstructionExtensions.Branches(instr, ref label2)), (string)null), new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null), new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GunScript), "slamfire_probability"), (string)null)).Advance().Insert(new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder.LocalIndex), new CodeInstruction(OpCodes.Add, (object)null));
				return smartCodeMatcher.InstructionEnumeration();
			}

			[HarmonyPatch(typeof(GunScript), "GetFailureToFeedProbability")]
			[HarmonyPostfix]
			private static void AddExtraFailureToFeedProbability(GunScript __instance, ref float __result)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.magazine_instance_in_gun != (Object)null && __instance.magazine_instance_in_gun.NumRounds() > 0)
				{
					CustomRoundDefinition definitionForRound = GetDefinitionForRound(__instance.magazine_instance_in_gun.rounds[0].cartridge_type);
					if (definitionForRound != null)
					{
						__result += definitionForRound.extra_ftf_chance;
					}
				}
			}

			[HarmonyPatch(typeof(PlayerLoadout), "Serialize")]
			[HarmonyPostfix]
			private static void SerializeIndividualRoundTypesFuckYou(JSONObject __result)
			{
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Invalid comparison between Unknown and I4
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Expected O, but got Unknown
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Expected O, but got Unknown
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Unknown result type (might be due to invalid IL or missing references)
				//IL_024c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_0260: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_021f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0221: Unknown result type (might be due to invalid IL or missing references)
				//IL_0226: Unknown result type (might be due to invalid IL or missing references)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0233: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)LocalAimHandler.player_instance != (Object)null))
				{
					return;
				}
				JSONArray asArray = ((JSONNode)__result)["equipment"].AsArray;
				if (LocalAimHandler.player_instance.LooseBulletCount > 0)
				{
					Debug.Log((object)LocalAimHandler.player_instance.LooseBulletCount);
					object value = _lah_loose_bullets.GetValue(LocalAimHandler.player_instance);
					for (int i = 0; i < (int)_list_get_count_info.Invoke(value, null); i++)
					{
						object? value2 = _boolet_display_item_info.GetValue(_list_get_item_info.Invoke(value, new object[1] { i }));
						ShellCasingScript val;
						if ((val = (ShellCasingScript)((value2 is ShellCasingScript) ? value2 : null)) != null)
						{
							Debug.Log((object)val.cartridge_type);
							JSONObject val2 = new PlayerLoadoutEquipment
							{
								equipment_type = (EquipmentType)1000,
								magazine_class = (MagazineClass)val.cartridge_type
							}.Serialize();
							((JSONNode)asArray).Add((JSONNode)(object)val2);
						}
					}
				}
				GunScript val3 = default(GunScript);
				if (!LocalAimHandler.player_instance.TryGetGun(ref val3))
				{
					return;
				}
				if ((int)val3.gun_type == 0)
				{
					EquipmentSlot slot;
					MagazineClass magazine_class;
					if ((Object)(object)val3.round_in_chamber != (Object)null)
					{
						slot = ((!val3.round_in_chamber.IsSpent()) ? ((EquipmentSlot)2) : ((EquipmentSlot)1));
						magazine_class = (MagazineClass)val3.round_in_chamber.cartridge_type;
					}
					else
					{
						slot = (EquipmentSlot)0;
						magazine_class = (MagazineClass)0;
					}
					PlayerLoadoutEquipment val4 = new PlayerLoadoutEquipment
					{
						equipment_type = (EquipmentType)1001,
						slot = slot,
						magazine_class = magazine_class
					};
					((JSONNode)asArray).Add((JSONNode)(object)val4.Serialize());
				}
				else
				{
					if ((int)val3.gun_type != 1)
					{
						return;
					}
					foreach (ChamberState item in val3.cylinder)
					{
						ChamberState val5 = item;
						if (val5 == null)
						{
							Debug.Log((object)"a cylindr was null?????? lol!!!");
							continue;
						}
						JSONObject val6 = ((!val5.HasBullet()) ? new PlayerLoadoutEquipment
						{
							equipment_type = (EquipmentType)1001,
							slot = (EquipmentSlot)0
						}.Serialize() : (val5.IsDisabled() ? new PlayerLoadoutEquipment
						{
							equipment_type = (EquipmentType)1001,
							slot = (EquipmentSlot)3,
							magazine_class = (MagazineClass)val5.GetBullet().cartridge_type
						}.Serialize() : ((!val5.IsSpent()) ? new PlayerLoadoutEquipment
						{
							equipment_type = (EquipmentType)1001,
							slot = (EquipmentSlot)2,
							magazine_class = (MagazineClass)val5.GetBullet().cartridge_type
						}.Serialize() : new PlayerLoadoutEquipment
						{
							equipment_type = (EquipmentType)1001,
							slot = (EquipmentSlot)1,
							magazine_class = (MagazineClass)val5.GetBullet().cartridge_type
						}.Serialize())));
						((JSONNode)asArray).Add((JSONNode)(object)val6);
					}
				}
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "SpawnGun")]
			[HarmonyPostfix]
			private static void HandleChamberCompatStuff(ReceiverCoreScript __instance, GunScript __result, PlayerLoadout loadout)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Invalid comparison between Unknown and I4
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Invalid comparison between Unknown and I4
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Invalid comparison between Unknown and I4
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected I4, but got Unknown
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: Expected I4, but got Unknown
				//IL_0326: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
				Debug.Log((object)"chamber compat yay");
				if ((int)__result.gun_type == 0)
				{
					foreach (PlayerLoadoutEquipment item2 in loadout.equipment)
					{
						if ((int)item2.equipment_type == 1001)
						{
							Debug.Log((object)"automatic");
							Debug.Log((object)(Preset)item2.magazine_class);
							if ((Object)(object)__result.round_in_chamber != (Object)null)
							{
								Object.Destroy((Object)(object)((Component)__result.round_in_chamber).gameObject);
							}
							ChamberState slot = (ChamberState)item2.slot;
							switch ((int)slot)
							{
							case 1:
								SpawnRoundInChamber(__result, (Preset)item2.magazine_class);
								__result.round_in_chamber.MakeSpent();
								break;
							case 2:
								SpawnRoundInChamber(__result, (Preset)item2.magazine_class);
								break;
							case 0:
								break;
							}
							break;
						}
					}
					return;
				}
				if ((int)__result.gun_type != 1)
				{
					return;
				}
				List<PlayerLoadoutEquipment> list = new List<PlayerLoadoutEquipment>();
				foreach (PlayerLoadoutEquipment item3 in loadout.equipment)
				{
					if ((int)item3.equipment_type == 1001)
					{
						list.Add(item3);
					}
				}
				Debug.Log((object)list.Count);
				for (int i = 0; i < list.Count && i < __result.cylinder.GetChamberCount(); i++)
				{
					ChamberState chamber = __result.cylinder.GetChamber(i);
					Preset magazine_class = (Preset)list[i].magazine_class;
					Debug.Log((object)magazine_class);
					ChamberState slot = (ChamberState)list[i].slot;
					switch ((int)slot)
					{
					case 3:
					{
						if (chamber.HasBullet())
						{
							Object.Destroy((Object)(object)((Component)chamber.GetBullet()).gameObject);
						}
						ShellCasingScript val = ((!Object.op_Implicit((Object)(object)((Component)ModdingKitCorePlugin.GetRoundPrefab(magazine_class)).transform.Find("plug"))) ? Object.Instantiate<GameObject>(__result.loaded_cartridge_prefab).GetComponent<ShellCasingScript>() : FillChamber(chamber, magazine_class));
						val.MakeSpent();
						MeshRenderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<MeshRenderer>();
						for (int j = 0; j < componentsInChildren.Length; j++)
						{
							((Renderer)componentsInChildren[j]).enabled = false;
						}
						((Component)((Component)val).transform.Find("plug")).gameObject.SetActive(true);
						if (__result.plug_use_parent_transform)
						{
							((Component)val).transform.parent = ((Component)val).transform.parent.parent;
						}
						((Component)val).transform.localScale = Vector3.one;
						typeof(ChamberState).GetField("disabled", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(chamber, true);
						break;
					}
					case 2:
						if (chamber.HasBullet())
						{
							Object.Destroy((Object)(object)((Component)chamber.GetBullet()).gameObject);
						}
						FillChamber(chamber, magazine_class);
						break;
					case 1:
						if (chamber.HasBullet())
						{
							Object.Destroy((Object)(object)((Component)chamber.GetBullet()).gameObject);
						}
						FillChamber(chamber, magazine_class).MakeSpent();
						chamber.wedged += Random.Range(0f, 0.5f);
						break;
					case 0:
						if (chamber.HasBullet())
						{
							Object.Destroy((Object)(object)((Component)chamber.GetBullet()).gameObject);
						}
						break;
					}
				}
				ShellCasingScript FillChamber(ChamberState val3, Preset cartridge_type)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_003f: Unknown result type (might be due to invalid IL or missing references)
					//IL_007e: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00db: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
					//IL_0101: Unknown result type (might be due to invalid IL or missing references)
					//IL_0106: Unknown result type (might be due to invalid IL or missing references)
					//IL_010b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0110: Unknown result type (might be due to invalid IL or missing references)
					//IL_011b: Unknown result type (might be due to invalid IL or missing references)
					//IL_012c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0138: Expected O, but got Unknown
					ShellCasingScript val2 = Object.Instantiate<ShellCasingScript>(ModdingKitCorePlugin.GetRoundPrefab(cartridge_type));
					val3.SetBullet(val2);
					((Component)val3.GetBullet()).transform.position = val3.transform.position;
					((Component)val3.GetBullet()).transform.rotation = val3.transform.rotation;
					((Component)val3.GetBullet()).transform.parent = val3.transform.parent;
					((Component)val3.GetBullet()).transform.localScale = new Vector3(1f, 1f, 1f);
					val3.wedged = Random.Range(0.05f, 0.1f);
					val3.seated = 0.01f;
					val3.seated_vel = 10f;
					PoseEvent item = new PoseEvent
					{
						parent = val3.transform,
						position = val3.transform.InverseTransformPoint(((Component)val3.GetBullet()).transform.position),
						rotation = Quaternion.Inverse(val3.transform.rotation) * ((Component)val3.GetBullet()).transform.rotation,
						scale = 1f,
						time = Time.time - 10f,
						transition = InventorySlot.fast_spring_baked
					};
					((InventoryItem)val3.GetBullet()).pose_events.Add(item);
					val3.UpdateBulletPosition();
					((InventoryItem)val2).Move(((Component)__result).GetComponent<InventorySlot>());
					val3.seated = 1f;
					val3.UpdateBulletPosition();
					return val2;
				}
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "SpawnPlayer")]
			[HarmonyPrefix]
			private static void RoundCompatStuff(ReceiverCoreScript __instance)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Invalid comparison between Unknown and I4
				Debug.Log((object)"prefix spawnplayer");
				foreach (PlayerLoadoutEquipment item in __instance.CurrentLoadout.equipment)
				{
					Debug.Log((object)item.equipment_type);
					if ((int)item.equipment_type == 1000)
					{
						__instance.CurrentLoadout.ammo_count = 0;
						Debug.Log((object)$"current loadout ammo count: {__instance.CurrentLoadout.ammo_count}");
					}
				}
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "SpawnPlayer")]
			[HarmonyPostfix]
			private static void RoundCompatStuffTwo(ReceiverCoreScript __instance)
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Invalid comparison between Unknown and I4
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				Debug.Log((object)"postfix spawnplayer");
				PlayerEquipment component = Object.FindObjectOfType<PlayerScript>().equipment.GetComponent<PlayerEquipment>();
				Debug.Log((object)LocalAimHandler.player_instance.loadout);
				Debug.Log((object)LocalAimHandler.player_instance.loadout.equipment);
				if (LocalAimHandler.player_instance.loadout == null)
				{
					return;
				}
				foreach (PlayerLoadoutEquipment item in LocalAimHandler.player_instance.loadout.equipment)
				{
					Debug.Log((object)item.equipment_type);
					if ((int)item.equipment_type == 1000)
					{
						Debug.Log((object)(Preset)item.magazine_class);
						GameObject val = Object.Instantiate<GameObject>(((Component)ModdingKitCorePlugin.GetRoundPrefab((Preset)item.magazine_class)).gameObject);
						component.AddRound(val);
					}
				}
			}

			[HarmonyPatch(typeof(MagazineScript), "GetPersistentData")]
			[HarmonyPostfix]
			private static void SaveMagRounds(MagazineScript __instance, JSONObject __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Expected I4, but got Unknown
				JSONArray val = new JSONArray();
				for (int i = 0; i < __instance.rounds.Count; i++)
				{
					Debug.Log((object)__instance.rounds[i].cartridge_type);
					JSONObject val2 = new JSONObject();
					((JSONNode)val2).Add("type", JSONNode.op_Implicit((int)__instance.rounds[i].cartridge_type));
					((JSONNode)val).Add((JSONNode)(object)val2);
				}
				((JSONNode)__result).Add("rounds", (JSONNode)(object)val);
			}

			[HarmonyPatch(typeof(MagazineScript), "SetPersistentData")]
			[HarmonyPostfix]
			private static void AddMagRounds(MagazineScript __instance, JSONObject data)
			{
				if (!(((JSONNode)data)["rounds"] != (object)null))
				{
					return;
				}
				JSONArray asArray = ((JSONNode)data)["rounds"].AsArray;
				if (__instance.rounds_in_mag == ((JSONNode)asArray).Count)
				{
					__instance.rounds_in_mag = 0;
					Debug.Log((object)"adding rounds 2 mag");
					Debug.Log((object)((JSONNode)asArray).Count);
					for (int i = 0; i < ((JSONNode)asArray).Count; i++)
					{
						int asInt = ((JSONNode)asArray)[i]["type"].AsInt;
						Debug.Log((object)(Preset)asInt);
						ShellCasingScript roundPrefab = ModdingKitCorePlugin.GetRoundPrefab((Preset)asInt);
						Debug.Log((object)((Object)roundPrefab).name);
						ShellCasingScript val = Object.Instantiate<ShellCasingScript>(roundPrefab);
						__instance.AddRound(val);
					}
				}
			}

			[HarmonyPatch(typeof(LocalAimHandler), "UpdateLooseBulletDisplay")]
			[HarmonyPostfix]
			private static void UpdateBulletSelectDisplay(object ___loose_bullets)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				List<Preset> list = GetPresetsInInventory();
				if (Input.GetKeyDown((KeyCode)273) || list.Count <= 1)
				{
					inventory_selected_cartridge = (Preset)int.MaxValue;
					UpdateSelectedCartridge();
					return;
				}
				if (Input.GetKeyDown((KeyCode)276))
				{
					int num = list.IndexOf(inventory_selected_cartridge);
					if (num == list.Count - 1)
					{
						inventory_selected_cartridge = list[0];
					}
					else
					{
						inventory_selected_cartridge = list[num + 1];
					}
					UpdateSelectedCartridge();
				}
				if (Input.GetKeyDown((KeyCode)275))
				{
					int num2 = list.IndexOf(inventory_selected_cartridge);
					if (num2 <= 0)
					{
						inventory_selected_cartridge = list[list.Count - 1];
					}
					else
					{
						inventory_selected_cartridge = list[num2 - 1];
					}
					UpdateSelectedCartridge();
				}
				List<Preset> GetPresetsInInventory()
				{
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					int num3 = (int)_list_get_count_info.Invoke(___loose_bullets, null);
					HashSet<Preset> hashSet = new HashSet<Preset>();
					for (int num4 = num3 - 1; num4 >= 0; num4--)
					{
						object? value = _boolet_display_item_info.GetValue(_list_get_item_info.Invoke(___loose_bullets, new object[1] { num4 }));
						ShellCasingScript val;
						if ((val = (ShellCasingScript)((value is ShellCasingScript) ? value : null)) != null)
						{
							hashSet.Add(val.cartridge_type);
						}
					}
					return hashSet.ToList();
				}
				void UpdateSelectedCartridge()
				{
					//IL_005a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Expected O, but got Unknown
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_0067: Unknown result type (might be due to invalid IL or missing references)
					int num3 = (int)_list_get_count_info.Invoke(___loose_bullets, null);
					for (int i = 0; i < num3; i++)
					{
						object obj = _list_get_item_info.Invoke(___loose_bullets, new object[1] { i });
						object? value = _boolet_display_item_info.GetValue(obj);
						ShellCasingScript val;
						if ((val = (ShellCasingScript)((value is ShellCasingScript) ? value : null)) != null)
						{
							Spring val2 = (Spring)_boolet_display_spring_info.GetValue(obj);
							if (val.cartridge_type == inventory_selected_cartridge)
							{
								val2.target_state = 0.4f;
							}
							else
							{
								val2.target_state = 0.3f;
							}
						}
					}
				}
			}

			[HarmonyPatch(typeof(ReceiverCoreScript), "SpawnPlayer")]
			[HarmonyPostfix]
			private static void AddExtenderToSRAB()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Invalid comparison between Unknown and I4
				if ((int)ReceiverCoreScript.Instance().game_mode.GetGameMode() != 3)
				{
					return;
				}
				GameObject val = GameObject.Find("Shooting Range/Gameplay/Ammo Tables");
				if ((Object)(object)val != (Object)null)
				{
					ShootingRangeAmmoBoxScript[] componentsInChildren = val.GetComponentsInChildren<ShootingRangeAmmoBoxScript>();
					foreach (ShootingRangeAmmoBoxScript obj in componentsInChildren)
					{
						Debug.Log((object)((Object)obj).name);
						((Component)obj).gameObject.AddComponent<ShootingRangeAmmoBoxCustomRoundExtender>();
					}
				}
				GameObject val2 = GameObject.Find("Challenge Room/Challenge Room Geometry/AmmoTable");
				if ((Object)(object)val2 != (Object)null)
				{
					ShootingRangeAmmoBoxScript[] componentsInChildren = val2.GetComponentsInChildren<ShootingRangeAmmoBoxScript>();
					foreach (ShootingRangeAmmoBoxScript obj2 in componentsInChildren)
					{
						Debug.Log((object)((Object)obj2).name);
						((Component)obj2).gameObject.AddComponent<ShootingRangeAmmoBoxCustomRoundExtender>();
					}
				}
				GameObject val3 = GameObject.Find("Weapon Storage Room/NewGunsLocation");
				if ((Object)(object)val3 != (Object)null)
				{
					ShootingRangeAmmoBoxScript[] componentsInChildren = val3.GetComponentsInChildren<ShootingRangeAmmoBoxScript>();
					foreach (ShootingRangeAmmoBoxScript obj3 in componentsInChildren)
					{
						Debug.Log((object)((Object)obj3).name);
						((Component)obj3).gameObject.AddComponent<ShootingRangeAmmoBoxCustomRoundExtender>();
					}
				}
			}
		}

		public static Preset inventory_selected_cartridge = (Preset)int.MaxValue;

		public static List<CustomRoundDefinition> definitions = new List<CustomRoundDefinition>();

		public static Dictionary<Preset, List<Preset>> presets_children_dictionary = new Dictionary<Preset, List<Preset>>();

		public static ShellCasingScript GetRandomRound(Preset baseVariant)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)baseVariant);
			if (presets_children_dictionary.TryGetValue(baseVariant, out var value))
			{
				float num = 0f;
				num += 1f;
				for (int i = 0; i < value.Count; i++)
				{
					CustomRoundDefinition definitionForRound = GetDefinitionForRound(value[i]);
					if (definitionForRound.IsUnlocked)
					{
						num += definitionForRound.spawn_chance;
					}
				}
				float num2 = Random.Range(0f, num);
				Debug.Log((object)("randFloat: " + num2));
				Debug.Log((object)value.Count);
				if (num2 <= 1f)
				{
					return ModdingKitCorePlugin.GetRoundPrefab(baseVariant);
				}
				float num3 = 0f;
				for (int j = 0; j < value.Count; j++)
				{
					if (GetDefinitionForRound(value[j]).IsUnlocked)
					{
						num3 += GetDefinitionForRound(value[j]).spawn_chance;
					}
					if (num2 <= num3)
					{
						return ModdingKitCorePlugin.GetRoundPrefab(value[j]);
					}
				}
				return ModdingKitCorePlugin.GetRoundPrefab(value[value.Count - 1]);
			}
			return ModdingKitCorePlugin.GetRoundPrefab(baseVariant);
		}

		public static CustomRoundDefinition GetDefinitionForRound(Preset round)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return definitions.FirstOrDefault((CustomRoundDefinition def) => def.cartridge == round);
		}

		public static Preset[] GetSiblingCartridgeTypes(params Preset[] cartridges)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			List<Preset> list = new List<Preset>();
			foreach (Preset key in cartridges)
			{
				if (presets_children_dictionary.TryGetValue(key, out var value))
				{
					list.AddRange(value);
				}
			}
			return list.ToArray();
		}

		public static void RegisterCustomRound(CustomRoundDefinition definition)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (definition == null)
			{
				throw new NullReferenceException("CustomRoundDefinition is null");
			}
			if (presets_children_dictionary.TryGetValue(definition.baseVariant, out var value))
			{
				value.Add(definition.cartridge);
			}
			else
			{
				presets_children_dictionary[definition.baseVariant] = new List<Preset> { definition.cartridge };
			}
			definitions.Add(definition);
		}

		public static void SpawnRoundInChamber(GunScript gunScript, Preset cartridge_type)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gunScript.transform_chambered_round != (Object)null)
			{
				gunScript.round_in_chamber = Object.Instantiate<ShellCasingScript>(ModdingKitCorePlugin.GetRoundPrefab(cartridge_type), gunScript.transform_chambered_round.position, gunScript.transform_chambered_round.rotation);
			}
			else
			{
				gunScript.round_in_chamber = Object.Instantiate<ShellCasingScript>(ModdingKitCorePlugin.GetRoundPrefab(cartridge_type));
			}
			((Component)gunScript.round_in_chamber).transform.parent = ((Component)gunScript).transform;
			((Component)gunScript.round_in_chamber).transform.localScale = Vector3.one;
			((InventoryItem)gunScript.round_in_chamber).Move(((Component)gunScript).GetComponent<InventorySlot>());
		}
	}
	public class ShootingRangeAmmoBoxCustomRoundExtender : MonoBehaviour
	{
		private PressableButton shootingRangeButton;

		private ShootingRangeAmmoBoxScript shootingRangeAmmoBoxScript;

		private MeshRenderer shootingRangeAmmoBoxRenderer;

		private Texture2D originalTex;

		private static readonly Dictionary<Preset, string> cartridgeNamesLookUp = new Dictionary<Preset, string>
		{
			{
				(Preset)0,
				"9mm"
			},
			{
				(Preset)3,
				".38"
			},
			{
				(Preset)2,
				".45 ACP"
			},
			{
				(Preset)8,
				".45 LC"
			},
			{
				(Preset)6,
				".50"
			}
		};

		private void Awake()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			shootingRangeButton = (((Object)(object)((Component)this).GetComponent<PressableButton>() == (Object)null) ? ((Component)this).GetComponentInChildren<PressableButton>() : ((Component)this).GetComponent<PressableButton>());
			shootingRangeAmmoBoxScript = ((Component)this).GetComponent<ShootingRangeAmmoBoxScript>();
			foreach (Transform item in ((Component)this).transform)
			{
				Transform val = item;
				if (!Object.op_Implicit((Object)(object)((Component)val).GetComponentInChildren<TextMeshPro>()) && !((Object)val).name.Contains("Blob"))
				{
					MeshRenderer componentInChildren = ((Component)val).GetComponentInChildren<MeshRenderer>();
					if (Object.op_Implicit((Object)(object)componentInChildren))
					{
						shootingRangeAmmoBoxRenderer = componentInChildren;
						ref Texture2D reference = ref originalTex;
						Texture mainTexture = ((Renderer)shootingRangeAmmoBoxRenderer).sharedMaterial.mainTexture;
						reference = (Texture2D)(object)((mainTexture is Texture2D) ? mainTexture : null);
					}
				}
			}
		}

		private void Update()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected I4, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected I4, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between I4 and Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Invalid comparison between I4 and Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Interactable)shootingRangeButton).IsHovered())
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)276))
			{
				ShellCasingScript component = shootingRangeAmmoBoxScript.round_prefab.GetComponent<ShellCasingScript>();
				Debug.Log((object)component);
				CustomRoundDefinition definitionForRound = CustomRoundTypes.GetDefinitionForRound(component.cartridge_type);
				Preset val = definitionForRound?.baseVariant ?? component.cartridge_type;
				Debug.Log((object)$"round def: {definitionForRound}");
				Debug.Log((object)$"base: {val}");
				Preset[] siblingCartridgeTypes = CustomRoundTypes.GetSiblingCartridgeTypes((Preset)(int)val);
				if (siblingCartridgeTypes.Length != 0 && definitionForRound == null)
				{
					val = siblingCartridgeTypes[0];
					shootingRangeAmmoBoxScript.round_prefab = ((Component)ModdingKitCorePlugin.GetRoundPrefab(siblingCartridgeTypes[0])).gameObject;
				}
				for (int i = 0; i < siblingCartridgeTypes.Length; i++)
				{
					Debug.Log((object)siblingCartridgeTypes[i]);
					if ((int)siblingCartridgeTypes[i] == (int)component.cartridge_type)
					{
						if (i + 1 == siblingCartridgeTypes.Length)
						{
							shootingRangeAmmoBoxScript.round_prefab = ((Component)ModdingKitCorePlugin.GetRoundPrefab(val)).gameObject;
							break;
						}
						val = siblingCartridgeTypes[i + 1];
						Debug.Log((object)$"got type: {val}");
						shootingRangeAmmoBoxScript.round_prefab = ((Component)ModdingKitCorePlugin.GetRoundPrefab(val)).gameObject;
						break;
					}
				}
				definitionForRound = CustomRoundTypes.GetDefinitionForRound(val);
				UpdateTapeText(definitionForRound, val);
			}
			if (!Input.GetKeyDown((KeyCode)275))
			{
				return;
			}
			ShellCasingScript component2 = shootingRangeAmmoBoxScript.round_prefab.GetComponent<ShellCasingScript>();
			CustomRoundDefinition definitionForRound2 = CustomRoundTypes.GetDefinitionForRound(component2.cartridge_type);
			Preset val2 = definitionForRound2?.baseVariant ?? component2.cartridge_type;
			Preset[] siblingCartridgeTypes2 = CustomRoundTypes.GetSiblingCartridgeTypes((Preset)(int)val2);
			if (siblingCartridgeTypes2.Length != 0 && definitionForRound2 == null)
			{
				val2 = siblingCartridgeTypes2[0];
				shootingRangeAmmoBoxScript.round_prefab = ((Component)ModdingKitCorePlugin.GetRoundPrefab(siblingCartridgeTypes2[0])).gameObject;
			}
			for (int num = siblingCartridgeTypes2.Length - 1; num >= 0; num--)
			{
				if ((int)siblingCartridgeTypes2[num] == (int)component2.cartridge_type)
				{
					if (num - 1 == -1)
					{
						shootingRangeAmmoBoxScript.round_prefab = ((Component)ModdingKitCorePlugin.GetRoundPrefab(val2)).gameObject;
						break;
					}
					val2 = siblingCartridgeTypes2[num - 1];
					shootingRangeAmmoBoxScript.round_prefab = ((Component)ModdingKitCorePlugin.GetRoundPrefab(val2)).gameObject;
					Debug.Log((object)$"got type: {val2}");
					break;
				}
			}
			definitionForRound2 = CustomRoundTypes.GetDefinitionForRound(val2);
			UpdateTapeText(definitionForRound2, val2);
		}

		private void UpdateTapeText(CustomRoundDefinition round_def, Preset cartridge_type)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			if (round_def != null)
			{
				if ((Object)(object)round_def.shootingRangeAmmoBoxTexture != (Object)null)
				{
					((Renderer)shootingRangeAmmoBoxRenderer).material.mainTexture = (Texture)(object)round_def.shootingRangeAmmoBoxTexture;
				}
			}
			else
			{
				((Renderer)shootingRangeAmmoBoxRenderer).material.mainTexture = (Texture)(object)originalTex;
			}
			TextMeshPro componentInChildren = default(TextMeshPro);
			foreach (Transform item in ((Component)this).transform)
			{
				Transform val = item;
				if (!((Object)val).name.StartsWith("Tape"))
				{
					continue;
				}
				Debug.Log((object)((Object)val).name);
				if (!((Component)val).TryGetComponent<TextMeshPro>(ref componentInChildren))
				{
					componentInChildren = ((Component)val).GetComponentInChildren<TextMeshPro>();
				}
				string text;
				if (round_def != null)
				{
					if (!string.IsNullOrWhiteSpace(round_def.clean_name))
					{
						text = round_def.clean_name;
						Debug.Log((object)"getting clean name");
					}
					else
					{
						ShellCasingScript roundPrefab = ModdingKitCorePlugin.GetRoundPrefab(cartridge_type);
						text = ((InventoryItem)roundPrefab).InternalName.Split(new char[1] { '.' })[((InventoryItem)roundPrefab).InternalName.Split(new char[1] { '.' }).Length - 1];
						text = "";
						string[] array = text.Split(new char[1] { '_' });
						foreach (string text2 in array)
						{
							text = text + char.ToUpperInvariant(text2[0]) + text2.Substring(1);
						}
					}
				}
				else
				{
					text = cartridgeNamesLookUp[cartridge_type];
				}
				((TMP_Text)componentInChildren).text = text;
				((TMP_Text)componentInChildren).ForceMeshUpdate(false, false);
				bool flag = false;
				for (int num = 7; num > 0; num--)
				{
					Transform val2 = ((Component)val).transform.Find("Tape_0" + num);
					Quaternion val3 = Quaternion.AngleAxis(0f - val2.eulerAngles.y, Vector3.up);
					Bounds bounds = ((Renderer)((Component)val2).GetComponent<MeshRenderer>()).bounds;
					float z = (val3 * ((Bounds)(ref bounds)).extents).z;
					bounds = ((TMP_Text)componentInChildren).bounds;
					bool flag2 = z > ((Bounds)(ref bounds)).extents.x + 0.02f;
					Debug.Log((object)$"index: {num} fits: {flag2}");
					Quaternion val4 = Quaternion.AngleAxis(0f - val2.eulerAngles.y, Vector3.up);
					bounds = ((Renderer)((Component)val2).GetComponent<MeshRenderer>()).bounds;
					object arg = (val4 * ((Bounds)(ref bounds)).extents).z;
					bounds = ((TMP_Text)componentInChildren).bounds;
					Debug.Log((object)$"tape extents: {arg} vs text extents: {((Bounds)(ref bounds)).extents.x}");
					Debug.Log((object)$"already found fitting tape: {flag}");
					if (flag2 && !flag)
					{
						flag = true;
						((Component)val2).gameObject.SetActive(true);
						Debug.Log((object)"setting active");
					}
					else
					{
						((Component)val2).gameObject.SetActive(false);
						Debug.Log((object)"setting inactive");
					}
					if (num == 1 && !flag)
					{
						Debug.Log((object)"didn't find any fitting tape, enable biggest & scaling");
						((Component)val2).gameObject.SetActive(true);
						bounds = ((TMP_Text)componentInChildren).bounds;
						float x = ((Bounds)(ref bounds)).extents.x;
						Quaternion val5 = Quaternion.AngleAxis(0f - val2.eulerAngles.y, Vector3.up);
						bounds = ((Renderer)((Component)val2).GetComponent<MeshRenderer>()).bounds;
						float num2 = x / (val5 * ((Bounds)(ref bounds)).extents).z;
						val2.localScale = new Vector3(val2.localScale.x, val2.localScale.y, val2.localScale.z * num2 + 0.02f);
					}
				}
				((TMP_Text)componentInChildren).text = text;
			}
		}
	}
}