using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ByteSizeMetal")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 ByteSizeMetal")]
[assembly: AssemblyFileVersion("1.4.8.0")]
[assembly: AssemblyInformationalVersion("1.4.8")]
[assembly: AssemblyProduct("Modlist-patchpack")]
[assembly: AssemblyTitle("ValuablesPatchpack.Preloader")]
[assembly: AssemblyMetadata("Author", "ByteSizeMetal")]
[assembly: AssemblyVersion("1.4.8.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ValuablesPatchpack
{
	public static class SillyApiCompatPatcher
	{
		private sealed class Wanted
		{
			public string Type;

			public string Name;

			public string Return;

			public bool HasThis;

			public string[] Params;

			public readonly SortedSet<string> Mods = new SortedSet<string>();

			public string Sig => Type + "." + Name + "(" + string.Join(", ", Params) + ")";

			public string BridgeName => "__SillyValuablesFix__" + Name + "__" + Digest(Key(Type, Name, HasThis, Return, Params)).Substring(0, 12);
		}

		private const string BridgePrefix = "__SillyValuablesFix__";

		private static readonly ManualLogSource Log = Logger.CreateLogSource("Modlist-patchpack API");

		public static IEnumerable<string> TargetDLLs
		{
			get
			{
				if (!SillyPaths().Any() || !ModuleSettings.SillyEnabled)
				{
					return Array.Empty<string>();
				}
				return new string[1] { "Assembly-CSharp.dll" };
			}
		}

		public static void Initialize()
		{
			try
			{
				MoreUpgradesInputPatcher.Prepare();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("MoreUpgrades input preparation failed; other modules continue: " + ex));
			}
			try
			{
				PresentsApiPatcher.Prepare();
			}
			catch (Exception ex2)
			{
				Log.LogError((object)("REPOPresents preparation failed; other modules continue: " + ex2));
			}
			try
			{
				LegacySpeedPatcher.Prepare();
			}
			catch (Exception ex3)
			{
				Log.LogError((object)("Legacy speed preparation failed; other modules continue: " + ex3));
			}
			if (!ModuleSettings.SillyEnabled)
			{
				RestoreOriginalCallNames();
			}
		}

		public static void Patch(AssemblyDefinition assembly)
		{
			if (!ModuleSettings.SillyEnabled)
			{
				return;
			}
			ModuleDefinition mainModule = assembly.MainModule;
			Dictionary<string, Wanted> dictionary;
			try
			{
				dictionary = CollectMissingCalls(mainModule);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Scanning plugins failed, nothing patched: " + ex));
				return;
			}
			int num = 0;
			foreach (Wanted w in dictionary.Values.OrderBy((Wanted x) => x.Sig))
			{
				try
				{
					TypeDefinition type = mainModule.GetType(w.Type);
					if (type == null)
					{
						Log.LogWarning((object)(w.Sig + ": type no longer exists, can't fix (used by " + string.Join(", ", w.Mods) + ")."));
					}
					else if (!((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == w.BridgeName))
					{
						MethodDefinition val = ((w.Type == "PhysGrabber" && w.Name == "ReleaseObjectRPC" && w.HasThis && w.Params.SequenceEqual(new string[2] { "System.Boolean", "System.Single" })) ? ReleaseObjectRpcShim(mainModule, type) : DefaultsShim(mainModule, type, w));
						if (val == null)
						{
							Log.LogWarning((object)(w.Sig + " is missing and can't be rebuilt automatically (used by " + string.Join(", ", w.Mods) + ")."));
							continue;
						}
						((MemberReference)val).Name = w.BridgeName;
						type.Methods.Add(val);
						num++;
						Log.LogInfo((object)("Added compatibility bridge for " + w.Sig + " (" + string.Join(", ", w.Mods) + ")."));
					}
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)(w.Sig + ": couldn't add it, skipped. " + ex2.Message));
				}
			}
			Log.LogInfo((object)((num == 0) ? "No supported outdated SillyValuables calls found." : $"Prepared {num} SillyValuables compatibility bridge(s); original game API overloads unchanged."));
			RewriteSillyReferences(mainModule);
		}

		private static Dictionary<string, Wanted> CollectMissingCalls(ModuleDefinition game)
		{
			//IL_00b7: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			HashSet<string> hashSet = new HashSet<string>(from m in ((IEnumerable<TypeDefinition>)game.Types).SelectMany(AllTypes).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
				select Key(((MemberReference)m.DeclaringType).FullName, ((MemberReference)m).Name, ((MethodReference)m).HasThis, ((MemberReference)((MethodReference)m).ReturnType).FullName, ((IEnumerable<ParameterDefinition>)((MethodReference)m).Parameters).Select((ParameterDefinition p) => ((MemberReference)((ParameterReference)p).ParameterType).FullName)));
			Dictionary<string, Wanted> dictionary = new Dictionary<string, Wanted>();
			if (!Directory.Exists(Paths.PluginPath))
			{
				return dictionary;
			}
			foreach (string item2 in SillyPaths())
			{
				if (Path.GetFileName(item2).StartsWith("MMHOOK", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				try
				{
					ModuleDefinition val = ModuleDefinition.ReadModule(item2, new ReaderParameters
					{
						ReadingMode = (ReadingMode)2,
						ReadSymbols = false
					});
					try
					{
						string item = PluginFolderName(item2);
						foreach (MemberReference memberReference in val.GetMemberReferences())
						{
							MethodReference val2 = (MethodReference)(object)((memberReference is MethodReference) ? memberReference : null);
							if (val2 == null || memberReference is MethodSpecification)
							{
								continue;
							}
							TypeReference declaringType = ((MemberReference)val2).DeclaringType;
							if (declaringType == null || declaringType.IsGenericInstance)
							{
								continue;
							}
							IMetadataScope scope = declaringType.Scope;
							if (((scope != null) ? scope.Name : null) != "Assembly-CSharp" || val2.HasGenericParameters || ((MemberReference)val2).Name == ".ctor" || ((MemberReference)val2).Name == ".cctor")
							{
								continue;
							}
							string[] array = ((IEnumerable<ParameterDefinition>)val2.Parameters).Select((ParameterDefinition p) => ((MemberReference)((ParameterReference)p).ParameterType).FullName).ToArray();
							string text = OriginalName(((MemberReference)val2).Name);
							string text2 = Key(((MemberReference)declaringType).FullName, text, val2.HasThis, ((MemberReference)val2.ReturnType).FullName, array);
							if (!(((MemberReference)val2).Name == text) || !hashSet.Contains(text2))
							{
								if (!dictionary.TryGetValue(text2, out var value))
								{
									Wanted obj = new Wanted
									{
										Type = ((MemberReference)declaringType).FullName,
										Name = text,
										HasThis = val2.HasThis,
										Return = ((MemberReference)val2.ReturnType).FullName,
										Params = array
									};
									value = obj;
									dictionary[text2] = obj;
								}
								value.Mods.Add(item);
							}
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				catch
				{
				}
			}
			return dictionary;
		}

		private static IEnumerable<TypeDefinition> AllTypes(TypeDefinition t)
		{
			return ((IEnumerable<TypeDefinition>)(object)new TypeDefinition[1] { t }).Concat(((IEnumerable<TypeDefinition>)t.NestedTypes).SelectMany(AllTypes));
		}

		private static string Key(string type, string name, bool hasThis, string ret, IEnumerable<string> ps)
		{
			return string.Format("{0}::{1}|{2}|{3}|{4}", type, name, hasThis, ret, string.Join(",", ps));
		}

		private static string PluginFolderName(string path)
		{
			string text = path.Substring(Paths.PluginPath.Length).TrimStart('\\', '/').Split('\\', '/')[0];
			if (!text.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			return Path.GetFileNameWithoutExtension(text);
		}

		private static bool Matches(MethodDefinition m, Wanted w, int count)
		{
			if (((MemberReference)m).Name != w.Name || ((MethodReference)m).HasThis != w.HasThis || ((MethodReference)m).HasGenericParameters || ((MemberReference)((MethodReference)m).ReturnType).FullName != w.Return)
			{
				return false;
			}
			if (((MethodReference)m).Parameters.Count != count)
			{
				return false;
			}
			for (int i = 0; i < count; i++)
			{
				if (((MemberReference)((ParameterReference)((MethodReference)m).Parameters[i]).ParameterType).FullName != w.Params[i])
				{
					return false;
				}
			}
			return true;
		}

		private static MethodDefinition DefaultsShim(ModuleDefinition module, TypeDefinition type, Wanted w)
		{
			//IL_00aa: 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_0124: 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)
			int n = w.Params.Length;
			MethodDefinition val = (from m in (IEnumerable<MethodDefinition>)type.Methods
				where ((MemberReference)m).Name == w.Name && ((MethodReference)m).HasThis == w.HasThis && !((MethodReference)m).HasGenericParameters && ((MemberReference)((MethodReference)m).ReturnType).FullName == w.Return && ((MethodReference)m).Parameters.Count >= n
				where Enumerable.Range(0, n).All((int i) => ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[i]).ParameterType).FullName == w.Params[i])
				where ((IEnumerable<ParameterDefinition>)((MethodReference)m).Parameters).Skip(n).All(CanEmitDefault)
				orderby ((MethodReference)m).Parameters.Count
				select m).FirstOrDefault();
			if (val == null)
			{
				return null;
			}
			MethodDefinition val2 = NewShim(val, n);
			ILProcessor iLProcessor = val2.Body.GetILProcessor();
			if (((MethodReference)val).HasThis)
			{
				iLProcessor.Emit(OpCodes.Ldarg_0);
			}
			for (int num = 0; num < n; num++)
			{
				iLProcessor.Emit(OpCodes.Ldarg, ((MethodReference)val2).Parameters[num]);
			}
			foreach (ParameterDefinition item in ((IEnumerable<ParameterDefinition>)((MethodReference)val).Parameters).Skip(n))
			{
				EmitDefault(iLProcessor, item);
			}
			iLProcessor.Emit(OpCodes.Call, (MethodReference)(object)val);
			iLProcessor.Emit(OpCodes.Ret);
			return val2;
		}

		private static MethodDefinition NewShim(MethodDefinition target, int paramCount)
		{
			//IL_0013: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			MethodAttributes val = (MethodAttributes)(0x86 | (target.IsStatic ? 16 : 0));
			MethodDefinition val2 = new MethodDefinition(((MemberReference)target).Name, val, ((MethodReference)target).ReturnType);
			for (int i = 0; i < paramCount; i++)
			{
				ParameterDefinition val3 = ((MethodReference)target).Parameters[i];
				((MethodReference)val2).Parameters.Add(new ParameterDefinition(((ParameterReference)val3).Name, (ParameterAttributes)0, ((ParameterReference)val3).ParameterType));
			}
			return val2;
		}

		private static bool CanEmitDefault(ParameterDefinition p)
		{
			if (!p.HasConstant || ((ParameterReference)p).ParameterType.IsByReference)
			{
				return false;
			}
			object constant = p.Constant;
			if (constant == null)
			{
				return !((ParameterReference)p).ParameterType.IsValueType;
			}
			if (!(constant is bool) && !(constant is int) && !(constant is uint) && !(constant is short) && !(constant is ushort) && !(constant is byte) && !(constant is sbyte) && !(constant is char) && !(constant is long) && !(constant is ulong) && !(constant is float) && !(constant is double))
			{
				return constant is string;
			}
			return true;
		}

		private static void EmitDefault(ILProcessor il, ParameterDefinition p)
		{
			//IL_0070: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			object constant = p.Constant;
			if (constant != null)
			{
				if (!(constant is bool flag))
				{
					if (!(constant is float num))
					{
						if (!(constant is double num2))
						{
							if (!(constant is long num3))
							{
								if (!(constant is ulong num4))
								{
									if (constant is string text)
									{
										il.Emit(OpCodes.Ldstr, text);
									}
									else
									{
										il.Emit(OpCodes.Ldc_I4, Convert.ToInt32(constant));
									}
								}
								else
								{
									il.Emit(OpCodes.Ldc_I8, (long)num4);
								}
							}
							else
							{
								il.Emit(OpCodes.Ldc_I8, num3);
							}
						}
						else
						{
							il.Emit(OpCodes.Ldc_R8, num2);
						}
					}
					else
					{
						il.Emit(OpCodes.Ldc_R4, num);
					}
				}
				else
				{
					il.Emit(OpCodes.Ldc_I4, flag ? 1 : 0);
				}
			}
			else
			{
				il.Emit(OpCodes.Ldnull);
			}
		}

		private static IEnumerable<string> SillyPaths()
		{
			if (!Directory.Exists(Paths.PluginPath))
			{
				return Array.Empty<string>();
			}
			return Directory.GetFiles(Paths.PluginPath, "SillyValuables.dll", SearchOption.AllDirectories);
		}

		private static string OriginalName(string name)
		{
			if (!name.StartsWith("__SillyValuablesFix__", StringComparison.Ordinal))
			{
				return name;
			}
			int num = name.LastIndexOf("__", StringComparison.Ordinal);
			if (num <= "__SillyValuablesFix__".Length)
			{
				return name;
			}
			return name.Substring("__SillyValuablesFix__".Length, num - "__SillyValuablesFix__".Length);
		}

		private static string Digest(string value)
		{
			return Digest(Encoding.UTF8.GetBytes(value));
		}

		private static string Digest(byte[] data)
		{
			using SHA256 sHA = SHA256.Create();
			return BitConverter.ToString(sHA.ComputeHash(data)).Replace("-", "").ToLowerInvariant();
		}

		private static void RewriteSillyReferences(ModuleDefinition game)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			foreach (string item in SillyPaths())
			{
				try
				{
					byte[] array = File.ReadAllBytes(item);
					int num = 0;
					byte[] bytes;
					using (MemoryStream memoryStream = new MemoryStream(array))
					{
						ModuleDefinition val = ModuleDefinition.ReadModule((Stream)memoryStream, new ReaderParameters
						{
							ReadSymbols = false
						});
						try
						{
							if (((AssemblyNameReference)val.Assembly.Name).Name != "SillyValuables")
							{
								continue;
							}
							if (((AssemblyNameReference)val.Assembly.Name).HasPublicKey)
							{
								Log.LogWarning((object)("Signed SillyValuables build skipped: " + item));
								continue;
							}
							foreach (MemberReference memberReference in val.GetMemberReferences())
							{
								MethodReference val2 = (MethodReference)(object)((memberReference is MethodReference) ? memberReference : null);
								if (val2 == null || memberReference is MethodSpecification)
								{
									continue;
								}
								TypeReference declaringType = ((MemberReference)val2).DeclaringType;
								object obj;
								if (declaringType == null)
								{
									obj = null;
								}
								else
								{
									IMetadataScope scope = declaringType.Scope;
									obj = ((scope != null) ? scope.Name : null);
								}
								if ((string?)obj != "Assembly-CSharp")
								{
									continue;
								}
								Wanted wanted = new Wanted
								{
									Type = ((MemberReference)((MemberReference)val2).DeclaringType).FullName,
									Name = OriginalName(((MemberReference)val2).Name),
									HasThis = val2.HasThis,
									Return = ((MemberReference)val2.ReturnType).FullName,
									Params = ((IEnumerable<ParameterDefinition>)val2.Parameters).Select((ParameterDefinition p) => ((MemberReference)((ParameterReference)p).ParameterType).FullName).ToArray()
								};
								if (!(((MemberReference)val2).Name == wanted.BridgeName))
								{
									TypeDefinition type = game.GetType(wanted.Type);
									if (type != null && ((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == wanted.BridgeName))
									{
										((MemberReference)val2).Name = wanted.BridgeName;
										num++;
									}
								}
							}
							if (num == 0)
							{
								Log.LogInfo((object)("SillyValuables references already compatible: " + item));
								continue;
							}
							using (MemoryStream memoryStream2 = new MemoryStream())
							{
								val.Write((Stream)memoryStream2);
								bytes = memoryStream2.ToArray();
							}
							goto IL_025f;
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					IL_025f:
					string text = Path.Combine(Paths.BepInExRootPath, "cache", "SillyValuablesFix", Digest(array));
					Directory.CreateDirectory(text);
					string text2 = Path.Combine(text, "SillyValuables.dll.original");
					if (!File.Exists(text2))
					{
						File.WriteAllBytes(text2, array);
					}
					if (!File.ReadAllBytes(text2).SequenceEqual(array))
					{
						throw new IOException("Backup verification failed");
					}
					if (!File.ReadAllBytes(item).SequenceEqual(array))
					{
						throw new IOException("SillyValuables changed during preload; retry next launch");
					}
					string text3 = item + ".svfix.pending";
					File.WriteAllBytes(text3, bytes);
					File.Replace(text3, item, null);
					Log.LogInfo((object)$"Updated {num} outdated SillyValuables reference(s). Original backup: {text2}");
				}
				catch (Exception ex)
				{
					Log.LogError((object)("Could not prepare SillyValuables; original backup is retained: " + ex));
				}
			}
		}

		private static void RestoreOriginalCallNames()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			foreach (string item in SillyPaths())
			{
				try
				{
					byte[] array = File.ReadAllBytes(item);
					int num = 0;
					byte[] bytes;
					using (MemoryStream memoryStream = new MemoryStream(array))
					{
						ModuleDefinition val = ModuleDefinition.ReadModule((Stream)memoryStream, new ReaderParameters
						{
							ReadSymbols = false
						});
						try
						{
							if (((AssemblyNameReference)val.Assembly.Name).Name != "SillyValuables" || ((AssemblyNameReference)val.Assembly.Name).HasPublicKey)
							{
								continue;
							}
							foreach (MemberReference memberReference in val.GetMemberReferences())
							{
								MethodReference val2 = (MethodReference)(object)((memberReference is MethodReference) ? memberReference : null);
								if (val2 == null)
								{
									continue;
								}
								TypeReference declaringType = ((MemberReference)val2).DeclaringType;
								object obj;
								if (declaringType == null)
								{
									obj = null;
								}
								else
								{
									IMetadataScope scope = declaringType.Scope;
									obj = ((scope != null) ? scope.Name : null);
								}
								if (!((string?)obj != "Assembly-CSharp"))
								{
									string text = OriginalName(((MemberReference)val2).Name);
									if (!(text == ((MemberReference)val2).Name))
									{
										((MemberReference)val2).Name = text;
										num++;
									}
								}
							}
							if (num == 0)
							{
								continue;
							}
							using (MemoryStream memoryStream2 = new MemoryStream())
							{
								val.Write((Stream)memoryStream2);
								bytes = memoryStream2.ToArray();
							}
							goto IL_014f;
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					IL_014f:
					string text2 = Path.Combine(Paths.BepInExRootPath, "cache", "ValuablesPatchpack", "disabled-SillyValuables", Digest(array));
					Directory.CreateDirectory(text2);
					string text3 = Path.Combine(text2, "SillyValuables.dll.before-disable");
					if (!File.Exists(text3))
					{
						File.WriteAllBytes(text3, array);
					}
					if (!File.ReadAllBytes(text3).SequenceEqual(array))
					{
						throw new IOException("Disable backup verification failed");
					}
					if (!File.ReadAllBytes(item).SequenceEqual(array))
					{
						throw new IOException("SillyValuables changed while disabling its module");
					}
					string text4 = item + ".vp-disable.pending";
					File.WriteAllBytes(text4, bytes);
					File.Replace(text4, item, null);
					Log.LogInfo((object)$"SillyValuables module disabled: restored {num} original call name(s). Backup: {text3}");
				}
				catch (Exception ex)
				{
					Log.LogError((object)("Could not undo SillyValuables compatibility redirection: " + ex));
				}
			}
		}

		private static MethodDefinition ReleaseObjectRpcShim(ModuleDefinition module, TypeDefinition type)
		{
			//IL_00d3: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: 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_01d9: 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_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			FieldDefinition val = ((IEnumerable<FieldDefinition>)type.Fields).FirstOrDefault((Func<FieldDefinition, bool>)((FieldDefinition f) => ((MemberReference)f).Name == "isLocal" && (int)((FieldReference)f).FieldType.MetadataType == 2));
			FieldDefinition val2 = ((IEnumerable<FieldDefinition>)type.Fields).FirstOrDefault((Func<FieldDefinition, bool>)((FieldDefinition f) => ((MemberReference)f).Name == "grabbed" && (int)((FieldReference)f).FieldType.MetadataType == 2));
			FieldDefinition val3 = ((IEnumerable<FieldDefinition>)type.Fields).FirstOrDefault((Func<FieldDefinition, bool>)((FieldDefinition f) => ((MemberReference)f).Name == "grabDisableTimer" && (int)((FieldReference)f).FieldType.MetadataType == 12));
			MethodDefinition val4 = ((IEnumerable<MethodDefinition>)type.Methods).FirstOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "ReleaseObject" && ((MethodReference)m).HasThis && ((MethodReference)m).Parameters.Count == 2 && (int)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType.MetadataType == 8 && (int)((ParameterReference)((MethodReference)m).Parameters[1]).ParameterType.MetadataType == 12));
			if (val == null || val2 == null || val3 == null || val4 == null)
			{
				return null;
			}
			TypeSystem typeSystem = module.TypeSystem;
			MethodDefinition val5 = new MethodDefinition("ReleaseObjectRPC", (MethodAttributes)134, typeSystem.Void);
			((MethodReference)val5).Parameters.Add(new ParameterDefinition("_physGrabEnded", (ParameterAttributes)0, typeSystem.Boolean));
			((MethodReference)val5).Parameters.Add(new ParameterDefinition("_disableTimer", (ParameterAttributes)0, typeSystem.Single));
			VariableDefinition val6 = new VariableDefinition(typeSystem.Boolean);
			val5.Body.Variables.Add(val6);
			val5.Body.InitLocals = true;
			ILProcessor iLProcessor = val5.Body.GetILProcessor();
			Instruction val7 = iLProcessor.Create(OpCodes.Ret);
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Ldfld, (FieldReference)(object)val);
			iLProcessor.Emit(OpCodes.Brfalse, val7);
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Ldfld, (FieldReference)(object)val2);
			iLProcessor.Emit(OpCodes.Stloc, val6);
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Ldc_I4_M1);
			iLProcessor.Emit(OpCodes.Ldarg_2);
			iLProcessor.Emit(OpCodes.Call, (MethodReference)(object)val4);
			iLProcessor.Emit(OpCodes.Ldloc, val6);
			iLProcessor.Emit(OpCodes.Brtrue, val7);
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Ldarg_2);
			iLProcessor.Emit(OpCodes.Stfld, (FieldReference)(object)val3);
			iLProcessor.Append(val7);
			return val5;
		}
	}
	internal static class MoreUpgradesInputPatcher
	{
		internal const string HelperName = "ModlistPatchpackCompat.MoreUpgradesInputApi";

		private static readonly string[] Names = new string[3] { "KeyUp", "KeyDown", "KeyHold" };

		private static readonly ManualLogSource Log = Logger.CreateLogSource("Modlist-patchpack MoreUpgrades");

		internal static void Prepare()
		{
			if (!Directory.Exists(Paths.PluginPath))
			{
				return;
			}
			foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, "MoreUpgrades.dll", SearchOption.AllDirectories))
			{
				try
				{
					byte[] array = File.ReadAllBytes(item);
					using MemoryStream memoryStream = new MemoryStream(array);
					ModuleDefinition val = ModuleDefinition.ReadModule((Stream)memoryStream);
					try
					{
						TypeDefinition type = val.GetType("MoreUpgrades.Plugin");
						if (!(((AssemblyNameReference)val.Assembly.Name).Name == "MoreUpgrades") || type == null || !((IEnumerable<CustomAttribute>)type.CustomAttributes).Any(delegate(CustomAttribute a)
						{
							//IL_002c: 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)
							if (((MemberReference)a.AttributeType).FullName == "BepInEx.BepInPlugin" && a.ConstructorArguments.Count == 3)
							{
								CustomAttributeArgument val3 = a.ConstructorArguments[0];
								return object.Equals(((CustomAttributeArgument)(ref val3)).Value, "bulletbot.moreupgrades");
							}
							return false;
						}) || ((AssemblyNameReference)val.Assembly.Name).HasPublicKey)
						{
							continue;
						}
						bool moreUpgradesEnabled = ModuleSettings.MoreUpgradesEnabled;
						int num;
						if (moreUpgradesEnabled)
						{
							ModuleDefinition val2 = ModuleDefinition.ReadModule(Path.Combine(Paths.ManagedPath, "Assembly-CSharp.dll"));
							try
							{
								num = Rewrite(val, val2) + MoreUpgradesShopPatcher.Rewrite(val, val2);
							}
							finally
							{
								((IDisposable)val2)?.Dispose();
							}
						}
						else
						{
							num = Restore(val) + MoreUpgradesShopPatcher.Restore(val);
						}
						if (num != 0)
						{
							byte[] updated;
							using (MemoryStream memoryStream2 = new MemoryStream())
							{
								val.Write((Stream)memoryStream2);
								updated = memoryStream2.ToArray();
							}
							Save(item, array, updated, moreUpgradesEnabled);
							Log.LogInfo((object)(moreUpgradesEnabled ? $"Prepared {num} MoreUpgrades input/shop compatibility change(s). Native input blocking and current shop rules retained." : $"MoreUpgrades module disabled: restored {num} original input/shop part(s)."));
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				catch (Exception ex)
				{
					Log.LogError((object)("Could not prepare MoreUpgrades input compatibility; backup retained if created: " + ex));
				}
			}
		}

		private static IEnumerable<TypeDefinition> AllTypes(IEnumerable<TypeDefinition> types)
		{
			return types.SelectMany((TypeDefinition t) => ((IEnumerable<TypeDefinition>)(object)new TypeDefinition[1] { t }).Concat(AllTypes((IEnumerable<TypeDefinition>)t.NestedTypes)));
		}

		private static bool Legacy(MethodReference method)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			if (method != null && method.HasThis && ((MemberReference)((MemberReference)method).DeclaringType).FullName == "InputManager")
			{
				IMetadataScope scope = ((MemberReference)method).DeclaringType.Scope;
				if (((scope != null) ? scope.Name : null) == "Assembly-CSharp" && Names.Contains(((MemberReference)method).Name) && (int)method.ReturnType.MetadataType == 2 && method.Parameters.Count == 1)
				{
					return ((MemberReference)((ParameterReference)method.Parameters[0]).ParameterType).FullName == "InputKey";
				}
			}
			return false;
		}

		internal static int Rewrite(ModuleDefinition mod, ModuleDefinition game)
		{
			//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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			TypeDefinition type = game.GetType("InputManager");
			if (type == null)
			{
				return 0;
			}
			TypeDefinition val = mod.GetType("ModlistPatchpackCompat.MoreUpgradesInputApi");
			int num = 0;
			TypeDefinition[] array = AllTypes((IEnumerable<TypeDefinition>)mod.Types).ToArray();
			foreach (TypeDefinition val2 in array)
			{
				if (val2 == val)
				{
					continue;
				}
				foreach (MethodDefinition item in ((IEnumerable<MethodDefinition>)val2.Methods).Where((MethodDefinition m) => m.HasBody))
				{
					Enumerator<Instruction> enumerator2 = item.Body.Instructions.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							Instruction current = enumerator2.Current;
							if (current.OpCode != OpCodes.Callvirt)
							{
								continue;
							}
							object operand = current.Operand;
							MethodReference old = (MethodReference)((operand is MethodReference) ? operand : null);
							if (old == null || !Legacy(old) || ((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == ((MemberReference)old).Name && ((MethodReference)m).HasThis && ((MethodReference)m).Parameters.Count == 1 && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType).FullName == "InputKey" && (int)((MethodReference)m).ReturnType.MetadataType == 2))
							{
								continue;
							}
							MethodDefinition val3 = ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == ((MemberReference)old).Name && ((MethodReference)m).HasThis && !((MethodReference)m).HasGenericParameters && (int)((MethodReference)m).ReturnType.MetadataType == 2 && ((MethodReference)m).Parameters.Count == 2 && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType).FullName == "InputKey" && (int)((ParameterReference)((MethodReference)m).Parameters[1]).ParameterType.MetadataType == 2 && ((MethodReference)m).Parameters[1].IsOptional && ((MethodReference)m).Parameters[1].HasConstant && object.Equals(((MethodReference)m).Parameters[1].Constant, false)));
							if (val3 != null)
							{
								if (val == null)
								{
									val = new TypeDefinition("ModlistPatchpackCompat", "MoreUpgradesInputApi", (TypeAttributes)384, mod.TypeSystem.Object);
									mod.Types.Add(val);
								}
								MethodDefinition val4 = ((IEnumerable<MethodDefinition>)val.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == ((MemberReference)old).Name));
								if (val4 == null)
								{
									val4 = new MethodDefinition(((MemberReference)old).Name, (MethodAttributes)147, mod.TypeSystem.Boolean);
									((MethodReference)val4).Parameters.Add(new ParameterDefinition("manager", (ParameterAttributes)0, mod.ImportReference(((MemberReference)old).DeclaringType)));
									((MethodReference)val4).Parameters.Add(new ParameterDefinition("key", (ParameterAttributes)0, mod.ImportReference(((ParameterReference)old.Parameters[0]).ParameterType)));
									val.Methods.Add(val4);
									ILProcessor iLProcessor = val4.Body.GetILProcessor();
									iLProcessor.Emit(OpCodes.Ldarg_0);
									iLProcessor.Emit(OpCodes.Ldarg_1);
									iLProcessor.Emit(OpCodes.Ldc_I4_0);
									iLProcessor.Emit(OpCodes.Callvirt, mod.ImportReference((MethodReference)(object)val3));
									iLProcessor.Emit(OpCodes.Ret);
								}
								current.OpCode = OpCodes.Call;
								current.Operand = val4;
								num++;
							}
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
				}
			}
			return num;
		}

		internal static int Restore(ModuleDefinition mod)
		{
			//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)
			//IL_008a: 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_016f: 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_017d: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			TypeDefinition type = mod.GetType("ModlistPatchpackCompat.MoreUpgradesInputApi");
			if (type == null)
			{
				return 0;
			}
			int num = 0;
			foreach (TypeDefinition item in AllTypes((IEnumerable<TypeDefinition>)mod.Types))
			{
				foreach (MethodDefinition item2 in ((IEnumerable<MethodDefinition>)item.Methods).Where((MethodDefinition m) => m.HasBody))
				{
					Enumerator<Instruction> enumerator3 = item2.Body.Instructions.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							Instruction current = enumerator3.Current;
							if (!(current.OpCode != OpCodes.Call))
							{
								object operand = current.Operand;
								MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
								if (val != null && !(((MemberReference)((MemberReference)val).DeclaringType).FullName != "ModlistPatchpackCompat.MoreUpgradesInputApi") && Names.Contains(((MemberReference)val).Name) && !val.HasThis && val.Parameters.Count == 2 && !(((MemberReference)((ParameterReference)val.Parameters[0]).ParameterType).FullName != "InputManager") && !(((MemberReference)((ParameterReference)val.Parameters[1]).ParameterType).FullName != "InputKey"))
								{
									MethodReference val2 = new MethodReference(((MemberReference)val).Name, mod.TypeSystem.Boolean, ((ParameterReference)val.Parameters[0]).ParameterType)
									{
										HasThis = true
									};
									val2.Parameters.Add(new ParameterDefinition(((ParameterReference)val.Parameters[1]).ParameterType));
									current.OpCode = OpCodes.Callvirt;
									current.Operand = val2;
									num++;
								}
							}
						}
					}
					finally
					{
						((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
					}
				}
			}
			if (num > 0)
			{
				mod.Types.Remove(type);
			}
			return num;
		}

		private static void Save(string path, byte[] original, byte[] updated, bool enabled)
		{
			string text;
			using (SHA256 sHA = SHA256.Create())
			{
				text = BitConverter.ToString(sHA.ComputeHash(original)).Replace("-", "").ToLowerInvariant();
			}
			string text2 = Path.Combine(Paths.BepInExRootPath, "cache", "Modlist-patchpack", "MoreUpgrades-input", text);
			Directory.CreateDirectory(text2);
			string text3 = Path.Combine(text2, enabled ? "MoreUpgrades.dll.original" : "MoreUpgrades.dll.before-disable");
			if (!File.Exists(text3))
			{
				File.WriteAllBytes(text3, original);
			}
			if (!File.ReadAllBytes(text3).SequenceEqual(original))
			{
				throw new IOException("MoreUpgrades input backup verification failed");
			}
			if (!File.ReadAllBytes(path).SequenceEqual(original))
			{
				throw new IOException("MoreUpgrades changed during input preparation; retry next launch");
			}
			string text4 = path + ".modlist-input.pending";
			File.WriteAllBytes(text4, updated);
			File.Replace(text4, path, null);
			Log.LogInfo((object)("Verified pre-change backup: " + text3));
		}
	}
	internal static class MoreUpgradesShopPatcher
	{
		internal const string BackupName = "__ModlistOriginal_GetWeightedUpgradeExcludingTranspiler";

		internal const string InventoryBackupName = "__ModlistOriginal_GetAllItemsFromStatsManagerTranspiler";

		internal static int Rewrite(ModuleDefinition mod, ModuleDefinition game)
		{
			return RewriteOne(mod, game, "MoreUpgrades.Patches.UpgradeStandPatch", "GetWeightedUpgradeExcludingTranspiler", "__ModlistOriginal_GetWeightedUpgradeExcludingTranspiler", "UpgradeStand", "GetWeightedUpgradeExcluding", 4) + RewriteOne(mod, game, "MoreUpgrades.Patches.ShopManagerPatch", "GetAllItemsFromStatsManagerTranspiler", "__ModlistOriginal_GetAllItemsFromStatsManagerTranspiler", "ShopManager", "GetAllItemsFromStatsManager", 0);
		}

		private static int RewriteOne(ModuleDefinition mod, ModuleDefinition game, string typeName, string methodName, string backupName, string nativeType, string nativeMethod, int parameters)
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			//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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected O, but got Unknown
			//IL_01a9: 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)
			TypeDefinition type = mod.GetType(typeName);
			MethodDefinition val = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == methodName && m.IsStatic && ((MethodReference)m).Parameters.Count == 1)) : null);
			TypeDefinition type2 = game.GetType(nativeType);
			MethodDefinition val2 = ((type2 != null) ? ((IEnumerable<MethodDefinition>)type2.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == nativeMethod && ((MethodReference)m).Parameters.Count == parameters)) : null);
			if (val == null || val2 == null || !val2.HasBody || ((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == backupName))
			{
				return 0;
			}
			bool num = val.HasBody && ((IEnumerable<Instruction>)val.Body.Instructions).Any(delegate(Instruction i)
			{
				object operand = i.Operand;
				TypeReference val4 = (TypeReference)((operand is TypeReference) ? operand : null);
				return val4 != null && ((MemberReference)val4).FullName.Contains("/ValueCollection/Enumerator");
			});
			bool flag = ((IEnumerable<Instruction>)val2.Body.Instructions).Any(delegate(Instruction i)
			{
				object operand = i.Operand;
				MethodReference val4 = (MethodReference)((operand is MethodReference) ? operand : null);
				return val4 != null && ((MemberReference)val4).Name == "get_Current" && ((MemberReference)((MemberReference)val4).DeclaringType).FullName.StartsWith("System.Collections.Generic.IEnumerator`1", StringComparison.Ordinal);
			});
			if (!num || !flag)
			{
				return 0;
			}
			MethodDefinition val3 = new MethodDefinition(backupName, (MethodAttributes)145, ((MethodReference)val).ReturnType);
			Enumerator<ParameterDefinition> enumerator = ((MethodReference)val).Parameters.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ParameterDefinition current = enumerator.Current;
					((MethodReference)val3).Parameters.Add(new ParameterDefinition(((ParameterReference)current).Name, current.Attributes, ((ParameterReference)current).ParameterType));
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			CopyBody(val, val3);
			type.Methods.Add(val3);
			val.Body = new MethodBody(val);
			ILProcessor iLProcessor = val.Body.GetILProcessor();
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Ret);
			return 1;
		}

		internal static int Restore(ModuleDefinition mod)
		{
			return RestoreOne(mod, "MoreUpgrades.Patches.UpgradeStandPatch", "GetWeightedUpgradeExcludingTranspiler", "__ModlistOriginal_GetWeightedUpgradeExcludingTranspiler") + RestoreOne(mod, "MoreUpgrades.Patches.ShopManagerPatch", "GetAllItemsFromStatsManagerTranspiler", "__ModlistOriginal_GetAllItemsFromStatsManagerTranspiler");
		}

		private static int RestoreOne(ModuleDefinition mod, string typeName, string methodName, string backupName)
		{
			TypeDefinition type = mod.GetType(typeName);
			MethodDefinition val = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == backupName)) : null);
			MethodDefinition val2 = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == methodName && ((MethodReference)m).Parameters.Count == 1)) : null);
			if (val == null || val2 == null)
			{
				return 0;
			}
			CopyBody(val, val2);
			type.Methods.Remove(val);
			return 1;
		}

		internal static void CopyBody(MethodDefinition source, MethodDefinition target)
		{
			//IL_0007: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0089: 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_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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: 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_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			MethodBody val = new MethodBody(target)
			{
				InitLocals = source.Body.InitLocals,
				MaxStackSize = source.Body.MaxStackSize
			};
			Dictionary<VariableDefinition, VariableDefinition> dictionary = ((IEnumerable<VariableDefinition>)source.Body.Variables).ToDictionary((Func<VariableDefinition, VariableDefinition>)((VariableDefinition v) => v), (Func<VariableDefinition, VariableDefinition>)((VariableDefinition v) => new VariableDefinition(((VariableReference)v).VariableType)));
			Enumerator<VariableDefinition> enumerator = source.Body.Variables.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					VariableDefinition current = enumerator.Current;
					val.Variables.Add(dictionary[current]);
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			Dictionary<Instruction, Instruction> instructions = ((IEnumerable<Instruction>)source.Body.Instructions).ToDictionary((Instruction i) => i, (Instruction i) => Instruction.Create(OpCodes.Nop));
			Enumerator<Instruction> enumerator2 = source.Body.Instructions.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					Instruction current2 = enumerator2.Current;
					Instruction val2 = instructions[current2];
					val2.OpCode = current2.OpCode;
					object operand = current2.Operand;
					Instruction val3 = (Instruction)((operand is Instruction) ? operand : null);
					object operand4;
					if (val3 == null)
					{
						if (!(current2.Operand is Instruction[] source2))
						{
							object operand2 = current2.Operand;
							VariableDefinition val4 = (VariableDefinition)((operand2 is VariableDefinition) ? operand2 : null);
							if (val4 == null)
							{
								object operand3 = current2.Operand;
								ParameterDefinition val5 = (ParameterDefinition)((operand3 is ParameterDefinition) ? operand3 : null);
								operand4 = ((val5 != null) ? ((MethodReference)target).Parameters[((ParameterReference)val5).Index] : current2.Operand);
							}
							else
							{
								operand4 = dictionary[val4];
							}
						}
						else
						{
							operand4 = source2.Select((Instruction i) => instructions[i]).ToArray();
						}
					}
					else
					{
						operand4 = instructions[val3];
					}
					val2.Operand = operand4;
					val.Instructions.Add(val2);
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
			Enumerator<ExceptionHandler> enumerator3 = source.Body.ExceptionHandlers.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					ExceptionHandler current3 = enumerator3.Current;
					val.ExceptionHandlers.Add(new ExceptionHandler(current3.HandlerType)
					{
						CatchType = current3.CatchType,
						TryStart = Map(current3.TryStart),
						TryEnd = Map(current3.TryEnd),
						HandlerStart = Map(current3.HandlerStart),
						HandlerEnd = Map(current3.HandlerEnd),
						FilterStart = Map(current3.FilterStart)
					});
				}
			}
			finally
			{
				((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
			target.Body = val;
			Instruction Map(Instruction instruction)
			{
				if (instruction != null)
				{
					return instructions[instruction];
				}
				return null;
			}
		}
	}
	internal static class PresentsApiPatcher
	{
		internal const string HelperName = "ModlistPatchpackCompat.REPOPresentsValuableApi";

		private static readonly ManualLogSource Log = Logger.CreateLogSource("Modlist-patchpack REPOPresents");

		private static IEnumerable<TypeDefinition> Types(IEnumerable<TypeDefinition> source)
		{
			return source.SelectMany((TypeDefinition t) => ((IEnumerable<TypeDefinition>)(object)new TypeDefinition[1] { t }).Concat(Types((IEnumerable<TypeDefinition>)t.NestedTypes)));
		}

		internal static void Prepare()
		{
			if (!Directory.Exists(Paths.PluginPath))
			{
				return;
			}
			foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, "REPOPresents.dll", SearchOption.AllDirectories))
			{
				try
				{
					byte[] array = File.ReadAllBytes(item);
					ModuleDefinition val = ModuleDefinition.ReadModule((Stream)new MemoryStream(array));
					try
					{
						if (!(((AssemblyNameReference)val.Assembly.Name).Name == "REPOPresents") || !Types((IEnumerable<TypeDefinition>)val.Types).Any((TypeDefinition t) => ((IEnumerable<CustomAttribute>)t.CustomAttributes).Any(delegate(CustomAttribute a)
						{
							//IL_002c: 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)
							if (((MemberReference)a.AttributeType).FullName == "BepInEx.BepInPlugin" && a.ConstructorArguments.Count == 3)
							{
								CustomAttributeArgument val4 = a.ConstructorArguments[0];
								return object.Equals(((CustomAttributeArgument)(ref val4)).Value, "REPOPresents");
							}
							return false;
						})) || ((AssemblyNameReference)val.Assembly.Name).HasPublicKey)
						{
							continue;
						}
						bool presentsEnabled = ModuleSettings.PresentsEnabled;
						int num = 0;
						if (!presentsEnabled)
						{
							num = Restore(val);
							goto IL_0142;
						}
						string text = Directory.EnumerateFiles(Paths.PluginPath, "REPOLib.dll", SearchOption.AllDirectories).FirstOrDefault();
						if (text == null)
						{
							continue;
						}
						ModuleDefinition val2 = ModuleDefinition.ReadModule(text);
						try
						{
							ModuleDefinition val3 = ModuleDefinition.ReadModule(Path.Combine(Paths.ManagedPath, "Assembly-CSharp.dll"));
							try
							{
								num = Rewrite(val, val2) + PresentsPoolPatcher.Rewrite(val, val3) + PresentsSpawnPatcher.Rewrite(val, val2, val3);
							}
							finally
							{
								((IDisposable)val3)?.Dispose();
							}
						}
						finally
						{
							((IDisposable)val2)?.Dispose();
						}
						goto IL_0142;
						IL_0142:
						if (num != 0)
						{
							byte[] bytes;
							using (MemoryStream memoryStream = new MemoryStream())
							{
								val.Write((Stream)memoryStream);
								bytes = memoryStream.ToArray();
							}
							string text2;
							using (SHA256 sHA = SHA256.Create())
							{
								text2 = BitConverter.ToString(sHA.ComputeHash(array)).Replace("-", "").ToLowerInvariant();
							}
							string text3 = Path.Combine(Paths.BepInExRootPath, "cache", "Modlist-patchpack", "REPOPresents", text2);
							Directory.CreateDirectory(text3);
							string text4 = Path.Combine(text3, presentsEnabled ? "REPOPresents.dll.original" : "REPOPresents.dll.before-disable");
							if (!File.Exists(text4))
							{
								File.WriteAllBytes(text4, array);
							}
							if (!File.ReadAllBytes(text4).SequenceEqual(array) || !File.ReadAllBytes(item).SequenceEqual(array))
							{
								throw new IOException("REPOPresents backup verification/concurrent change check failed");
							}
							string text5 = item + ".modlist-presents.pending";
							File.WriteAllBytes(text5, bytes);
							File.Replace(text5, item, null);
							Log.LogInfo((object)((presentsEnabled ? "Adapted " : "Restored ") + num + " REPOPresents registration/pool/spawn part(s). Verified backup: " + text4));
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				catch (Exception ex)
				{
					Log.LogError((object)("REPOPresents preparation failed; other modules continue: " + ex));
				}
			}
		}

		internal static int Rewrite(ModuleDefinition mod, ModuleDefinition repo)
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_0190: 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_01ad: 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)
			TypeDefinition type = repo.GetType("REPOLib.Modules.Valuables");
			MethodDefinition val = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "RegisterValuable" && m.IsStatic && ((MethodReference)m).Parameters.Count == 1 && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType).FullName == "UnityEngine.GameObject" && ((MemberReference)((MethodReference)m).ReturnType).FullName == "PrefabRef")) : null);
			if (val == null)
			{
				return 0;
			}
			List<Instruction> list = (from m in Types((IEnumerable<TypeDefinition>)mod.Types).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
				where m.HasBody
				select m).SelectMany((MethodDefinition m) => (IEnumerable<Instruction>)m.Body.Instructions).Where(delegate(Instruction i)
			{
				//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_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Invalid comparison between Unknown and I4
				if (i.OpCode == OpCodes.Call)
				{
					object operand = i.Operand;
					MethodReference val4 = (MethodReference)((operand is MethodReference) ? operand : null);
					if (val4 != null && ((MemberReference)((MemberReference)val4).DeclaringType).FullName == "REPOLib.Modules.Valuables")
					{
						IMetadataScope scope = ((MemberReference)val4).DeclaringType.Scope;
						if (((scope != null) ? scope.Name : null) == "REPOLib" && ((MemberReference)val4).Name == "RegisterValuable" && !val4.HasThis && val4.Parameters.Count == 1 && ((MemberReference)((ParameterReference)val4.Parameters[0]).ParameterType).FullName == "UnityEngine.GameObject")
						{
							return (int)val4.ReturnType.MetadataType == 1;
						}
					}
				}
				return false;
			}).ToList();
			if (list.Count == 0)
			{
				return 0;
			}
			if (mod.GetType("ModlistPatchpackCompat.REPOPresentsValuableApi") != null)
			{
				throw new InvalidOperationException("Unexpected existing REPOPresents helper with unresolved calls");
			}
			TypeDefinition val2 = new TypeDefinition("ModlistPatchpackCompat", "REPOPresentsValuableApi", (TypeAttributes)384, mod.TypeSystem.Object);
			mod.Types.Add(val2);
			MethodDefinition val3 = new MethodDefinition("RegisterValuable", (MethodAttributes)147, mod.TypeSystem.Void);
			((MethodReference)val3).Parameters.Add(new ParameterDefinition("prefab", (ParameterAttributes)0, mod.ImportReference(((ParameterReference)((MethodReference)val).Parameters[0]).ParameterType)));
			val2.Methods.Add(val3);
			ILProcessor iLProcessor = val3.Body.GetILProcessor();
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Call, mod.ImportReference((MethodReference)(object)val));
			iLProcessor.Emit(OpCodes.Pop);
			iLProcessor.Emit(OpCodes.Ret);
			foreach (Instruction item in list)
			{
				item.Operand = val3;
			}
			return list.Count;
		}

		internal static int Restore(ModuleDefinition mod)
		{
			//IL_00c7: 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_00d4: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//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_01a2: 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)
			int num = PresentsPoolPatcher.Restore(mod) + PresentsSpawnPatcher.Restore(mod);
			TypeDefinition helper = mod.GetType("ModlistPatchpackCompat.REPOPresentsValuableApi");
			if (helper == null)
			{
				return num;
			}
			MethodReference val = (from i in ((IEnumerable<MethodDefinition>)helper.Methods).SelectMany((MethodDefinition m) => (IEnumerable<Instruction>)m.Body.Instructions)
				select i.Operand).OfType<MethodReference>().SingleOrDefault((Func<MethodReference, bool>)((MethodReference m) => ((MemberReference)((MemberReference)m).DeclaringType).FullName == "REPOLib.Modules.Valuables" && ((MemberReference)m).Name == "RegisterValuable"));
			if (val == null)
			{
				return 0;
			}
			MethodReference val2 = new MethodReference("RegisterValuable", mod.TypeSystem.Void, ((MemberReference)val).DeclaringType)
			{
				HasThis = false
			};
			val2.Parameters.Add(new ParameterDefinition(((ParameterReference)val.Parameters[0]).ParameterType));
			int num2 = 0;
			foreach (MethodDefinition item in from m in (from t in Types((IEnumerable<TypeDefinition>)mod.Types)
					where t != helper
					select t).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
				where m.HasBody
				select m)
			{
				Enumerator<Instruction> enumerator2 = item.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						Instruction current = enumerator2.Current;
						if (current.OpCode == OpCodes.Call)
						{
							object operand = current.Operand;
							MethodReference val3 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val3 != null && ((MemberReference)((MemberReference)val3).DeclaringType).FullName == "ModlistPatchpackCompat.REPOPresentsValuableApi")
							{
								current.Operand = val2;
								num2++;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			mod.Types.Remove(helper);
			return num2 + num;
		}
	}
	internal static class PresentsPoolPatcher
	{
		internal const string BackupName = "__ModlistOriginal_GetValuablesByVolumeType";

		internal static int Rewrite(ModuleDefinition mod, ModuleDefinition game)
		{
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: 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_01e9: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			TypeDefinition type = mod.GetType("REPOPresents.ValuableUtil");
			MethodDefinition method = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "GetValuablesByVolumeType" && m.IsStatic && ((MethodReference)m).Parameters.Count == 2)) : null);
			if (method == null || !method.HasBody || ((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == "__ModlistOriginal_GetValuablesByVolumeType"))
			{
				return 0;
			}
			List<FieldReference> list = (from f in ((IEnumerable<Instruction>)method.Body.Instructions).Select((Instruction i) => i.Operand).OfType<FieldReference>()
				where ((MemberReference)((MemberReference)f).DeclaringType).FullName == "LevelValuables"
				select f).ToList();
			TypeDefinition native = game.GetType("LevelValuables");
			if (list.Count != 7 || list.Any(delegate(FieldReference f)
			{
				if (!(((MemberReference)f.FieldType).FullName != "System.Collections.Generic.List`1<UnityEngine.GameObject>"))
				{
					TypeDefinition obj = native;
					object obj2;
					if (obj == null)
					{
						obj2 = null;
					}
					else
					{
						FieldDefinition? obj3 = ((IEnumerable<FieldDefinition>)obj.Fields).SingleOrDefault((Func<FieldDefinition, bool>)((FieldDefinition n) => ((MemberReference)n).Name == ((MemberReference)f).Name));
						obj2 = ((obj3 != null) ? ((MemberReference)((FieldReference)obj3).FieldType).FullName : null);
					}
					return (string?)obj2 != "System.Collections.Generic.List`1<PrefabRef>";
				}
				return true;
			}))
			{
				return 0;
			}
			MethodReference val = ((IEnumerable<Instruction>)method.Body.Instructions).Select((Instruction i) => i.Operand).OfType<MethodReference>().SingleOrDefault((Func<MethodReference, bool>)((MethodReference m) => ((MemberReference)m).Name == ".ctor" && ((MemberReference)((MemberReference)m).DeclaringType).FullName == ((MemberReference)((MethodReference)method).ReturnType).FullName && m.Parameters.Count == 0));
			if (val == null || ((MemberReference)((MethodReference)method).ReturnType).FullName != "System.Collections.Generic.List`1<UnityEngine.GameObject>")
			{
				return 0;
			}
			MethodDefinition val2 = new MethodDefinition("__ModlistOriginal_GetValuablesByVolumeType", (MethodAttributes)145, ((MethodReference)method).ReturnType);
			Enumerator<ParameterDefinition> enumerator = ((MethodReference)method).Parameters.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ParameterDefinition current = enumerator.Current;
					((MethodReference)val2).Parameters.Add(new ParameterDefinition(((ParameterReference)current).Name, current.Attributes, ((ParameterReference)current).ParameterType));
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			MoreUpgradesShopPatcher.CopyBody(method, val2);
			type.Methods.Add(val2);
			method.Body = new MethodBody(method);
			ILProcessor iLProcessor = method.Body.GetILProcessor();
			iLProcessor.Emit(OpCodes.Newobj, val);
			iLProcessor.Emit(OpCodes.Ret);
			return 1;
		}

		internal static int Restore(ModuleDefinition mod)
		{
			TypeDefinition type = mod.GetType("REPOPresents.ValuableUtil");
			MethodDefinition val = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "__ModlistOriginal_GetValuablesByVolumeType")) : null);
			MethodDefinition val2 = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "GetValuablesByVolumeType" && ((MethodReference)m).Parameters.Count == 2)) : null);
			if (val == null || val2 == null)
			{
				return 0;
			}
			MoreUpgradesShopPatcher.CopyBody(val, val2);
			type.Methods.Remove(val);
			return 1;
		}
	}
	internal static class PresentsSpawnPatcher
	{
		internal const string HelperName = "ModlistPatchpackCompat.REPOPresentsSpawnApi";

		private static IEnumerable<TypeDefinition> Types(IEnumerable<TypeDefinition> types)
		{
			return types.SelectMany((TypeDefinition t) => ((IEnumerable<TypeDefinition>)(object)new TypeDefinition[1] { t }).Concat(Types((IEnumerable<TypeDefinition>)t.NestedTypes)));
		}

		internal static int Rewrite(ModuleDefinition mod, ModuleDefinition repo, ModuleDefinition game)
		{
			//IL_01ed: 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_0213: Expected O, but got Unknown
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			//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_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Expected O, but got Unknown
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Expected O, but got Unknown
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Expected O, but got Unknown
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Expected O, but got Unknown
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Expected O, but got Unknown
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Expected O, but got Unknown
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Expected O, but got Unknown
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Expected O, but got Unknown
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Expected O, but got Unknown
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0600: Unknown result type (might be due to invalid IL or missing references)
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_0633: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Expected O, but got Unknown
			TypeDefinition type = repo.GetType("REPOLib.Modules.Valuables");
			MethodDefinition val = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "SpawnValuable" && m.IsStatic && ((MemberReference)((MethodReference)m).ReturnType).FullName == "UnityEngine.GameObject" && ((MethodReference)m).Parameters.Count == 3 && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType).FullName == "PrefabRef" && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[1]).ParameterType).FullName == "UnityEngine.Vector3" && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[2]).ParameterType).FullName == "UnityEngine.Quaternion")) : null);
			MethodDefinition val2 = ((type != null) ? ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "get_AllValuables" && m.IsStatic && ((MethodReference)m).Parameters.Count == 0 && ((MemberReference)((MethodReference)m).ReturnType).FullName == "System.Collections.Generic.IReadOnlyList`1<PrefabRef>")) : null);
			TypeDefinition type2 = game.GetType("PrefabRef");
			if (val != null && val2 != null)
			{
				TypeReference obj = ((type2 != null) ? type2.BaseType : null);
				GenericInstanceType val3 = (GenericInstanceType)(object)((obj is GenericInstanceType) ? obj : null);
				if (val3 != null)
				{
					List<MethodDefinition> source = (from m in Types((IEnumerable<TypeDefinition>)mod.Types).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
						where m.HasBody
						select m).ToList();
					List<Instruction> list = source.SelectMany((MethodDefinition m) => (IEnumerable<Instruction>)m.Body.Instructions).Where(delegate(Instruction i)
					{
						//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)
						if (i.OpCode == OpCodes.Call)
						{
							object operand = i.Operand;
							MethodReference val20 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val20 != null && ((MemberReference)((MemberReference)val20).DeclaringType).FullName == "REPOLib.Modules.Valuables")
							{
								IMetadataScope scope = ((MemberReference)val20).DeclaringType.Scope;
								if (((scope != null) ? scope.Name : null) == "REPOLib" && !val20.HasThis && ((MemberReference)val20).Name == "SpawnValuable" && ((MemberReference)val20.ReturnType).FullName == "UnityEngine.GameObject" && val20.Parameters.Count == 3 && ((MemberReference)((ParameterReference)val20.Parameters[0]).ParameterType).FullName == "ValuableObject" && ((MemberReference)((ParameterReference)val20.Parameters[1]).ParameterType).FullName == "UnityEngine.Vector3")
								{
									return ((MemberReference)((ParameterReference)val20.Parameters[2]).ParameterType).FullName == "UnityEngine.Quaternion";
								}
							}
						}
						return false;
					}).ToList();
					if (list.Count == 0)
					{
						return 0;
					}
					if (mod.GetType("ModlistPatchpackCompat.REPOPresentsSpawnApi") != null)
					{
						throw new InvalidOperationException("Unexpected existing Presents spawn adapter");
					}
					MethodReference val4 = (from i in source.SelectMany((MethodDefinition m) => (IEnumerable<Instruction>)m.Body.Instructions)
						select i.Operand).OfType<MethodReference>().FirstOrDefault((Func<MethodReference, bool>)((MethodReference m) => ((MemberReference)((MemberReference)m).DeclaringType).FullName == "UnityEngine.Object" && ((MemberReference)m).Name == "get_name"));
					if (val4 == null)
					{
						return 0;
					}
					MethodReference val5 = (MethodReference)list[0].Operand;
					TypeDefinition val6 = new TypeDefinition("ModlistPatchpackCompat", "REPOPresentsSpawnApi", (TypeAttributes)384, mod.TypeSystem.Object);
					mod.Types.Add(val6);
					MethodDefinition val7 = new MethodDefinition("SpawnValuable", (MethodAttributes)147, mod.ImportReference(((MethodReference)val).ReturnType));
					Enumerator<ParameterDefinition> enumerator = val5.Parameters.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							ParameterDefinition current = enumerator.Current;
							((MethodReference)val7).Parameters.Add(new ParameterDefinition(((ParameterReference)current).Name, current.Attributes, mod.ImportReference(((ParameterReference)current).ParameterType)));
						}
					}
					finally
					{
						((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
					val6.Methods.Add(val7);
					val7.Body.InitLocals = true;
					GenericInstanceType val8 = (GenericInstanceType)mod.ImportReference(((MethodReference)val2).ReturnType);
					if (((TypeSpecification)val8).ElementType.GenericParameters.Count == 0)
					{
						((TypeSpecification)val8).ElementType.GenericParameters.Add(new GenericParameter("T", (IGenericParameterProvider)(object)((TypeSpecification)val8).ElementType));
					}
					MethodReference val9 = new MethodReference("get_Item", (TypeReference)(object)((TypeSpecification)val8).ElementType.GenericParameters[0], (TypeReference)(object)val8)
					{
						HasThis = true
					};
					val9.Parameters.Add(new ParameterDefinition(mod.TypeSystem.Int32));
					TypeReference val10 = new TypeReference("System.Collections.Generic", "IReadOnlyCollection`1", mod, ((TypeSpecification)val8).ElementType.Scope);
					val10.GenericParameters.Add(new GenericParameter("T", (IGenericParameterProvider)(object)val10));
					GenericInstanceType val11 = new GenericInstanceType(val10);
					val11.GenericArguments.Add(mod.ImportReference((TypeReference)(object)type2));
					MethodReference val12 = new MethodReference("get_Count", mod.TypeSystem.Int32, (TypeReference)(object)val11)
					{
						HasThis = true
					};
					MethodReference val13 = new MethodReference("get_PrefabName", mod.TypeSystem.String, mod.ImportReference((TypeReference)(object)val3))
					{
						HasThis = true
					};
					VariableDefinition val14 = new VariableDefinition((TypeReference)(object)val8);
					VariableDefinition val15 = new VariableDefinition(mod.TypeSystem.Int32);
					VariableDefinition val16 = new VariableDefinition(mod.ImportReference((TypeReference)(object)type2));
					val7.Body.Variables.Add(val14);
					val7.Body.Variables.Add(val15);
					val7.Body.Variables.Add(val16);
					ILProcessor iLProcessor = val7.Body.GetILProcessor();
					Instruction val17 = Instruction.Create(OpCodes.Ldloc, val15);
					Instruction val18 = Instruction.Create(OpCodes.Ldloc, val14);
					Instruction val19 = Instruction.Create(OpCodes.Ldloc, val15);
					iLProcessor.Emit(OpCodes.Call, mod.ImportReference((MethodReference)(object)val2));
					iLProcessor.Emit(OpCodes.Stloc, val14);
					iLProcessor.Emit(OpCodes.Ldc_I4_0);
					iLProcessor.Emit(OpCodes.Stloc, val15);
					iLProcessor.Emit(OpCodes.Br, val17);
					iLProcessor.Append(val18);
					iLProcessor.Emit(OpCodes.Ldloc, val15);
					iLProcessor.Emit(OpCodes.Callvirt, val9);
					iLProcessor.Emit(OpCodes.Stloc, val16);
					iLProcessor.Emit(OpCodes.Ldloc, val16);
					iLProcessor.Emit(OpCodes.Brfalse, val19);
					iLProcessor.Emit(OpCodes.Ldloc, val16);
					iLProcessor.Emit(OpCodes.Callvirt, val13);
					iLProcessor.Emit(OpCodes.Ldarg_0);
					iLProcessor.Emit(OpCodes.Callvirt, mod.ImportReference(val4));
					iLProcessor.Emit(OpCodes.Call, mod.ImportReference((MethodBase)typeof(string).GetMethod("op_Equality", new Type[2]
					{
						typeof(string),
						typeof(string)
					})));
					iLProcessor.Emit(OpCodes.Brfalse, val19);
					iLProcessor.Emit(OpCodes.Ldloc, val16);
					iLProcessor.Emit(OpCodes.Ldarg_1);
					iLProcessor.Emit(OpCodes.Ldarg_2);
					iLProcessor.Emit(OpCodes.Call, mod.ImportReference((MethodReference)(object)val));
					iLProcessor.Emit(OpCodes.Ret);
					iLProcessor.Append(val19);
					iLProcessor.Emit(OpCodes.Ldc_I4_1);
					iLProcessor.Emit(OpCodes.Add);
					iLProcessor.Emit(OpCodes.Stloc, val15);
					iLProcessor.Append(val17);
					iLProcessor.Emit(OpCodes.Ldloc, val14);
					iLProcessor.Emit(OpCodes.Callvirt, val12);
					iLProcessor.Emit(OpCodes.Blt, val18);
					iLProcessor.Emit(OpCodes.Ldnull);
					iLProcessor.Emit(OpCodes.Ret);
					foreach (Instruction item in list)
					{
						item.Operand = val7;
					}
					return list.Count;
				}
			}
			return 0;
		}

		internal static int Restore(ModuleDefinition mod)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00a8: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//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)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			TypeDefinition helper = mod.GetType("ModlistPatchpackCompat.REPOPresentsSpawnApi");
			if (helper == null)
			{
				return 0;
			}
			MethodDefinition val = ((IEnumerable<MethodDefinition>)helper.Methods).Single();
			MethodReference val2 = ((IEnumerable<Instruction>)val.Body.Instructions).Select((Instruction i) => i.Operand).OfType<MethodReference>().Single((MethodReference m) => ((MemberReference)m).Name == "SpawnValuable" && ((MemberReference)((MemberReference)m).DeclaringType).FullName == "REPOLib.Modules.Valuables");
			MethodReference val3 = new MethodReference("SpawnValuable", ((MethodReference)val).ReturnType, ((MemberReference)val2).DeclaringType);
			Enumerator<ParameterDefinition> enumerator = ((MethodReference)val).Parameters.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ParameterDefinition current = enumerator.Current;
					val3.Parameters.Add(new ParameterDefinition(((ParameterReference)current).ParameterType));
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			int num = 0;
			foreach (MethodDefinition item in from m in (from t in Types((IEnumerable<TypeDefinition>)mod.Types)
					where t != helper
					select t).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
				where m.HasBody
				select m)
			{
				Enumerator<Instruction> enumerator3 = item.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						Instruction current2 = enumerator3.Current;
						if (current2.OpCode == OpCodes.Call)
						{
							object operand = current2.Operand;
							MethodReference val4 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val4 != null && ((MemberReference)((MemberReference)val4).DeclaringType).FullName == "ModlistPatchpackCompat.REPOPresentsSpawnApi")
							{
								current2.Operand = val3;
								num++;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
				}
			}
			mod.Types.Remove(helper);
			return num;
		}
	}
	internal static class LegacySpeedPatcher
	{
		internal const string HelperName = "ModlistPatchpackCompat.LegacySpeedApi";

		private static readonly Dictionary<string, string> Supported = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["ExtraBattleUpgrades.dll"] = "DarkSpider90.ExtraBattleUpgrades",
			["JNL_Assist.dll"] = "HERO.JNL_Assist",
			["WesleysEnemies.dll"] = "WesleysEnemies",
			["SteampunkItems.dll"] = "SteampunkItems"
		};

		private static readonly ManualLogSource Log = Logger.CreateLogSource("Modlist-patchpack speed API");

		private static IEnumerable<TypeDefinition> Types(IEnumerable<TypeDefinition> types)
		{
			return types.SelectMany((TypeDefinition t) => ((IEnumerable<TypeDefinition>)(object)new TypeDefinition[1] { t }).Concat(Types((IEnumerable<TypeDefinition>)t.NestedTypes)));
		}

		internal static void Prepare()
		{
			if (!Directory.Exists(Paths.PluginPath))
			{
				return;
			}
			foreach (KeyValuePair<string, string> spec in Supported)
			{
				foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, spec.Key, SearchOption.AllDirectories))
				{
					try
					{
						byte[] array = File.ReadAllBytes(item);
						ModuleDefinition val = ModuleDefinition.ReadModule((Stream)new MemoryStream(array));
						try
						{
							if (!Types((IEnumerable<TypeDefinition>)val.Types).Any((TypeDefinition t) => ((IEnumerable<CustomAttribute>)t.CustomAttributes).Any(delegate(CustomAttribute a)
							{
								//IL_002c: 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)
								if (((MemberReference)a.AttributeType).FullName == "BepInEx.BepInPlugin" && a.ConstructorArguments.Count == 3)
								{
									CustomAttributeArgument val3 = a.ConstructorArguments[0];
									return object.Equals(((CustomAttributeArgument)(ref val3)).Value, spec.Value);
								}
								return false;
							})) || ((AssemblyNameReference)val.Assembly.Name).HasPublicKey)
							{
								continue;
							}
							bool flag = ModuleSettings.EnabledFor(spec.Value);
							int num;
							if (flag)
							{
								ModuleDefinition val2 = ModuleDefinition.ReadModule(Path.Combine(Paths.ManagedPath, "Assembly-CSharp.dll"));
								try
								{
									num = Rewrite(val, val2);
								}
								finally
								{
									((IDisposable)val2)?.Dispose();
								}
							}
							else
							{
								num = Restore(val);
							}
							if (num != 0)
							{
								byte[] bytes;
								using (MemoryStream memoryStream = new MemoryStream())
								{
									val.Write((Stream)memoryStream);
									bytes = memoryStream.ToArray();
								}
								string text;
								using (SHA256 sHA = SHA256.Create())
								{
									text = BitConverter.ToString(sHA.ComputeHash(array)).Replace("-", "").ToLowerInvariant();
								}
								string text2 = Path.Combine(Paths.BepInExRootPath, "cache", "Modlist-patchpack", "speed-api", text);
								Directory.CreateDirectory(text2);
								string text3 = Path.Combine(text2, Path.GetFileName(item) + (flag ? ".original" : ".before-disable"));
								if (!File.Exists(text3))
								{
									File.WriteAllBytes(text3, array);
								}
								if (!File.ReadAllBytes(text3).SequenceEqual(array) || !File.ReadAllBytes(item).SequenceEqual(array))
								{
									throw new IOException("Speed API backup/concurrent change check failed");
								}
								string text4 = item + ".modlist-speed.pending";
								File.WriteAllBytes(text4, bytes);
								File.Replace(text4, item, null);
								Log.LogInfo((object)((flag ? "Adapted " : "Restored ") + num + " OverrideSpeed call(s) for " + spec.Value + "; backup: " + text3));
							}
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					catch (Exception ex)
					{
						Log.LogError((object)("Speed API preparation failed for " + spec.Value + ": " + ex));
					}
				}
			}
		}

		internal static int Rewrite(ModuleDefinition mod, ModuleDefinition game)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			TypeDefinition type = game.GetType("PlayerController");
			if (type == null || ((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == "OverrideSpeed" && ((MethodReference)m).Parameters.Count == 2))
			{
				return 0;
			}
			MethodDefinition val = ((IEnumerable<MethodDefinition>)type.Methods).SingleOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "OverrideSpeed" && ((MethodReference)m).HasThis && (int)((MethodReference)m).ReturnType.MetadataType == 1 && ((MethodReference)m).Parameters.Count == 3 && ((IEnumerable<ParameterDefinition>)((MethodReference)m).Parameters).All((ParameterDefinition p) => (int)((ParameterReference)p).ParameterType.MetadataType == 12) && ((MethodReference)m).Parameters[2].IsOptional && ((MethodReference)m).Parameters[2].HasConstant && object.Equals(((MethodReference)m).Parameters[2].Constant, -1f)));
			if (val == null)
			{
				return 0;
			}
			List<Instruction> list = (from m in Types((IEnumerable<TypeDefinition>)mod.Types).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
				where m.HasBody
				select m).SelectMany((MethodDefinition m) => (IEnumerable<Instruction>)m.Body.Instructions).Where(delegate(Instruction i)
			{
				//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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Invalid comparison between Unknown and I4
				if (i.OpCode == OpCodes.Callvirt)
				{
					object operand = i.Operand;
					MethodReference val4 = (MethodReference)((operand is MethodReference) ? operand : null);
					if (val4 != null && val4.HasThis && ((MemberReference)((MemberReference)val4).DeclaringType).FullName == "PlayerController")
					{
						IMetadataScope scope = ((MemberReference)val4).DeclaringType.Scope;
						if (((scope != null) ? scope.Name : null) == "Assembly-CSharp" && ((MemberReference)val4).Name == "OverrideSpeed" && (int)val4.ReturnType.MetadataType == 1 && val4.Parameters.Count == 2)
						{
							return ((IEnumerable<ParameterDefinition>)val4.Parameters).All((ParameterDefinition p) => (int)((ParameterReference)p).ParameterType.MetadataType == 12);
						}
					}
				}
				return false;
			}).ToList();
			if (list.Count == 0)
			{
				return 0;
			}
			if (mod.GetType("ModlistPatchpackCompat.LegacySpeedApi") != null)
			{
				throw new InvalidOperationException("Unexpected speed helper collision");
			}
			TypeDefinition val2 = new TypeDefinition("ModlistPatchpackCompat", "LegacySpeedApi", (TypeAttributes)384, mod.TypeSystem.Object);
			mod.Types.Add(val2);
			MethodDefinition val3 = new MethodDefinition("OverrideSpeed", (MethodAttributes)147, mod.TypeSystem.Void);
			((MethodReference)val3).Parameters.Add(new ParameterDefinition("controller", (ParameterAttributes)0, mod.ImportReference((TypeReference)(object)type)));
			((MethodReference)val3).Parameters.Add(new ParameterDefinition("speed", (ParameterAttributes)0, mod.TypeSystem.Single));
			((MethodReference)val3).Parameters.Add(new ParameterDefinition("time", (ParameterAttributes)0, mod.TypeSystem.Single));
			val2.Methods.Add(val3);
			ILProcessor iLProcessor = val3.Body.GetILProcessor();
			iLProcessor.Emit(OpCodes.Ldarg_0);
			iLProcessor.Emit(OpCodes.Ldarg_1);
			iLProcessor.Emit(OpCodes.Ldarg_2);
			iLProcessor.Emit(OpCodes.Ldc_R4, -1f);
			iLProcessor.Emit(OpCodes.Callvirt, mod.ImportReference((MethodReference)(object)val));
			iLProcessor.Emit(OpCodes.Ret);
			foreach (Instruction item in list)
			{
				item.OpCode = OpCodes.Call;
				item.Operand = val3;
			}
			return list.Count;
		}

		internal static int Restore(ModuleDefinition mod)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			TypeDefinition helper = mod.GetType("ModlistPatchpackCompat.LegacySpeedApi");
			if (helper == null)
			{
				return 0;
			}
			MethodReference val = (from i in ((IEnumerable<MethodDefinition>)helper.Methods).SelectMany((MethodDefinition m) => (IEnumerable<Instruction>)m.Body.Instructions)
				select i.Operand).OfType<MethodReference>().Single((MethodReference m) => ((MemberReference)m).Name == "OverrideSpeed");
			MethodReference val2 = new MethodReference("OverrideSpeed", mod.TypeSystem.Void, ((MemberReference)val).DeclaringType)
			{
				HasThis = true
			};
			val2.Parameters.Add(new ParameterDefinition(mod.TypeSystem.Single));
			val2.Parameters.Add(new ParameterDefinition(mod.TypeSystem.Single));
			int num = 0;
			foreach (MethodDefinition item in from m in (from t in Types((IEnumerable<TypeDefinition>)mod.Types)
					where t != helper
					select t).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
				where m.HasBody
				select m)
			{
				Enumerator<Instruction> enumerator2 = item.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						Instruction current = enumerator2.Current;
						if (current.OpCode == OpCodes.Call)
						{
							object operand = current.Operand;
							MethodReference val3 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val3 != null && ((MemberReference)((MemberReference)val3).DeclaringType).FullName == "ModlistPatchpackCompat.LegacySpeedApi")
							{
								current.OpCode = OpCodes.Callvirt;
								current.Operand = val2;
								num++;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			mod.Types.Remove(helper);
			return num;
		}
	}
	internal static class ModuleSettings
	{
		private static ConfigFile _file;

		internal static ConfigFile File
		{
			get
			{
				//IL_0019: 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: Expected O, but got Unknown
				object obj = _file;
				if (obj == null)
				{
					ConfigFile val = new ConfigFile(Path.Combine(Paths.ConfigPath, "ValuablesPatchpack.cfg"), true);
					_file = val;
					obj = (object)val;
				}
				return (ConfigFile)obj;
			}
		}

		internal static bool SillyEnabled => File.Bind<bool>("Mods", "SillyValuables", true, "Enable ALL Modlist-patchpack fixes for SillyValuables, including API compatibility, melee networking and ItemLight visual initialization. Requires that mod to be installed. Restart after changing.").Value;

		internal static bool SteampunkEnabled => File.Bind<bool>("Mods", "SteampunkItems", true, "Enable ALL Modlist-patchpack fixes for SteampunkItems. Requires that mod to be installed. Restart after changing.").Value;

		internal static bool MinecraftEnabled => File.Bind<bool>("Mods", "MinecraftStrongholdLevel", true, "Enable ALL Modlist-patchpack fixes for MinecraftStrongholdLevel, including Diamond Sword, source-attributed SDK prefabs and the minecart's missing optional value display. Requires that mod to be installed. Restart after changing.").Value;

		internal static bool KeybindEnabled => File.Bind<bool>("Mods", "KeybindLib", true, "Enable ALL Modlist-patchpack fixes for KeybindLib's obsolete inputToggle injection on current R.E.P.O., plus startup-only input-load diagnostics. Requires that mod to be installed. Restart after changing.").Value;

		internal static bool MoreUpgradesEnabled => File.Bind<bool>("Mods", "MoreUpgrades", true, "Enable ALL Modlist-patchpack fixes for MoreUpgrades: legacy input API, current shop selection/pricing and verified duplicate-manager retirement. Requires that mod to be installed. Disabling restores original input/shop code during preload; restart after changing.").Value;

		internal static bool PresentsEnabled => File.Bind<bool>("Mods", "REPOPresents", true, "Enable ALL Modlist-patchpack fixes for REPOPresents: registration/spawning APIs and lazy current PrefabRef valuable pools. Disabling restores original calls and pool body during preload; restart after changing.").Value;

		internal static bool RepoWarningsEnabled => File.Bind<bool>("Mods", "REPOLib", true, "Enable the pack's REPOLib-specific registration logging compatibility: duplicate valuable-name collisions become warnings with the existing skip behavior explained. Missing references and other errors remain errors. Other source mods retain their own master switches. Restart after changing.").Value;

		internal static bool ExtraBattleEnabled => File.Bind<bool>("Mods", "DarkSpider90.ExtraBattleUpgrades", true, "Enable ALL pack fixes for Extra Battle Upgrades, including the legacy OverrideSpeed call in Panic Response. Retains its existing source-plugin master key. Restart after changing.").Value;

		internal static bool JnlEnabled => File.Bind<bool>("Mods", "HERO.JNL_Assist", true, "Enable ALL pack fixes for JNL_Assist, including its legacy OverrideSpeed call. Retains its existing source-plugin master key. Restart after changing.").Value;

		internal static bool WesleysEnemiesEnabled => File.Bind<bool>("Mods", "WesleysEnemies", true, "Enable ALL pack fixes for Wesley's Enemies, including Voodoo's legacy OverrideSpeed call. Restart after changing.").Value;

		internal static bool ValorantEnabled => File.Bind<bool>("Mods", "ValorantWeapons", true, "Enable ALL pack fixes for Neofeng's asset-only Valorant Weapons package, detected from its SDK bundle path and manifest. Excludes unsupported Standard-shader targets from ItemLight glow animation without changing models/materials. Restart after changing.").Value;

		internal static bool DandyEnabled => File.Bind<bool>("Mods", "DandysWorldItems", true, "Enable ALL pack fixes for SushiWolf's asset-only Dandy's World Items, detected from its actual SDK bundle path and manifest. Repairs the missing radioactive loop audio source at initialization without changing radiation/gameplay logic. Restart after changing.").Value;

		internal static bool MelanieEnabled => File.Bind<bool>("Mods", "MelanieLevels", true, "Enable ALL pack fixes for MelanieMelicious's asset-only level package. Skip only verified Mel Mausoleum registration with no entrance-room references, preventing selection of an unloadable map. Does not rebuild the map. Updated content with a valid entrance remains enabled. Restart after changing.").Value;

		internal static bool ShopSpawnEnabled => File.Bind<bool>("Mods", "AllShopItemsInLevel", true, "Enable ALL pack fixes for ALL Shop Items spawn in Level (REPO_All_Shop_Items_in_Level). Use each item's registered prefab path for multiplayer spawning instead of guessing Items/<name>. Restart after changing.").Value;

		internal static bool EnabledFor(string guid)
		{
			return guid switch
			{
				"Sangrento.SillyValuables" => SillyEnabled, 
				"SteampunkItems" => SteampunkEnabled, 
				"MinecraftStrongholdLevel" => MinecraftEnabled, 
				"bulletbot.keybindlib" => KeybindEnabled, 
				"bulletbot.moreupgrades" => MoreUpgradesEnabled, 
				"REPOPresents" => PresentsEnabled, 
				"REPOLib" => RepoWarningsEnabled, 
				"DarkSpider90.ExtraBattleUpgrades" => ExtraBattleEnabled, 
				"HERO.JNL_Assist" => JnlEnabled, 
				"WesleysEnemies" => WesleysEnemiesEnabled, 
				"asset:Neofeng:valorant_weapons_mod" => ValorantEnabled, 
				"asset:SushiWolf:Dandys_World_Items" => DandyEnabled, 
				"asset:MelanieMelicious:Melanie_REPO_Levels_MelanieMelicious" => MelanieEnabled, 
				"REPO_All_Shop_Items_in_Level" => ShopSpawnEnabled, 
				_ => File.Bind<bool>("Mods", Safe(guid), true, "Enable ALL automatic prefab compatibility fixes for detected plugin " + guid + ". Repairs obsolete ItemMelee observations, invalid ItemLight setup and missing optional cart displays only on source-attributed prefabs. Restart after changing.").Value, 
			};
		}

		private static string Safe(string guid)
		{
			return (guid ?? "").Replace('[', '_').Replace(']', '_').Replace('=', '_')
				.Replace('\\', '_')
				.Replace('/', '_');
		}
	}
}