using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using HarmonyLib.Internal.Patching;
using HarmonyLib.Internal.RuntimeFixes;
using HarmonyLib.Internal.Util;
using HarmonyLib.Public.Patching;
using HarmonyLib.Tools;
using JetBrains.Annotations;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using MonoMod.Utils.Cil;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: ComVisible(false)]
[assembly: InternalsVisibleTo("HarmonyTests")]
[assembly: InternalsVisibleTo("MonoMod.Utils.Cil.ILGeneratorProxy")]
[assembly: Guid("69aee16a-b6e7-4642-8081-3928b32455df")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BepInEx")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © BepInEx 2022")]
[assembly: AssemblyDescription("A library for patching, replacing and decorating .NET and Mono methods during runtime powered by MonoMod.")]
[assembly: AssemblyFileVersion("2.10.1.0")]
[assembly: AssemblyInformationalVersion("2.10.1")]
[assembly: AssemblyProduct("HarmonyX")]
[assembly: AssemblyTitle("0Harmony")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.10.1.0")]
[module: UnverifiableCode]
namespace JetBrains.Annotations
{
	[AttributeUsage(AttributeTargets.All)]
	internal sealed class UsedImplicitlyAttribute : Attribute
	{
		public ImplicitUseKindFlags UseKindFlags { get; }

		public ImplicitUseTargetFlags TargetFlags { get; }

		public UsedImplicitlyAttribute()
			: this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default)
		{
		}

		public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
			: this(useKindFlags, ImplicitUseTargetFlags.Default)
		{
		}

		public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
			: this(ImplicitUseKindFlags.Default, targetFlags)
		{
		}

		public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
		{
			UseKindFlags = useKindFlags;
			TargetFlags = targetFlags;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter | AttributeTargets.GenericParameter)]
	internal sealed class MeansImplicitUseAttribute : Attribute
	{
		[UsedImplicitly]
		public ImplicitUseKindFlags UseKindFlags { get; }

		[UsedImplicitly]
		public ImplicitUseTargetFlags TargetFlags { get; }

		public MeansImplicitUseAttribute()
			: this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default)
		{
		}

		public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
			: this(useKindFlags, ImplicitUseTargetFlags.Default)
		{
		}

		public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
			: this(ImplicitUseKindFlags.Default, targetFlags)
		{
		}

		public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
		{
			UseKindFlags = useKindFlags;
			TargetFlags = targetFlags;
		}
	}
	[Flags]
	internal enum ImplicitUseKindFlags
	{
		Default = 7,
		Access = 1,
		Assign = 2,
		InstantiatedWithFixedConstructorSignature = 4,
		InstantiatedNoFixedConstructorSignature = 8
	}
	[Flags]
	internal enum ImplicitUseTargetFlags
	{
		Default = 1,
		Itself = 1,
		Members = 2,
		WithInheritors = 4,
		WithMembers = 3
	}
}
namespace HarmonyLib
{
	public class DelegateTypeFactory
	{
		private class DelegateEntry
		{
			public CallingConvention? callingConvention;

			public Type delegateType;
		}

		private static int counter;

		private static readonly Dictionary<MethodInfo, List<DelegateEntry>> TypeCache = new Dictionary<MethodInfo, List<DelegateEntry>>();

		private static readonly MethodBase CallingConvAttr = AccessTools.Constructor(typeof(UnmanagedFunctionPointerAttribute), new Type[1] { typeof(CallingConvention) });

		public static readonly DelegateTypeFactory instance = new DelegateTypeFactory();

		public Type CreateDelegateType(Type returnType, Type[] argTypes)
		{
			return CreateDelegateType(returnType, argTypes, null);
		}

		public Type CreateDelegateType(Type returnType, Type[] argTypes, CallingConvention? convention)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			counter++;
			AssemblyDefinition val = AssemblyDefinition.CreateAssembly(new AssemblyNameDefinition($"HarmonyDTFAssembly{counter}", new Version(1, 0)), $"HarmonyDTFModule{counter}", (ModuleKind)0);
			ModuleDefinition module = val.MainModule;
			TypeDefinition val2 = new TypeDefinition("", $"HarmonyDTFType{counter}", (TypeAttributes)257)
			{
				BaseType = module.ImportReference(typeof(MulticastDelegate))
			};
			module.Types.Add(val2);
			if (convention.HasValue)
			{
				CustomAttribute val3 = new CustomAttribute(module.ImportReference(CallingConvAttr));
				val3.ConstructorArguments.Add(new CustomAttributeArgument(module.ImportReference(typeof(CallingConvention)), (object)convention.Value));
				val2.CustomAttributes.Add(val3);
			}
			MethodDefinition val4 = new MethodDefinition(".ctor", (MethodAttributes)4230, module.ImportReference(typeof(void)))
			{
				ImplAttributes = (MethodImplAttributes)3
			};
			Extensions.AddRange<ParameterDefinition>(((MethodReference)val4).Parameters, (IEnumerable<ParameterDefinition>)(object)new ParameterDefinition[2]
			{
				new ParameterDefinition(module.ImportReference(typeof(object))),
				new ParameterDefinition(module.ImportReference(typeof(IntPtr)))
			});
			val2.Methods.Add(val4);
			MethodDefinition val5 = new MethodDefinition("Invoke", (MethodAttributes)198, module.ImportReference(returnType))
			{
				ImplAttributes = (MethodImplAttributes)3
			};
			Extensions.AddRange<ParameterDefinition>(((MethodReference)val5).Parameters, ((IEnumerable<Type>)argTypes).Select((Func<Type, ParameterDefinition>)((Type t) => new ParameterDefinition(module.ImportReference(t)))));
			val2.Methods.Add(val5);
			return ReflectionHelper.Load(val.MainModule).GetType($"HarmonyDTFType{counter}");
		}

		public Type CreateDelegateType(MethodInfo method)
		{
			return CreateDelegateType(method, null);
		}

		public Type CreateDelegateType(MethodInfo method, CallingConvention? convention)
		{
			DelegateEntry delegateEntry;
			if (TypeCache.TryGetValue(method, out var value) && (delegateEntry = value.FirstOrDefault((DelegateEntry e) => e.callingConvention == convention)) != null)
			{
				return delegateEntry.delegateType;
			}
			if (value == null)
			{
				value = (TypeCache[method] = new List<DelegateEntry>());
			}
			delegateEntry = new DelegateEntry
			{
				delegateType = CreateDelegateType(method.ReturnType, method.GetParameters().Types().ToArray(), convention),
				callingConvention = convention
			};
			value.Add(delegateEntry);
			return delegateEntry.delegateType;
		}
	}
	[Obsolete("Use AccessTools.FieldRefAccess<T, S> for fields and AccessTools.MethodDelegate<Func<T, S>> for property getters")]
	public delegate S GetterHandler<in T, out S>(T source);
	[Obsolete("Use AccessTools.FieldRefAccess<T, S> for fields and AccessTools.MethodDelegate<Action<T, S>> for property setters")]
	public delegate void SetterHandler<in T, in S>(T source, S value);
	public delegate T InstantiationHandler<out T>();
	public static class FastAccess
	{
		public static InstantiationHandler<T> CreateInstantiationHandler<T>()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			ConstructorInfo constructor = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null);
			if ((object)constructor == null)
			{
				throw new ApplicationException($"The type {typeof(T)} must declare an empty constructor (the constructor may be private, internal, protected, protected internal, or public).");
			}
			DynamicMethodDefinition val = new DynamicMethodDefinition("InstantiateObject_" + typeof(T).Name, typeof(T), (Type[])null);
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Newobj, constructor);
			iLGenerator.Emit(OpCodes.Ret);
			return (InstantiationHandler<T>)val.Generate().CreateDelegate(typeof(InstantiationHandler<T>));
		}

		[Obsolete("Use AccessTools.MethodDelegate<Func<T, S>>(PropertyInfo.GetGetMethod(true))")]
		public static GetterHandler<T, S> CreateGetterHandler<T, S>(PropertyInfo propertyInfo)
		{
			MethodInfo getMethod = propertyInfo.GetGetMethod(nonPublic: true);
			DynamicMethodDefinition obj = CreateGetDynamicMethod<T, S>(propertyInfo.DeclaringType);
			ILGenerator iLGenerator = obj.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Call, getMethod);
			iLGenerator.Emit(OpCodes.Ret);
			return (GetterHandler<T, S>)obj.Generate().CreateDelegate(typeof(GetterHandler<T, S>));
		}

		[Obsolete("Use AccessTools.FieldRefAccess<T, S>(fieldInfo)")]
		public static GetterHandler<T, S> CreateGetterHandler<T, S>(FieldInfo fieldInfo)
		{
			DynamicMethodDefinition obj = CreateGetDynamicMethod<T, S>(fieldInfo.DeclaringType);
			ILGenerator iLGenerator = obj.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
			iLGenerator.Emit(OpCodes.Ret);
			return (GetterHandler<T, S>)obj.Generate().CreateDelegate(typeof(GetterHandler<T, S>));
		}

		[Obsolete("Use AccessTools.FieldRefAccess<T, S>(name) for fields and AccessTools.MethodDelegate<Func<T, S>>(AccessTools.PropertyGetter(typeof(T), name)) for properties")]
		public static GetterHandler<T, S> CreateFieldGetter<T, S>(params string[] names)
		{
			foreach (string name in names)
			{
				FieldInfo field = typeof(T).GetField(name, AccessTools.all);
				if ((object)field != null)
				{
					return CreateGetterHandler<T, S>(field);
				}
				PropertyInfo property = typeof(T).GetProperty(name, AccessTools.all);
				if ((object)property != null)
				{
					return CreateGetterHandler<T, S>(property);
				}
			}
			return null;
		}

		[Obsolete("Use AccessTools.MethodDelegate<Action<T, S>>(PropertyInfo.GetSetMethod(true))")]
		public static SetterHandler<T, S> CreateSetterHandler<T, S>(PropertyInfo propertyInfo)
		{
			MethodInfo setMethod = propertyInfo.GetSetMethod(nonPublic: true);
			DynamicMethodDefinition obj = CreateSetDynamicMethod<T, S>(propertyInfo.DeclaringType);
			ILGenerator iLGenerator = obj.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldarg_1);
			iLGenerator.Emit(OpCodes.Call, setMethod);
			iLGenerator.Emit(OpCodes.Ret);
			return (SetterHandler<T, S>)obj.Generate().CreateDelegate(typeof(SetterHandler<T, S>));
		}

		[Obsolete("Use AccessTools.FieldRefAccess<T, S>(fieldInfo)")]
		public static SetterHandler<T, S> CreateSetterHandler<T, S>(FieldInfo fieldInfo)
		{
			DynamicMethodDefinition obj = CreateSetDynamicMethod<T, S>(fieldInfo.DeclaringType);
			ILGenerator iLGenerator = obj.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldarg_1);
			iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
			iLGenerator.Emit(OpCodes.Ret);
			return (SetterHandler<T, S>)obj.Generate().CreateDelegate(typeof(SetterHandler<T, S>));
		}

		private static DynamicMethodDefinition CreateGetDynamicMethod<T, S>(Type type)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			return new DynamicMethodDefinition("DynamicGet_" + type.Name, typeof(S), new Type[1] { typeof(T) });
		}

		private static DynamicMethodDefinition CreateSetDynamicMethod<T, S>(Type type)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			return new DynamicMethodDefinition("DynamicSet_" + type.Name, typeof(void), new Type[2]
			{
				typeof(T),
				typeof(S)
			});
		}
	}
	public delegate object FastInvokeHandler(object target, params object[] parameters);
	public static class MethodInvoker
	{
		public static FastInvokeHandler GetHandler(MethodInfo methodInfo, bool directBoxValueAccess = false)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			DynamicMethodDefinition val = new DynamicMethodDefinition("FastInvoke_" + methodInfo.Name + "_" + (directBoxValueAccess ? "direct" : "indirect"), typeof(object), new Type[2]
			{
				typeof(object),
				typeof(object[])
			});
			ILGenerator iLGenerator = val.GetILGenerator();
			if (!methodInfo.IsStatic)
			{
				Emit(iLGenerator, OpCodes.Ldarg_0);
				EmitUnboxIfNeeded(iLGenerator, methodInfo.DeclaringType);
			}
			bool flag = true;
			ParameterInfo[] parameters = methodInfo.GetParameters();
			for (int i = 0; i < parameters.Length; i++)
			{
				Type type = parameters[i].ParameterType;
				bool isByRef = type.IsByRef;
				if (isByRef)
				{
					type = type.GetElementType();
				}
				bool isValueType = type.IsValueType;
				if (isByRef && isValueType && !directBoxValueAccess)
				{
					Emit(iLGenerator, OpCodes.Ldarg_1);
					EmitFastInt(iLGenerator, i);
				}
				Emit(iLGenerator, OpCodes.Ldarg_1);
				EmitFastInt(iLGenerator, i);
				if (isByRef && !isValueType)
				{
					Emit(iLGenerator, OpCodes.Ldelema, typeof(object));
					continue;
				}
				Emit(iLGenerator, OpCodes.Ldelem_Ref);
				if (!isValueType)
				{
					continue;
				}
				if (!isByRef || !directBoxValueAccess)
				{
					Emit(iLGenerator, OpCodes.Unbox_Any, type);
					if (isByRef)
					{
						Emit(iLGenerator, OpCodes.Box, type);
						Emit(iLGenerator, OpCodes.Dup);
						if (flag)
						{
							flag = false;
							iLGenerator.DeclareLocal(typeof(object), pinned: false);
						}
						Emit(iLGenerator, OpCodes.Stloc_0);
						Emit(iLGenerator, OpCodes.Stelem_Ref);
						Emit(iLGenerator, OpCodes.Ldloc_0);
						Emit(iLGenerator, OpCodes.Unbox, type);
					}
				}
				else
				{
					Emit(iLGenerator, OpCodes.Unbox, type);
				}
			}
			if (methodInfo.IsStatic)
			{
				EmitCall(iLGenerator, OpCodes.Call, methodInfo);
			}
			else
			{
				EmitCall(iLGenerator, OpCodes.Callvirt, methodInfo);
			}
			if (methodInfo.ReturnType == typeof(void))
			{
				Emit(iLGenerator, OpCodes.Ldnull);
			}
			else
			{
				EmitBoxIfNeeded(iLGenerator, methodInfo.ReturnType);
			}
			Emit(iLGenerator, OpCodes.Ret);
			return (FastInvokeHandler)val.Generate().CreateDelegate(typeof(FastInvokeHandler));
		}

		internal static void Emit(ILGenerator il, OpCode opcode)
		{
			il.Emit(opcode);
		}

		internal static void Emit(ILGenerator il, OpCode opcode, Type type)
		{
			il.Emit(opcode, type);
		}

		internal static void EmitCall(ILGenerator il, OpCode opcode, MethodInfo methodInfo)
		{
			il.EmitCall(opcode, methodInfo, null);
		}

		private static void EmitUnboxIfNeeded(ILGenerator il, Type type)
		{
			if (type.IsValueType)
			{
				Emit(il, OpCodes.Unbox_Any, type);
			}
		}

		private static void EmitBoxIfNeeded(ILGenerator il, Type type)
		{
			if (type.IsValueType)
			{
				Emit(il, OpCodes.Box, type);
			}
		}

		internal static void EmitFastInt(ILGenerator il, int value)
		{
			switch (value)
			{
			case -1:
				il.Emit(OpCodes.Ldc_I4_M1);
				return;
			case 0:
				il.Emit(OpCodes.Ldc_I4_0);
				return;
			case 1:
				il.Emit(OpCodes.Ldc_I4_1);
				return;
			case 2:
				il.Emit(OpCodes.Ldc_I4_2);
				return;
			case 3:
				il.Emit(OpCodes.Ldc_I4_3);
				return;
			case 4:
				il.Emit(OpCodes.Ldc_I4_4);
				return;
			case 5:
				il.Emit(OpCodes.Ldc_I4_5);
				return;
			case 6:
				il.Emit(OpCodes.Ldc_I4_6);
				return;
			case 7:
				il.Emit(OpCodes.Ldc_I4_7);
				return;
			case 8:
				il.Emit(OpCodes.Ldc_I4_8);
				return;
			}
			if (value > -129 && value < 128)
			{
				il.Emit(OpCodes.Ldc_I4_S, (sbyte)value);
			}
			else
			{
				il.Emit(OpCodes.Ldc_I4, value);
			}
		}
	}
	internal class AccessCache
	{
		internal enum MemberType
		{
			Any,
			Static,
			Instance
		}

		private const BindingFlags BasicFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty;

		private static readonly Dictionary<MemberType, BindingFlags> declaredOnlyBindingFlags = new Dictionary<MemberType, BindingFlags>
		{
			{
				MemberType.Any,
				BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty
			},
			{
				MemberType.Instance,
				BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty
			},
			{
				MemberType.Static,
				BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty
			}
		};

		private readonly Dictionary<Type, Dictionary<string, FieldInfo>> declaredFields = new Dictionary<Type, Dictionary<string, FieldInfo>>();

		private readonly Dictionary<Type, Dictionary<string, PropertyInfo>> declaredProperties = new Dictionary<Type, Dictionary<string, PropertyInfo>>();

		private readonly Dictionary<Type, Dictionary<string, Dictionary<int, MethodBase>>> declaredMethods = new Dictionary<Type, Dictionary<string, Dictionary<int, MethodBase>>>();

		private readonly Dictionary<Type, Dictionary<string, FieldInfo>> inheritedFields = new Dictionary<Type, Dictionary<string, FieldInfo>>();

		private readonly Dictionary<Type, Dictionary<string, PropertyInfo>> inheritedProperties = new Dictionary<Type, Dictionary<string, PropertyInfo>>();

		private readonly Dictionary<Type, Dictionary<string, Dictionary<int, MethodBase>>> inheritedMethods = new Dictionary<Type, Dictionary<string, Dictionary<int, MethodBase>>>();

		private static T Get<T>(Dictionary<Type, Dictionary<string, T>> dict, Type type, string name, Func<T> fetcher)
		{
			lock (dict)
			{
				if (!dict.TryGetValue(type, out var value))
				{
					value = (dict[type] = new Dictionary<string, T>());
				}
				if (!value.TryGetValue(name, out var value2))
				{
					value2 = (value[name] = fetcher());
				}
				return value2;
			}
		}

		private static T Get<T>(Dictionary<Type, Dictionary<string, Dictionary<int, T>>> dict, Type type, string name, Type[] arguments, Func<T> fetcher)
		{
			lock (dict)
			{
				if (!dict.TryGetValue(type, out var value))
				{
					value = (dict[type] = new Dictionary<string, Dictionary<int, T>>());
				}
				if (!value.TryGetValue(name, out var value2))
				{
					value2 = (value[name] = new Dictionary<int, T>());
				}
				int key = AccessTools.CombinedHashCode(arguments);
				if (!value2.TryGetValue(key, out var value3))
				{
					value3 = (value2[key] = fetcher());
				}
				return value3;
			}
		}

		internal FieldInfo GetFieldInfo(Type type, string name, MemberType memberType = MemberType.Any, bool declaredOnly = false)
		{
			FieldInfo fieldInfo = Get(declaredFields, type, name, () => type.GetField(name, declaredOnlyBindingFlags[memberType]));
			if ((object)fieldInfo == null && !declaredOnly)
			{
				fieldInfo = Get(inheritedFields, type, name, () => AccessTools.FindIncludingBaseTypes(type, (Type t) => t.GetField(name, AccessTools.all)));
			}
			return fieldInfo;
		}

		internal PropertyInfo GetPropertyInfo(Type type, string name, MemberType memberType = MemberType.Any, bool declaredOnly = false)
		{
			PropertyInfo propertyInfo = Get(declaredProperties, type, name, () => type.GetProperty(name, declaredOnlyBindingFlags[memberType]));
			if ((object)propertyInfo == null && !declaredOnly)
			{
				propertyInfo = Get(inheritedProperties, type, name, () => AccessTools.FindIncludingBaseTypes(type, (Type t) => t.GetProperty(name, AccessTools.all)));
			}
			return propertyInfo;
		}

		internal MethodBase GetMethodInfo(Type type, string name, Type[] arguments, MemberType memberType = MemberType.Any, bool declaredOnly = false)
		{
			MethodBase methodBase = Get(declaredMethods, type, name, arguments, () => type.GetMethod(name, declaredOnlyBindingFlags[memberType], null, arguments, null));
			if ((object)methodBase == null && !declaredOnly)
			{
				methodBase = Get(inheritedMethods, type, name, arguments, () => AccessTools.Method(type, name, arguments));
			}
			return methodBase;
		}
	}
	internal static class PatchArgumentExtensions
	{
		private static HarmonyArgument[] AllHarmonyArguments(object[] attributes)
		{
			return (from attr in attributes
				select (attr.GetType().Name != "HarmonyArgument") ? null : AccessTools.MakeDeepCopy<HarmonyArgument>(attr) into harg
				where harg != null
				select harg).ToArray();
		}

		private static HarmonyArgument GetArgumentAttribute(this ParameterInfo parameter)
		{
			return AllHarmonyArguments(parameter.GetCustomAttributes(inherit: false)).FirstOrDefault();
		}

		private static HarmonyArgument[] GetArgumentAttributes(this MethodInfo method)
		{
			if ((object)method == null || method is DynamicMethod)
			{
				return null;
			}
			return AllHarmonyArguments(method.GetCustomAttributes(inherit: false));
		}

		private static HarmonyArgument[] GetArgumentAttributes(this Type type)
		{
			return AllHarmonyArguments(type.GetCustomAttributes(inherit: false));
		}

		private static string GetOriginalArgumentName(this ParameterInfo parameter, string[] originalParameterNames)
		{
			HarmonyArgument argumentAttribute = parameter.GetArgumentAttribute();
			if (argumentAttribute == null)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(argumentAttribute.OriginalName))
			{
				return argumentAttribute.OriginalName;
			}
			if (argumentAttribute.Index >= 0 && argumentAttribute.Index < originalParameterNames.Length)
			{
				return originalParameterNames[argumentAttribute.Index];
			}
			return null;
		}

		private static string GetOriginalArgumentName(HarmonyArgument[] attributes, string name, string[] originalParameterNames)
		{
			if (((attributes != null && attributes.Length != 0) ? 1 : 0) <= (false ? 1 : 0))
			{
				return null;
			}
			HarmonyArgument harmonyArgument = attributes.SingleOrDefault((HarmonyArgument p) => p.NewName == name);
			if (harmonyArgument == null)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(harmonyArgument.OriginalName))
			{
				return harmonyArgument.OriginalName;
			}
			if (originalParameterNames != null && harmonyArgument.Index >= 0 && harmonyArgument.Index < originalParameterNames.Length)
			{
				return originalParameterNames[harmonyArgument.Index];
			}
			return null;
		}

		private static string GetOriginalArgumentName(this MethodInfo method, string[] originalParameterNames, string name)
		{
			string originalArgumentName = GetOriginalArgumentName(((object)method != null) ? method.GetArgumentAttributes() : null, name, originalParameterNames);
			if (originalArgumentName != null)
			{
				return originalArgumentName;
			}
			object attributes;
			if ((object)method == null)
			{
				attributes = null;
			}
			else
			{
				Type? declaringType = method.DeclaringType;
				attributes = (((object)declaringType != null) ? declaringType.GetArgumentAttributes() : null);
			}
			originalArgumentName = GetOriginalArgumentName((HarmonyArgument[])attributes, name, originalParameterNames);
			if (originalArgumentName != null)
			{
				return originalArgumentName;
			}
			return name;
		}

		internal static int GetArgumentIndex(this MethodInfo patch, string[] originalParameterNames, ParameterInfo patchParam)
		{
			if (patch is DynamicMethod)
			{
				return Array.IndexOf<string>(originalParameterNames, patchParam.Name);
			}
			string originalArgumentName = patchParam.GetOriginalArgumentName(originalParameterNames);
			if (originalArgumentName != null)
			{
				return Array.IndexOf(originalParameterNames, originalArgumentName);
			}
			originalArgumentName = patch.GetOriginalArgumentName(originalParameterNames, patchParam.Name);
			if (originalArgumentName != null)
			{
				return Array.IndexOf(originalParameterNames, originalArgumentName);
			}
			return -1;
		}
	}
	internal static class PatchFunctions
	{
		internal static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches, bool debug)
		{
			return new PatchSorter(patches, debug).Sort(original);
		}

		internal static Patch[] GetSortedPatchMethodsAsPatches(MethodBase original, Patch[] patches, bool debug)
		{
			return new PatchSorter(patches, debug).SortAsPatches(original);
		}

		internal static MethodInfo UpdateWrapper(MethodBase original, PatchInfo patchInfo)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			MethodPatcher methodPatcher = original.GetMethodPatcher();
			DynamicMethodDefinition val = methodPatcher.PrepareOriginal();
			if (val != null)
			{
				ILContext ctx = new ILContext(val.Definition);
				HarmonyManipulator.Manipulate(original, patchInfo, ctx);
			}
			try
			{
				return methodPatcher.DetourTo((val != null) ? val.Generate() : null) as MethodInfo;
			}
			catch (Exception ex)
			{
				object body;
				if (val == null)
				{
					body = null;
				}
				else
				{
					MethodDefinition definition = val.Definition;
					body = ((definition != null) ? definition.Body : null);
				}
				throw HarmonyException.Create(ex, (MethodBody)body);
			}
		}

		internal static MethodInfo ReversePatch(HarmonyMethod standin, MethodBase original, MethodInfo postTranspiler, MethodInfo postManipulator)
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			if (standin == null)
			{
				throw new ArgumentNullException("standin");
			}
			if ((object)standin.method == null)
			{
				throw new ArgumentNullException("standin", "standin.method is NULL");
			}
			if (!standin.method.IsStatic)
			{
				throw new ArgumentException("standin", "standin.method is not static");
			}
			bool debug = standin.debug.GetValueOrDefault();
			List<MethodInfo> transpilers = new List<MethodInfo>();
			List<MethodInfo> ilmanipulators = new List<MethodInfo>();
			if (standin.reversePatchType == HarmonyReversePatchType.Snapshot)
			{
				Patches patchInfo = Harmony.GetPatchInfo(original);
				transpilers.AddRange(GetSortedPatchMethods(original, patchInfo.Transpilers.ToArray(), debug));
				ilmanipulators.AddRange(GetSortedPatchMethods(original, patchInfo.ILManipulators.ToArray(), debug));
			}
			if ((object)postTranspiler != null)
			{
				transpilers.Add(postTranspiler);
			}
			if ((object)postManipulator != null)
			{
				ilmanipulators.Add(postManipulator);
			}
			Logger.Log(Logger.LogChannel.Info, delegate
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Reverse patching " + standin.method.FullDescription() + " with " + original.FullDescription());
				PrintInfo(stringBuilder, transpilers, "Transpiler");
				PrintInfo(stringBuilder, ilmanipulators, "Manipulators");
				return stringBuilder.ToString();
			}, debug);
			MethodBody patchBody = null;
			ILHook val = new ILHook((MethodBase)standin.method, (Manipulator)delegate(ILContext ctx)
			{
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Expected O, but got Unknown
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				if (original is MethodInfo methodInfo2)
				{
					patchBody = ctx.Body;
					MethodPatcher methodPatcher = methodInfo2.GetMethodPatcher();
					DynamicMethodDefinition val2 = methodPatcher.CopyOriginal();
					if (val2 == null)
					{
						throw new NullReferenceException("Cannot reverse patch " + methodInfo2.FullDescription() + ": method patcher (" + methodPatcher.GetType().FullDescription() + ") can't copy original method body");
					}
					ILManipulator iLManipulator = new ILManipulator(val2.Definition.Body, debug);
					ctx.Body.Variables.Clear();
					Enumerator<VariableDefinition> enumerator2 = iLManipulator.Body.Variables.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							VariableDefinition current2 = enumerator2.Current;
							ctx.Body.Variables.Add(new VariableDefinition(ctx.Module.ImportReference(((VariableReference)current2).VariableType)));
						}
					}
					finally
					{
						((IDisposable)enumerator2).Dispose();
					}
					foreach (MethodInfo item in transpilers)
					{
						iLManipulator.AddTranspiler(item);
					}
					iLManipulator.WriteTo(ctx.Body, standin.method);
					HarmonyManipulator.ApplyManipulators(ctx, original, ilmanipulators, null);
					Instruction val3 = null;
					foreach (Instruction item2 in ((IEnumerable<Instruction>)ctx.Instrs).Where((Instruction i) => i.OpCode == OpCodes.Ret))
					{
						if (val3 == null)
						{
							val3 = ctx.IL.Create(OpCodes.Ret);
						}
						item2.OpCode = OpCodes.Br;
						item2.Operand = val3;
					}
					if (val3 != null)
					{
						ctx.IL.Append(val3);
					}
					Logger.Log(Logger.LogChannel.IL, () => "Generated reverse patcher (" + ((MemberReference)ctx.Method).FullName + "):\n" + ctx.Body.ToILDasmString(), debug);
				}
			}, new ILHookConfig
			{
				ManualApply = true
			});
			try
			{
				val.Apply();
			}
			catch (Exception ex)
			{
				throw HarmonyException.Create(ex, patchBody);
			}
			MethodInfo methodInfo = val.GetCurrentTarget() as MethodInfo;
			PatchTools.RememberObject(standin.method, methodInfo);
			return methodInfo;
			static void PrintInfo(StringBuilder sb, ICollection<MethodInfo> methods, string name)
			{
				if (methods.Count <= 0)
				{
					return;
				}
				sb.AppendLine(name + ":");
				foreach (MethodInfo method in methods)
				{
					sb.AppendLine("  * " + method.FullDescription());
				}
			}
		}

		internal static IEnumerable<CodeInstruction> ApplyTranspilers(MethodBase methodBase, ILGenerator generator, int maxTranspilers = 0)
		{
			MethodPatcher methodPatcher = methodBase.GetMethodPatcher();
			DynamicMethodDefinition val = methodPatcher.CopyOriginal();
			if (val == null)
			{
				throw new NullReferenceException("Cannot reverse patch " + methodBase.FullDescription() + ": method patcher (" + methodPatcher.GetType().FullDescription() + ") can't copy original method body");
			}
			ILManipulator iLManipulator = new ILManipulator(val.Definition.Body, debug: false);
			PatchInfo patchInfo = methodBase.GetPatchInfo();
			if (patchInfo != null)
			{
				List<MethodInfo> sortedPatchMethods = GetSortedPatchMethods(methodBase, patchInfo.transpilers, debug: false);
				for (int i = 0; i < maxTranspilers && i < sortedPatchMethods.Count; i++)
				{
					iLManipulator.AddTranspiler(sortedPatchMethods[i]);
				}
			}
			return iLManipulator.GetInstructions(generator, methodBase);
		}

		internal static void UnpatchConditional(Func<Patch, bool> executionCondition)
		{
			foreach (MethodBase item in PatchProcessor.GetAllPatchedMethods().ToList())
			{
				bool num = item.HasMethodBody();
				Patches patchInfo2 = PatchProcessor.GetPatchInfo(item);
				PatchProcessor patchProcessor = new PatchProcessor(null, item);
				if (num)
				{
					patchInfo2.Postfixes.DoIf(executionCondition, delegate(Patch patchInfo)
					{
						patchProcessor.Unpatch(patchInfo.PatchMethod);
					});
					patchInfo2.Prefixes.DoIf(executionCondition, delegate(Patch patchInfo)
					{
						patchProcessor.Unpatch(patchInfo.PatchMethod);
					});
				}
				patchInfo2.ILManipulators.DoIf(executionCondition, delegate(Patch patchInfo)
				{
					patchProcessor.Unpatch(patchInfo.PatchMethod);
				});
				patchInfo2.Transpilers.DoIf(executionCondition, delegate(Patch patchInfo)
				{
					patchProcessor.Unpatch(patchInfo.PatchMethod);
				});
				if (num)
				{
					patchInfo2.Finalizers.DoIf(executionCondition, delegate(Patch patchInfo)
					{
						patchProcessor.Unpatch(patchInfo.PatchMethod);
					});
				}
			}
		}
	}
	internal class PatchJobs<T>
	{
		internal class Job
		{
			internal MethodBase original;

			internal T replacement;

			internal List<HarmonyMethod> prefixes = new List<HarmonyMethod>();

			internal List<HarmonyMethod> postfixes = new List<HarmonyMethod>();

			internal List<HarmonyMethod> transpilers = new List<HarmonyMethod>();

			internal List<HarmonyMethod> finalizers = new List<HarmonyMethod>();

			internal List<HarmonyMethod> ilmanipulators = new List<HarmonyMethod>();

			internal void AddPatch(AttributePatch patch)
			{
				HarmonyPatchType? type = patch.type;
				if (type.HasValue)
				{
					switch (type.GetValueOrDefault())
					{
					case HarmonyPatchType.Prefix:
						prefixes.Add(patch.info);
						break;
					case HarmonyPatchType.Postfix:
						postfixes.Add(patch.info);
						break;
					case HarmonyPatchType.Transpiler:
						transpilers.Add(patch.info);
						break;
					case HarmonyPatchType.Finalizer:
						finalizers.Add(patch.info);
						break;
					case HarmonyPatchType.ILManipulator:
						ilmanipulators.Add(patch.info);
						break;
					case HarmonyPatchType.ReversePatch:
						break;
					}
				}
			}
		}

		internal Dictionary<MethodBase, Job> state = new Dictionary<MethodBase, Job>();

		internal Job GetJob(MethodBase method)
		{
			if ((object)method == null)
			{
				return null;
			}
			if (!state.TryGetValue(method, out var value))
			{
				value = new Job
				{
					original = method
				};
				state[method] = value;
			}
			return value;
		}

		internal List<Job> GetJobs()
		{
			return state.Values.Where((Job job) => job.prefixes.Count + job.postfixes.Count + job.transpilers.Count + job.finalizers.Count + job.ilmanipulators.Count > 0).ToList();
		}

		internal List<T> GetReplacements()
		{
			return state.Values.Select((Job job) => job.replacement).ToList();
		}
	}
	internal class AttributePatch
	{
		private static readonly HarmonyPatchType[] allPatchTypes = new HarmonyPatchType[6]
		{
			HarmonyPatchType.Prefix,
			HarmonyPatchType.Postfix,
			HarmonyPatchType.Transpiler,
			HarmonyPatchType.Finalizer,
			HarmonyPatchType.ReversePatch,
			HarmonyPatchType.ILManipulator
		};

		internal HarmonyMethod info;

		internal HarmonyPatchType? type;

		private static readonly string harmonyAttributeName = typeof(HarmonyAttribute).FullName;

		internal static IEnumerable<AttributePatch> Create(MethodInfo patch, bool collectIncomplete = false)
		{
			if ((object)patch == null)
			{
				throw new NullReferenceException("Patch method cannot be null");
			}
			object[] customAttributes = patch.GetCustomAttributes(inherit: true);
			string name = patch.Name;
			HarmonyPatchType? type = GetPatchType(name, customAttributes);
			if (!type.HasValue)
			{
				return Enumerable.Empty<AttributePatch>();
			}
			if (type != HarmonyPatchType.ReversePatch && !patch.IsStatic)
			{
				throw new ArgumentException("Patch method " + patch.FullDescription() + " must be static");
			}
			List<HarmonyMethod> list = (from attr in customAttributes
				where attr.GetType().BaseType.FullName == harmonyAttributeName
				select AccessTools.Field(attr.GetType(), "info").GetValue(attr) into harmonyInfo
				select AccessTools.MakeDeepCopy<HarmonyMethod>(harmonyInfo)).ToList();
			List<HarmonyMethod> list2 = new List<HarmonyMethod>();
			ILookup<bool, HarmonyMethod> lookup = list.ToLookup((HarmonyMethod m) => IsComplete(m, collectIncomplete));
			List<HarmonyMethod> incomplete = lookup[false].ToList();
			HarmonyMethod info = HarmonyMethod.Merge(incomplete);
			List<HarmonyMethod> list3 = lookup[true].Where((HarmonyMethod m) => !Same(m, info)).ToList();
			if (list3.Count > 1)
			{
				list2.AddRange(list3.Select((HarmonyMethod m) => HarmonyMethod.Merge(incomplete.AddItem(m))));
			}
			else
			{
				list2.Add(HarmonyMethod.Merge(list));
			}
			foreach (HarmonyMethod item in list2)
			{
				item.method = patch;
			}
			return list2.Select((HarmonyMethod i) => new AttributePatch
			{
				info = i,
				type = type
			}).ToList();
			static bool IsComplete(HarmonyMethod m, bool collectIncomplete)
			{
				if (collectIncomplete || m.GetDeclaringType() != null)
				{
					return m.methodName != null;
				}
				return false;
			}
			static bool Same(HarmonyMethod m1, HarmonyMethod m2)
			{
				if (m1.GetDeclaringType() == m2.GetDeclaringType() && m1.methodName == m2.methodName)
				{
					return m1.GetArgumentList().SequenceEqual(m2.GetArgumentList());
				}
				return false;
			}
		}

		private static HarmonyPatchType? GetPatchType(string methodName, object[] allAttributes)
		{
			HashSet<string> hashSet = new HashSet<string>(from attr in allAttributes
				select attr.GetType().FullName into name
				where name.StartsWith("Harmony")
				select name);
			HarmonyPatchType? result = null;
			HarmonyPatchType[] array = allPatchTypes;
			for (int i = 0; i < array.Length; i++)
			{
				HarmonyPatchType value = array[i];
				string text = value.ToString();
				if (text == methodName || hashSet.Contains("HarmonyLib.Harmony" + text))
				{
					result = value;
					break;
				}
			}
			return result;
		}
	}
	internal class PatchSorter
	{
		private class PatchSortingWrapper : IComparable
		{
			internal readonly HashSet<PatchSortingWrapper> after;

			internal readonly HashSet<PatchSortingWrapper> before;

			internal readonly Patch innerPatch;

			internal PatchSortingWrapper(Patch patch)
			{
				innerPatch = patch;
				before = new HashSet<PatchSortingWrapper>();
				after = new HashSet<PatchSortingWrapper>();
			}

			public int CompareTo(object obj)
			{
				return PatchInfoSerialization.PriorityComparer((obj as PatchSortingWrapper)?.innerPatch, innerPatch.index, innerPatch.priority);
			}

			public override bool Equals(object obj)
			{
				if (obj is PatchSortingWrapper patchSortingWrapper)
				{
					return innerPatch.PatchMethod == patchSortingWrapper.innerPatch.PatchMethod;
				}
				return false;
			}

			public override int GetHashCode()
			{
				return innerPatch.PatchMethod.GetHashCode();
			}

			internal void AddBeforeDependency(IEnumerable<PatchSortingWrapper> dependencies)
			{
				foreach (PatchSortingWrapper dependency in dependencies)
				{
					before.Add(dependency);
					dependency.after.Add(this);
				}
			}

			internal void AddAfterDependency(IEnumerable<PatchSortingWrapper> dependencies)
			{
				foreach (PatchSortingWrapper dependency in dependencies)
				{
					after.Add(dependency);
					dependency.before.Add(this);
				}
			}

			internal void RemoveAfterDependency(PatchSortingWrapper afterNode)
			{
				after.Remove(afterNode);
				afterNode.before.Remove(this);
			}

			internal void RemoveBeforeDependency(PatchSortingWrapper beforeNode)
			{
				before.Remove(beforeNode);
				beforeNode.after.Remove(this);
			}
		}

		internal class PatchDetailedComparer : IEqualityComparer<Patch>
		{
			public bool Equals(Patch x, Patch y)
			{
				if (y != null && x != null && x.owner == y.owner && x.PatchMethod == y.PatchMethod && x.index == y.index && x.priority == y.priority && x.before.Length == y.before.Length && x.after.Length == y.after.Length && x.before.All(((IEnumerable<string>)y.before).Contains<string>))
				{
					return x.after.All(((IEnumerable<string>)y.after).Contains<string>);
				}
				return false;
			}

			public int GetHashCode(Patch obj)
			{
				return obj.GetHashCode();
			}
		}

		private List<PatchSortingWrapper> patches;

		private HashSet<PatchSortingWrapper> handledPatches;

		private List<PatchSortingWrapper> result;

		private List<PatchSortingWrapper> waitingList;

		internal Patch[] sortedPatchArray;

		private readonly bool debug;

		internal PatchSorter(Patch[] patches, bool debug = false)
		{
			this.patches = patches.Select((Patch x) => new PatchSortingWrapper(x)).ToList();
			this.debug = debug;
			foreach (PatchSortingWrapper node in this.patches)
			{
				node.AddBeforeDependency(this.patches.Where((PatchSortingWrapper x) => node.innerPatch.before.Contains(x.innerPatch.owner)));
				node.AddAfterDependency(this.patches.Where((PatchSortingWrapper x) => node.innerPatch.after.Contains(x.innerPatch.owner)));
			}
			this.patches.Sort();
		}

		internal List<MethodInfo> Sort(MethodBase original)
		{
			return (from x in SortAsPatches(original)
				select x.GetMethod(original)).ToList();
		}

		internal Patch[] SortAsPatches(MethodBase original)
		{
			if (sortedPatchArray != null)
			{
				return sortedPatchArray;
			}
			handledPatches = new HashSet<PatchSortingWrapper>();
			waitingList = new List<PatchSortingWrapper>();
			result = new List<PatchSortingWrapper>(patches.Count);
			Queue<PatchSortingWrapper> queue = new Queue<PatchSortingWrapper>(patches);
			while (queue.Count != 0)
			{
				foreach (PatchSortingWrapper item in queue)
				{
					if (item.after.All((PatchSortingWrapper x) => handledPatches.Contains(x)))
					{
						AddNodeToResult(item);
						if (item.before.Count != 0)
						{
							ProcessWaitingList();
						}
					}
					else
					{
						waitingList.Add(item);
					}
				}
				CullDependency();
				queue = new Queue<PatchSortingWrapper>(waitingList);
				waitingList.Clear();
			}
			sortedPatchArray = result.Select((PatchSortingWrapper x) => x.innerPatch).ToArray();
			handledPatches = null;
			waitingList = null;
			patches = null;
			return sortedPatchArray;
		}

		internal bool ComparePatchLists(Patch[] patches)
		{
			if (sortedPatchArray == null)
			{
				Sort(null);
			}
			if (patches != null && sortedPatchArray.Length == patches.Length)
			{
				return sortedPatchArray.All((Patch x) => patches.Contains(x, new PatchDetailedComparer()));
			}
			return false;
		}

		private void CullDependency()
		{
			for (int i = waitingList.Count - 1; i >= 0; i--)
			{
				foreach (PatchSortingWrapper afterNode in waitingList[i].after)
				{
					if (!handledPatches.Contains(afterNode))
					{
						waitingList[i].RemoveAfterDependency(afterNode);
						Logger.Log(Logger.LogChannel.Debug, delegate
						{
							string text = afterNode.innerPatch.PatchMethod.FullDescription();
							string text2 = waitingList[i].innerPatch.PatchMethod.FullDescription();
							return "Breaking dependence between " + text + " and " + text2;
						}, debug);
						return;
					}
				}
			}
		}

		private void ProcessWaitingList()
		{
			int num = waitingList.Count;
			int num2 = 0;
			while (num2 < num)
			{
				PatchSortingWrapper patchSortingWrapper = waitingList[num2];
				if (patchSortingWrapper.after.All(handledPatches.Contains))
				{
					waitingList.Remove(patchSortingWrapper);
					AddNodeToResult(patchSortingWrapper);
					num--;
					num2 = 0;
				}
				else
				{
					num2++;
				}
			}
		}

		private void AddNodeToResult(PatchSortingWrapper node)
		{
			result.Add(node);
			handledPatches.Add(node);
		}
	}
	internal static class PatchTools
	{
		[ThreadStatic]
		private static Dictionary<object, object> objectReferences;

		internal static void RememberObject(object key, object value)
		{
			if (objectReferences == null)
			{
				objectReferences = new Dictionary<object, object>();
			}
			objectReferences[key] = value;
		}

		internal static MethodInfo GetPatchMethod(Type patchType, string attributeName)
		{
			MethodInfo methodInfo = patchType.GetMethods(AccessTools.all).FirstOrDefault((MethodInfo m) => m.GetCustomAttributes(inherit: true).Any((object a) => a.GetType().FullName == attributeName));
			if ((object)methodInfo == null)
			{
				string name = attributeName.Replace("HarmonyLib.Harmony", "");
				methodInfo = patchType.GetMethod(name, AccessTools.all);
			}
			return methodInfo;
		}

		internal static AssemblyBuilder DefineDynamicAssembly(string name)
		{
			return AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run);
		}

		internal static List<AttributePatch> GetPatchMethods(Type type, bool collectIncomplete = false)
		{
			return (from attributePatch in AccessTools.GetDeclaredMethods(type).SelectMany((MethodInfo m) => AttributePatch.Create(m, collectIncomplete))
				where attributePatch != null
				select attributePatch).ToList();
		}

		internal static MethodBase GetOriginalMethod(this HarmonyMethod attr)
		{
			try
			{
				MethodType? methodType = attr.methodType;
				if (methodType.HasValue)
				{
					switch (methodType.GetValueOrDefault())
					{
					case MethodType.Normal:
						if (attr.methodName == null)
						{
							return null;
						}
						return AccessTools.DeclaredMethod(attr.GetDeclaringType(), attr.methodName, attr.argumentTypes);
					case MethodType.Getter:
						if (attr.methodName == null)
						{
							return null;
						}
						return AccessTools.DeclaredProperty(attr.GetDeclaringType(), attr.methodName).GetGetMethod(nonPublic: true);
					case MethodType.Setter:
						if (attr.methodName == null)
						{
							return null;
						}
						return AccessTools.DeclaredProperty(attr.GetDeclaringType(), attr.methodName).GetSetMethod(nonPublic: true);
					case MethodType.Constructor:
						return AccessTools.DeclaredConstructor(attr.GetDeclaringType(), attr.argumentTypes);
					case MethodType.StaticConstructor:
						return AccessTools.GetDeclaredConstructors(attr.GetDeclaringType()).FirstOrDefault((ConstructorInfo c) => c.IsStatic);
					case MethodType.Enumerator:
						if (attr.methodName == null)
						{
							return null;
						}
						return AccessTools.EnumeratorMoveNext(AccessTools.DeclaredMethod(attr.GetDeclaringType(), attr.methodName, attr.argumentTypes));
					}
				}
			}
			catch (AmbiguousMatchException ex)
			{
				throw new HarmonyException("Ambiguous match for HarmonyMethod[" + attr.Description() + "]", ex.InnerException ?? ex);
			}
			return null;
		}
	}
	public enum MethodType
	{
		Normal,
		Getter,
		Setter,
		Constructor,
		StaticConstructor,
		Enumerator
	}
	public enum ArgumentType
	{
		Normal,
		Ref,
		Out,
		Pointer
	}
	public enum HarmonyPatchType
	{
		All,
		Prefix,
		Postfix,
		Transpiler,
		Finalizer,
		ReversePatch,
		ILManipulator
	}
	public enum HarmonyReversePatchType
	{
		Original,
		Snapshot
	}
	public enum MethodDispatchType
	{
		VirtualCall,
		Call
	}
	[MeansImplicitUse]
	public class HarmonyAttribute : Attribute
	{
		public HarmonyMethod info = new HarmonyMethod();
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Delegate, AllowMultiple = true)]
	public class HarmonyPatch : HarmonyAttribute
	{
		public HarmonyPatch()
		{
		}

		public HarmonyPatch(Type declaringType)
		{
			info.declaringType = declaringType;
		}

		public HarmonyPatch(Type declaringType, Type[] argumentTypes)
		{
			info.declaringType = declaringType;
			info.argumentTypes = argumentTypes;
		}

		public HarmonyPatch(Type declaringType, string methodName)
		{
			info.declaringType = declaringType;
			info.methodName = methodName;
		}

		public HarmonyPatch(Type declaringType, string methodName, params Type[] argumentTypes)
		{
			info.declaringType = declaringType;
			info.methodName = methodName;
			info.argumentTypes = argumentTypes;
		}

		public HarmonyPatch(Type declaringType, string methodName, Type[] argumentTypes, ArgumentType[] argumentVariations)
		{
			info.declaringType = declaringType;
			info.methodName = methodName;
			ParseSpecialArguments(argumentTypes, argumentVariations);
		}

		public HarmonyPatch(string typeName, string methodName)
		{
			info.declaringType = AccessTools.TypeByName(typeName);
			info.methodName = methodName;
		}

		public HarmonyPatch(string typeName, string methodName, MethodType methodType, Type[] argumentTypes = null, ArgumentType[] argumentVariations = null)
		{
			info.declaringType = AccessTools.TypeByName(typeName);
			info.methodName = methodName;
			info.methodType = methodType;
			if (argumentTypes != null)
			{
				ParseSpecialArguments(argumentTypes, argumentVariations);
			}
		}

		public HarmonyPatch(Type declaringType, MethodType methodType)
		{
			info.declaringType = declaringType;
			info.methodType = methodType;
		}

		public HarmonyPatch(Type declaringType, MethodType methodType, params Type[] argumentTypes)
		{
			info.declaringType = declaringType;
			info.methodType = methodType;
			info.argumentTypes = argumentTypes;
		}

		public HarmonyPatch(Type declaringType, MethodType methodType, Type[] argumentTypes, ArgumentType[] argumentVariations)
		{
			info.declaringType = declaringType;
			info.methodType = methodType;
			ParseSpecialArguments(argumentTypes, argumentVariations);
		}

		public HarmonyPatch(Type declaringType, string methodName, MethodType methodType)
		{
			info.declaringType = declaringType;
			info.methodName = methodName;
			info.methodType = methodType;
		}

		public HarmonyPatch(string methodName)
		{
			info.methodName = methodName;
		}

		public HarmonyPatch(string methodName, params Type[] argumentTypes)
		{
			info.methodName = methodName;
			info.argumentTypes = argumentTypes;
		}

		public HarmonyPatch(string methodName, Type[] argumentTypes, ArgumentType[] argumentVariations)
		{
			info.methodName = methodName;
			ParseSpecialArguments(argumentTypes, argumentVariations);
		}

		public HarmonyPatch(string methodName, MethodType methodType)
		{
			info.methodName = methodName;
			info.methodType = methodType;
		}

		public HarmonyPatch(MethodType methodType)
		{
			info.methodType = methodType;
		}

		public HarmonyPatch(MethodType methodType, params Type[] argumentTypes)
		{
			info.methodType = methodType;
			info.argumentTypes = argumentTypes;
		}

		public HarmonyPatch(MethodType methodType, Type[] argumentTypes, ArgumentType[] argumentVariations)
		{
			info.methodType = methodType;
			ParseSpecialArguments(argumentTypes, argumentVariations);
		}

		public HarmonyPatch(Type[] argumentTypes)
		{
			info.argumentTypes = argumentTypes;
		}

		public HarmonyPatch(Type[] argumentTypes, ArgumentType[] argumentVariations)
		{
			ParseSpecialArguments(argumentTypes, argumentVariations);
		}

		public HarmonyPatch(string typeName, string methodName, MethodType methodType = MethodType.Normal)
		{
			info.declaringType = AccessTools.TypeByName(typeName);
			info.methodName = methodName;
			info.methodType = methodType;
		}

		private void ParseSpecialArguments(Type[] argumentTypes, ArgumentType[] argumentVariations)
		{
			if (argumentVariations == null || argumentVariations.Length == 0)
			{
				info.argumentTypes = argumentTypes;
				return;
			}
			if (argumentTypes.Length < argumentVariations.Length)
			{
				throw new ArgumentException("argumentVariations contains more elements than argumentTypes", "argumentVariations");
			}
			List<Type> list = new List<Type>();
			for (int i = 0; i < argumentTypes.Length; i++)
			{
				Type type = argumentTypes[i];
				switch (argumentVariations[i])
				{
				case ArgumentType.Ref:
				case ArgumentType.Out:
					type = type.MakeByRefType();
					break;
				case ArgumentType.Pointer:
					type = type.MakePointerType();
					break;
				}
				list.Add(type);
			}
			info.argumentTypes = list.ToArray();
		}
	}
	[AttributeUsage(AttributeTargets.Delegate, AllowMultiple = true)]
	public class HarmonyDelegate : HarmonyPatch
	{
		public HarmonyDelegate(Type declaringType)
			: base(declaringType)
		{
		}

		public HarmonyDelegate(Type declaringType, Type[] argumentTypes)
			: base(declaringType, argumentTypes)
		{
		}

		public HarmonyDelegate(Type declaringType, string methodName)
			: base(declaringType, methodName)
		{
		}

		public HarmonyDelegate(Type declaringType, string methodName, params Type[] argumentTypes)
			: base(declaringType, methodName, argumentTypes)
		{
		}

		public HarmonyDelegate(Type declaringType, string methodName, Type[] argumentTypes, ArgumentType[] argumentVariations)
			: base(declaringType, methodName, argumentTypes, argumentVariations)
		{
		}

		public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType)
			: base(declaringType, MethodType.Normal)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType, params Type[] argumentTypes)
			: base(declaringType, MethodType.Normal, argumentTypes)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(Type declaringType, MethodDispatchType methodDispatchType, Type[] argumentTypes, ArgumentType[] argumentVariations)
			: base(declaringType, MethodType.Normal, argumentTypes, argumentVariations)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(Type declaringType, string methodName, MethodDispatchType methodDispatchType)
			: base(declaringType, methodName, MethodType.Normal)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(string methodName)
			: base(methodName)
		{
		}

		public HarmonyDelegate(string methodName, params Type[] argumentTypes)
			: base(methodName, argumentTypes)
		{
		}

		public HarmonyDelegate(string methodName, Type[] argumentTypes, ArgumentType[] argumentVariations)
			: base(methodName, argumentTypes, argumentVariations)
		{
		}

		public HarmonyDelegate(string methodName, MethodDispatchType methodDispatchType)
			: base(methodName, MethodType.Normal)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(MethodDispatchType methodDispatchType)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(MethodDispatchType methodDispatchType, params Type[] argumentTypes)
			: base(MethodType.Normal, argumentTypes)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(MethodDispatchType methodDispatchType, Type[] argumentTypes, ArgumentType[] argumentVariations)
			: base(MethodType.Normal, argumentTypes, argumentVariations)
		{
			info.nonVirtualDelegate = methodDispatchType == MethodDispatchType.Call;
		}

		public HarmonyDelegate(Type[] argumentTypes)
			: base(argumentTypes)
		{
		}

		public HarmonyDelegate(Type[] argumentTypes, ArgumentType[] argumentVariations)
			: base(argumentTypes, argumentVariations)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
	public class HarmonyReversePatch : HarmonyAttribute
	{
		public HarmonyReversePatch(HarmonyReversePatchType type = HarmonyReversePatchType.Original)
		{
			info.reversePatchType = type;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class HarmonyPatchAll : HarmonyAttribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
	public class HarmonyPriority : HarmonyAttribute
	{
		public HarmonyPriority(int priority)
		{
			info.priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
	public class HarmonyBefore : HarmonyAttribute
	{
		public HarmonyBefore(params string[] before)
		{
			info.before = before;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
	public class HarmonyAfter : HarmonyAttribute
	{
		public HarmonyAfter(params string[] after)
		{
			info.after = after;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
	public class HarmonyDebug : HarmonyAttribute
	{
		public HarmonyDebug()
		{
			info.debug = true;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
	public class HarmonyEmitIL : HarmonyAttribute
	{
		public HarmonyEmitIL()
		{
			info.debugEmitPath = "./";
		}

		public HarmonyEmitIL(string dir)
		{
			info.debugEmitPath = dir;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
	public class HarmonyWrapSafe : HarmonyAttribute
	{
		public HarmonyWrapSafe()
		{
			info.wrapTryCatch = true;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyPrepare : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyCleanup : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyTargetMethod : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyTargetMethods : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyPrefix : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyPostfix : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyTranspiler : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyILManipulator : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyFinalizer : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Parameter, AllowMultiple = true)]
	public class HarmonyArgument : Attribute
	{
		public string OriginalName { get; private set; }

		public int Index { get; private set; }

		public string NewName { get; private set; }

		public HarmonyArgument(string originalName)
			: this(originalName, null)
		{
		}

		public HarmonyArgument(int index)
			: this(index, null)
		{
		}

		public HarmonyArgument(string originalName, string newName)
		{
			OriginalName = originalName;
			Index = -1;
			NewName = newName;
		}

		public HarmonyArgument(int index, string name)
		{
			OriginalName = null;
			Index = index;
			NewName = name;
		}
	}
	public class CodeInstruction
	{
		public OpCode opcode;

		public object operand;

		public List<Label> labels = new List<Label>();

		public List<ExceptionBlock> blocks = new List<ExceptionBlock>();

		internal CodeInstruction()
		{
		}

		public CodeInstruction(OpCode opcode, object operand = null)
		{
			this.opcode = opcode;
			this.operand = operand;
		}

		public CodeInstruction(CodeInstruction instruction)
		{
			opcode = instruction.opcode;
			operand = instruction.operand;
			labels = instruction.labels.ToList();
			blocks = instruction.blocks.ToList();
		}

		public CodeInstruction Clone()
		{
			return new CodeInstruction(this)
			{
				labels = new List<Label>(),
				blocks = new List<ExceptionBlock>()
			};
		}

		public CodeInstruction Clone(OpCode opcode)
		{
			CodeInstruction codeInstruction = Clone();
			codeInstruction.opcode = opcode;
			return codeInstruction;
		}

		public CodeInstruction Clone(object operand)
		{
			CodeInstruction codeInstruction = Clone();
			codeInstruction.operand = operand;
			return codeInstruction;
		}

		public static CodeInstruction Call(Type type, string name, Type[] parameters = null, Type[] generics = null)
		{
			MethodInfo methodInfo = AccessTools.Method(type, name, parameters, generics);
			if ((object)methodInfo == null)
			{
				throw new ArgumentException($"No method found for type={type}, name={name}, parameters={parameters.Description()}, generics={generics.Description()}");
			}
			return new CodeInstruction(OpCodes.Call, methodInfo);
		}

		public static CodeInstruction Call(string typeColonMethodname, Type[] parameters = null, Type[] generics = null)
		{
			MethodInfo methodInfo = AccessTools.Method(typeColonMethodname, parameters, generics);
			if ((object)methodInfo == null)
			{
				throw new ArgumentException("No method found for " + typeColonMethodname + ", parameters=" + parameters.Description() + ", generics=" + generics.Description());
			}
			return new CodeInstruction(OpCodes.Call, methodInfo);
		}

		public static CodeInstruction Call(Expression<Action> expression)
		{
			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
		}

		public static CodeInstruction Call<T>(Expression<Action<T>> expression)
		{
			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
		}

		public static CodeInstruction Call<T, TResult>(Expression<Func<T, TResult>> expression)
		{
			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
		}

		public static CodeInstruction Call(LambdaExpression expression)
		{
			return new CodeInstruction(OpCodes.Call, SymbolExtensions.GetMethodInfo(expression));
		}

		public static CodeInstruction CallClosure<T>(T closure) where T : Delegate
		{
			return Transpilers.EmitDelegate(closure);
		}

		public static CodeInstruction LoadField(Type type, string name, bool useAddress = false)
		{
			FieldInfo fieldInfo = AccessTools.Field(type, name);
			if ((object)fieldInfo == null)
			{
				throw new ArgumentException($"No field found for {type} and {name}");
			}
			return new CodeInstruction((!useAddress) ? (fieldInfo.IsStatic ? OpCodes.Ldsfld : OpCodes.Ldfld) : (fieldInfo.IsStatic ? OpCodes.Ldsflda : OpCodes.Ldflda), fieldInfo);
		}

		public static CodeInstruction StoreField(Type type, string name)
		{
			FieldInfo fieldInfo = AccessTools.Field(type, name);
			if ((object)fieldInfo == null)
			{
				throw new ArgumentException($"No field found for {type} and {name}");
			}
			return new CodeInstruction(fieldInfo.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld, fieldInfo);
		}

		public override string ToString()
		{
			List<string> list = new List<string>();
			foreach (Label label in labels)
			{
				list.Add($"Label{label.GetHashCode()}");
			}
			foreach (ExceptionBlock block in blocks)
			{
				list.Add("EX_" + block.blockType.ToString().Replace("Block", ""));
			}
			string text = ((list.Count > 0) ? (" [" + string.Join(", ", list.ToArray()) + "]") : "");
			string text2 = FormatArgument(operand);
			if (text2.Length > 0)
			{
				text2 = " " + text2;
			}
			OpCode opCode = opcode;
			return opCode.ToString() + text2 + text;
		}

		internal static string FormatArgument(object argument, string extra = null)
		{
			if (argument == null)
			{
				return "NULL";
			}
			Type type = argument.GetType();
			if (argument is MethodBase member)
			{
				return member.FullDescription() + ((extra != null) ? (" " + extra) : "");
			}
			if (argument is FieldInfo fieldInfo)
			{
				return fieldInfo.FieldType.FullDescription() + " " + fieldInfo.DeclaringType.FullDescription() + "::" + fieldInfo.Name;
			}
			if (type == typeof(Label))
			{
				return $"Label{((Label)argument).GetHashCode()}";
			}
			if (type == typeof(Label[]))
			{
				return "Labels" + string.Join(",", ((Label[])argument).Select((Label l) => l.GetHashCode().ToString()).ToArray());
			}
			if (type == typeof(LocalBuilder))
			{
				return $"{((LocalBuilder)argument).LocalIndex} ({((LocalBuilder)argument).LocalType})";
			}
			if (type == typeof(string))
			{
				return argument.ToString().ToLiteral();
			}
			return argument.ToString().Trim();
		}
	}
	public enum ExceptionBlockType
	{
		BeginExceptionBlock,
		BeginCatchBlock,
		BeginExceptFilterBlock,
		BeginFaultBlock,
		BeginFinallyBlock,
		EndExceptionBlock
	}
	public class ExceptionBlock
	{
		public ExceptionBlockType blockType;

		public Type catchType;

		public ExceptionBlock(ExceptionBlockType blockType, Type catchType = null)
		{
			this.blockType = blockType;
			this.catchType = catchType ?? typeof(object);
		}
	}
	public class InvalidHarmonyPatchArgumentException : Exception
	{
		public MethodBase Original { get; }

		public MethodInfo Patch { get; }

		public override string Message => "(" + Patch.FullDescription() + "): " + base.Message;

		public InvalidHarmonyPatchArgumentException(string message, MethodBase original, MethodInfo patch)
			: base(message)
		{
			Original = original;
			Patch = patch;
		}
	}
	public class MemberNotFoundException : Exception
	{
		public MemberNotFoundException(string message)
			: base(message)
		{
		}
	}
	public class Harmony : IDisposable
	{
		[Obsolete("Use HarmonyFileLog.Enabled instead")]
		public static bool DEBUG;

		public string Id { get; }

		static Harmony()
		{
			StackTraceFixes.Install();
		}

		public Harmony(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				throw new ArgumentException("id cannot be null or empty");
			}
			try
			{
				string environmentVariable = Environment.GetEnvironmentVariable("HARMONY_DEBUG");
				if (environmentVariable != null && environmentVariable.Length > 0)
				{
					environmentVariable = environmentVariable.Trim();
					DEBUG = environmentVariable == "1" || bool.Parse(environmentVariable);
				}
			}
			catch
			{
			}
			if (DEBUG)
			{
				HarmonyFileLog.Enabled = true;
			}
			MethodBase callingMethod = (Logger.IsEnabledFor(Logger.LogChannel.Info) ? AccessTools.GetOutsideCaller() : null);
			Logger.Log(Logger.LogChannel.Info, delegate
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				StringBuilder stringBuilder = new StringBuilder();
				Assembly assembly = typeof(Harmony).Assembly;
				Version version = assembly.GetName().Version;
				string text = assembly.Location;
				string text2 = Environment.Version.ToString();
				string text3 = Environment.OSVersion.Platform.ToString();
				if (string.IsNullOrEmpty(text))
				{
					text = new Uri(assembly.CodeBase).LocalPath;
				}
				int size = IntPtr.Size;
				Platform current = PlatformHelper.Current;
				stringBuilder.AppendLine($"### Harmony id={id}, version={version}, location={text}, env/clr={text2}, platform={text3}, ptrsize:runtime/env={size}/{current}");
				if ((object)callingMethod?.DeclaringType != null)
				{
					Assembly assembly2 = callingMethod.DeclaringType.Assembly;
					text = assembly2.Location;
					if (string.IsNullOrEmpty(text))
					{
						text = new Uri(assembly2.CodeBase).LocalPath;
					}
					stringBuilder.AppendLine("### Started from " + callingMethod.FullDescription() + ", location " + text);
					stringBuilder.Append($"### At {DateTime.Now:yyyy-MM-dd hh.mm.ss}");
				}
				return stringBuilder.ToString();
			});
			Id = id;
		}

		public void PatchAll()
		{
			Assembly assembly = new StackTrace().GetFrame(1).GetMethod().ReflectedType.Assembly;
			PatchAll(assembly);
		}

		public PatchProcessor CreateProcessor(MethodBase original)
		{
			return new PatchProcessor(this, original);
		}

		public PatchClassProcessor CreateClassProcessor(Type type)
		{
			return new PatchClassProcessor(this, type);
		}

		public PatchClassProcessor CreateClassProcessor(Type type, bool allowUnannotatedType)
		{
			return new PatchClassProcessor(this, type, allowUnannotatedType);
		}

		public ReversePatcher CreateReversePatcher(MethodBase original, HarmonyMethod standin)
		{
			return new ReversePatcher(this, original, standin);
		}

		public void PatchAll(Assembly assembly)
		{
			AccessTools.GetTypesFromAssembly(assembly).Do(delegate(Type type)
			{
				CreateClassProcessor(type).Patch();
			});
		}

		public void PatchAll(Type type)
		{
			CreateClassProcessor(type, allowUnannotatedType: true).Patch();
		}

		public MethodInfo Patch(MethodBase original, HarmonyMethod prefix = null, HarmonyMethod postfix = null, HarmonyMethod transpiler = null, HarmonyMethod finalizer = null, HarmonyMethod ilmanipulator = null)
		{
			PatchProcessor patchProcessor = CreateProcessor(original);
			patchProcessor.AddPrefix(prefix);
			patchProcessor.AddPostfix(postfix);
			patchProcessor.AddTranspiler(transpiler);
			patchProcessor.AddFinalizer(finalizer);
			patchProcessor.AddILManipulator(ilmanipulator);
			return patchProcessor.Patch();
		}

		[Obsolete("Use newer Patch() instead", true)]
		public MethodInfo Patch(MethodBase original, HarmonyMethod prefix, HarmonyMethod postfix, HarmonyMethod transpiler, HarmonyMethod finalizer)
		{
			return Patch(original, prefix, postfix, transpiler, finalizer, null);
		}

		public static MethodInfo ReversePatch(MethodBase original, HarmonyMethod standin, MethodInfo transpiler = null, MethodInfo ilmanipulator = null)
		{
			return PatchFunctions.ReversePatch(standin, original, transpiler, ilmanipulator);
		}

		[Obsolete("Use newer ReversePatch() instead", true)]
		public static MethodInfo ReversePatch(MethodBase original, HarmonyMethod standin, MethodInfo transpiler)
		{
			return PatchFunctions.ReversePatch(standin, original, transpiler, null);
		}

		public static void UnpatchID(string harmonyID)
		{
			if (string.IsNullOrEmpty(harmonyID))
			{
				throw new ArgumentNullException("harmonyID", "UnpatchID was called with a null or empty harmonyID.");
			}
			PatchFunctions.UnpatchConditional((Patch patchInfo) => patchInfo.owner == harmonyID);
		}

		void IDisposable.Dispose()
		{
			UnpatchSelf();
		}

		public void UnpatchSelf()
		{
			UnpatchID(Id);
		}

		public static void UnpatchAll()
		{
			Logger.Log(Logger.LogChannel.Warn, () => "UnpatchAll has been called - This will remove ALL HARMONY PATCHES.");
			PatchFunctions.UnpatchConditional((Patch _) => true);
		}

		[Obsolete("Use UnpatchSelf() to unpatch the current instance. The functionality to unpatch either other ids or EVERYTHING has been moved the static methods UnpatchID() and UnpatchAll() respectively", true)]
		public void UnpatchAll(string harmonyID = null)
		{
			if (harmonyID == null)
			{
				if (HarmonyGlobalSettings.DisallowLegacyGlobalUnpatchAll)
				{
					Logger.Log(Logger.LogChannel.Warn, () => "Legacy UnpatchAll has been called AND DisallowLegacyGlobalUnpatchAll=true. Skipping execution of UnpatchAll");
				}
				else
				{
					UnpatchAll();
				}
			}
			else if (harmonyID.Length == 0)
			{
				Logger.Log(Logger.LogChannel.Warn, () => "Legacy UnpatchAll was called with harmonyID=\"\" which is an invalid id. Skipping execution of UnpatchAll");
			}
			else
			{
				UnpatchID(harmonyID);
			}
		}

		public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyID = "*")
		{
			CreateProcessor(original).Unpatch(type, harmonyID);
		}

		public void Unpatch(MethodBase original, MethodInfo patch)
		{
			CreateProcessor(original).Unpatch(patch);
		}

		public static bool HasAnyPatches(string harmonyID)
		{
			return (from original in GetAllPatchedMethods()
				select GetPatchInfo(original)).Any((Patches info) => info.Owners.Contains(harmonyID));
		}

		public static Patches GetPatchInfo(MethodBase method)
		{
			return PatchProcessor.GetPatchInfo(method);
		}

		public IEnumerable<MethodBase> GetPatchedMethods()
		{
			return from original in GetAllPatchedMethods()
				where GetPatchInfo(original).Owners.Contains(Id)
				select original;
		}

		public static IEnumerable<MethodBase> GetAllPatchedMethods()
		{
			return PatchProcessor.GetAllPatchedMethods();
		}

		public static MethodBase GetOriginalMethod(MethodInfo replacement)
		{
			if (replacement == null)
			{
				throw new ArgumentNullException("replacement");
			}
			return PatchManager.GetOriginal(replacement);
		}

		public static MethodBase GetMethodFromStackframe(StackFrame frame)
		{
			if (frame == null)
			{
				throw new ArgumentNullException("frame");
			}
			return PatchManager.FindReplacement(frame) ?? frame.GetMethod();
		}

		public static MethodBase GetOriginalMethodFromStackframe(StackFrame frame)
		{
			MethodBase methodBase = GetMethodFromStackframe(frame);
			if (methodBase is MethodInfo replacement)
			{
				methodBase = GetOriginalMethod(replacement) ?? methodBase;
			}
			return methodBase;
		}

		public static Dictionary<string, Version> VersionInfo(out Version currentVersion)
		{
			return PatchProcessor.VersionInfo(out currentVersion);
		}

		public static Harmony CreateAndPatchAll(Type type, string harmonyInstanceId = null)
		{
			Harmony harmony = new Harmony(harmonyInstanceId ?? $"harmony-auto-{Guid.NewGuid()}");
			harmony.PatchAll(type);
			return harmony;
		}

		public static Harmony CreateAndPatchAll(Assembly assembly, string harmonyInstanceId = null)
		{
			Harmony harmony = new Harmony(harmonyInstanceId ?? $"harmony-auto-{Guid.NewGuid()}");
			harmony.PatchAll(assembly);
			return harmony;
		}
	}
	[Serializable]
	public class HarmonyException : Exception
	{
		private Dictionary<int, CodeInstruction> instructions = new Dictionary<int, CodeInstruction>();

		private int errorOffset = -1;

		internal HarmonyException()
		{
		}

		internal HarmonyException(string message)
			: base(message)
		{
		}

		internal HarmonyException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		protected HarmonyException(SerializationInfo serializationInfo, StreamingContext streamingContext)
		{
			throw new NotImplementedException();
		}

		internal HarmonyException(Exception innerException, Dictionary<int, CodeInstruction> instructions, int errorOffset)
			: base("IL Compile Error", innerException)
		{
			this.instructions = instructions;
			this.errorOffset = errorOffset;
		}

		internal static Exception Create(Exception ex, MethodBody body)
		{
			if (ex is HarmonyException ex2)
			{
				Dictionary<int, CodeInstruction> dictionary = ex2.instructions;
				if (dictionary != null && dictionary.Count > 0 && ex2.errorOffset >= 0)
				{
					return ex;
				}
			}
			Match match = Regex.Match(ex.Message.TrimEnd(Array.Empty<char>()), "(?:Reason: )?Invalid IL code in.+: IL_(\\d{4}): (.+)$");
			if (!match.Success)
			{
				return new HarmonyException("IL Compile Error (unknown location)", ex);
			}
			Dictionary<int, CodeInstruction> dictionary2 = ILManipulator.GetInstructions(body) ?? new Dictionary<int, CodeInstruction>();
			int num = int.Parse(match.Groups[1].Value, NumberStyles.HexNumber);
			Regex.Replace(match.Groups[2].Value, " {2,}", " ");
			if (ex is HarmonyException ex3)
			{
				if (dictionary2.Count != 0)
				{
					ex3.instructions = dictionary2;
					ex3.errorOffset = num;
				}
				return ex3;
			}
			return new HarmonyException(ex, dictionary2, num);
		}

		public List<KeyValuePair<int, CodeInstruction>> GetInstructionsWithOffsets()
		{
			return instructions.OrderBy((KeyValuePair<int, CodeInstruction> ins) => ins.Key).ToList();
		}

		public List<CodeInstruction> GetInstructions()
		{
			return (from ins in instructions
				orderby ins.Key
				select ins.Value).ToList();
		}

		public int GetErrorOffset()
		{
			return errorOffset;
		}

		public int GetErrorIndex()
		{
			if (instructions.TryGetValue(errorOffset, out var value))
			{
				return GetInstructions().IndexOf(value);
			}
			return -1;
		}
	}
	public static class HarmonyGlobalSettings
	{
		public static bool DisallowLegacyGlobalUnpatchAll { get; set; }
	}
	public class HarmonyMethod
	{
		public MethodInfo method;

		public Type declaringType;

		public string methodName;

		public MethodType? methodType;

		public Type[] argumentTypes;

		public int priority = -1;

		public string[] before;

		public string[] after;

		public HarmonyReversePatchType? reversePatchType;

		public bool? debug;

		public string debugEmitPath;

		public bool nonVirtualDelegate;

		public bool? wrapTryCatch;

		public HarmonyMethod()
		{
		}

		private void ImportMethod(MethodInfo theMethod)
		{
			if ((object)theMethod == null)
			{
				throw new ArgumentNullException("theMethod", "Harmony method is null (did you target a wrong or missing method?)");
			}
			if (!theMethod.IsStatic)
			{
				throw new ArgumentException("Harmony method must be static", "theMethod");
			}
			method = theMethod;
			List<HarmonyMethod> fromMethod = HarmonyMethodExtensions.GetFromMethod(method);
			if (fromMethod != null)
			{
				Merge(fromMethod).CopyTo(this);
			}
		}

		public HarmonyMethod(MethodInfo method)
		{
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			ImportMethod(method);
		}

		public HarmonyMethod(MethodInfo method, int priority = -1, string[] before = null, string[] after = null, bool? debug = null)
		{
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			ImportMethod(method);
			this.priority = priority;
			this.before = before;
			this.after = after;
			this.debug = debug;
		}

		public HarmonyMethod(Type methodType, string methodName, Type[] argumentTypes = null)
		{
			MethodInfo methodInfo = AccessTools.Method(methodType, methodName, argumentTypes);
			if ((object)methodInfo == null)
			{
				throw new ArgumentException($"Cannot not find method for type {methodType} and name {methodName} and parameters {argumentTypes?.Description()}");
			}
			ImportMethod(methodInfo);
		}

		public static List<string> HarmonyFields()
		{
			return (from s in AccessTools.GetFieldNames(typeof(HarmonyMethod))
				where s != "method"
				select s).ToList();
		}

		public static HarmonyMethod Merge(List<HarmonyMethod> attributes)
		{
			return Merge((IEnumerable<HarmonyMethod>)attributes);
		}

		internal static HarmonyMethod Merge(IEnumerable<HarmonyMethod> attributes)
		{
			HarmonyMethod harmonyMethod = new HarmonyMethod();
			if (attributes == null)
			{
				return harmonyMethod;
			}
			Traverse resultTrv = Traverse.Create(harmonyMethod);
			attributes.Do(delegate(HarmonyMethod attribute)
			{
				Traverse trv = Traverse.Create(attribute);
				HarmonyFields().ForEach(delegate(string f)
				{
					object value = trv.Field(f).GetValue();
					if (value != null && (f != "priority" || (int)value != -1))
					{
						HarmonyMethodExtensions.SetValue(resultTrv, f, value);
					}
				});
			});
			return harmonyMethod;
		}

		public override string ToString()
		{
			string result = "";
			Traverse trv = Traverse.Create(this);
			HarmonyFields().ForEach(delegate(string f)
			{
				if (result.Length > 0)
				{
					result += ", ";
				}
				result += $"{f}={trv.Field(f).GetValue()}";
			});
			return "HarmonyMethod[" + result + "]";
		}

		internal string Description()
		{
			string text = (((object)declaringType != null) ? declaringType.FullDescription() : "undefined");
			string text2 = methodName ?? "undefined";
			string text3 = (methodType.HasValue ? methodType.Value.ToString() : "undefined");
			string text4 = ((argumentTypes != null) ? argumentTypes.Description() : "undefined");
			return "(class=" + text + ", methodname=" + text2 + ", type=" + text3 + ", args=" + text4 + ")";
		}

		internal Type GetDeclaringType()
		{
			return declaringType;
		}

		internal Type[] GetArgumentList()
		{
			return argumentTypes ?? EmptyType.NoArgs;
		}
	}
	internal static class EmptyType
	{
		internal static readonly Type[] NoArgs = new Type[0];
	}
	public static class HarmonyMethodExtensions
	{
		internal static void SetValue(Traverse trv, string name, object val)
		{
			if (val != null)
			{
				Traverse traverse = trv.Field(name);
				if (name == "methodType" || name == "reversePatchType")
				{
					val = Enum.ToObject(Nullable.GetUnderlyingType(traverse.GetValueType()), (int)val);
				}
				traverse.SetValue(val);
			}
		}

		public static void CopyTo(this HarmonyMethod from, HarmonyMethod to)
		{
			if (to == null)
			{
				return;
			}
			Traverse fromTrv = Traverse.Create(from);
			Traverse toTrv = Traverse.Create(to);
			HarmonyMethod.HarmonyFields().ForEach(delegate(string f)
			{
				object value = fromTrv.Field(f).GetValue();
				if (value != null)
				{
					SetValue(toTrv, f, value);
				}
			});
		}

		public static HarmonyMethod Clone(this HarmonyMethod original)
		{
			HarmonyMethod harmonyMethod = new HarmonyMethod();
			original.CopyTo(harmonyMethod);
			return harmonyMethod;
		}

		public static HarmonyMethod Merge(this HarmonyMethod master, HarmonyMethod detail)
		{
			if (detail == null)
			{
				return master;
			}
			HarmonyMethod harmonyMethod = new HarmonyMethod();
			Traverse resultTrv = Traverse.Create(harmonyMethod);
			Traverse masterTrv = Traverse.Create(master);
			Traverse detailTrv = Traverse.Create(detail);
			HarmonyMethod.HarmonyFields().ForEach(delegate(string f)
			{
				object value = masterTrv.Field(f).GetValue();
				object value2 = detailTrv.Field(f).GetValue();
				if (f != "priority" || (int)value2 != -1)
				{
					SetValue(resultTrv, f, value2 ?? value);
				}
			});
			return harmonyMethod;
		}

		private static HarmonyMethod GetHarmonyMethodInfo(object attribute)
		{
			FieldInfo field = attribute.GetType().GetField("info", AccessTools.all);
			if ((object)field == null)
			{
				return null;
			}
			if (field.FieldType.FullName != typeof(HarmonyMethod).FullName)
			{
				return null;
			}
			return AccessTools.MakeDeepCopy<HarmonyMethod>(field.GetValue(attribute));
		}

		public static List<HarmonyMethod> GetFromType(Type type)
		{
			return (from attr in type.GetCustomAttributes(inherit: true)
				select GetHarmonyMethodInfo(attr) into info
				where info != null
				select info).ToList();
		}

		public static HarmonyMethod GetMergedFromType(Type type)
		{
			return HarmonyMethod.Merge(GetFromType(type));
		}

		public static List<HarmonyMethod> GetFromMethod(MethodBase method)
		{
			return (from attr in method.GetCustomAttributes(inherit: true)
				select GetHarmonyMethodInfo(attr) into info
				where info != null
				select info).ToList();
		}

		public static HarmonyMethod GetMergedFromMethod(MethodBase method)
		{
			return HarmonyMethod.Merge(GetFromMethod(method));
		}
	}
	public class InlineSignature : ICallSiteGenerator
	{
		public class ModifierType
		{
			public bool IsOptional;

			public Type Modifier;

			public object Type;

			public override string ToString()
			{
				return ((Type is Type type) ? type.FullDescription() : Type?.ToString()) + " mod" + (IsOptional ? "opt" : "req") + "(" + Modifier?.FullDescription() + ")";
			}

			internal TypeReference ToTypeReference(ModuleDefinition module)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Expected O, but got Unknown
				if (!IsOptional)
				{
					return (TypeReference)new RequiredModifierType(module.ImportReference(Modifier), GetTypeReference(module, Type));
				}
				return (TypeReference)new OptionalModifierType(module.ImportReference(Modifier), GetTypeReference(module, Type));
			}
		}

		public bool HasThis { get; set; }

		public bool ExplicitThis { get; set; }

		public CallingConvention CallingConvention { get; set; } = CallingConvention.Winapi;


		public List<object> Parameters { get; set; } = new List<object>();


		public object ReturnType { get; set; } = typeof(void);


		public override string ToString()
		{
			return ((ReturnType is Type type) ? type.FullDescription() : ReturnType?.ToString()) + " (" + Parameters.Join((object p) => (!(p is Type type2)) ? p?.ToString() : type2.FullDescription()) + ")";
		}

		internal static TypeReference GetTypeReference(ModuleDefinition module, object param)
		{
			if (!(param is Type type))
			{
				if (!(param is InlineSignature inlineSignature))
				{
					if (param is ModifierType modifierType)
					{
						return modifierType.ToTypeReference(module);
					}
					throw new NotSupportedException($"Unsupported inline signature parameter type: {param} ({param?.GetType().FullDescription()})");
				}
				return (TypeReference)(object)inlineSignature.ToFunctionPointer(module);
			}
			return module.ImportReference(type);
		}

		CallSite ICallSiteGenerator.ToCallSite(ModuleDefinition module)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			CallSite val = new CallSite(GetTypeReference(module, ReturnType))
			{
				HasThis = HasThis,
				ExplicitThis = ExplicitThis,
				CallingConvention = (MethodCallingConvention)(byte)((byte)CallingConvention - 1)
			};
			foreach (object parameter in Parameters)
			{
				val.Parameters.Add(new ParameterDefinition(GetTypeReference(module, parameter)));
			}
			return val;
		}

		private FunctionPointerType ToFunctionPointer(ModuleDefinition module)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			FunctionPointerType val = new FunctionPointerType
			{
				ReturnType = GetTypeReference(module, ReturnType),
				HasThis = HasThis,
				ExplicitThis = ExplicitThis,
				CallingConvention = (MethodCallingConvention)(byte)((byte)CallingConvention - 1)
			};
			foreach (object parameter in Parameters)
			{
				val.Parameters.Add(new ParameterDefinition(GetTypeReference(module, parameter)));
			}
			return val;
		}
	}
	internal static class PatchInfoSerialization
	{
		private class Binder : SerializationBinder
		{
			public override Type BindToType(string assemblyName, string typeName)
			{
				Type[] array = new Type[3]
				{
					typeof(PatchInfo),
					typeof(Patch[]),
					typeof(Patch)
				};
				foreach (Type type in array)
				{
					if (typeName == type.FullName)
					{
						return type;
					}
				}
				return Type.GetType($"{typeName}, {assemblyName}");
			}
		}

		internal static byte[] Serialize(this PatchInfo patchInfo)
		{
			using MemoryStream memoryStream = new MemoryStream();
			new BinaryFormatter().Serialize(memoryStream, patchInfo);
			return memoryStream.GetBuffer();
		}

		internal static PatchInfo Deserialize(byte[] bytes)
		{
			BinaryFormatter obj = new BinaryFormatter
			{
				Binder = new Binder()
			};
			MemoryStream serializationStream = new MemoryStream(bytes);
			return (PatchInfo)obj.Deserialize(serializationStream);
		}

		internal static int PriorityComparer(object obj, int index, int priority)
		{
			Traverse traverse = Traverse.Create(obj);
			int value = traverse.Field("priority").GetValue<int>();
			int value2 = traverse.Field("index").GetValue<int>();
			if (priority != value)
			{
				return -priority.CompareTo(value);
			}
			return index.CompareTo(value2);
		}
	}
	[Serializable]
	public class PatchInfo
	{
		public Patch[] prefixes = new Patch[0];

		public Patch[] postfixes = new Patch[0];

		public Patch[] transpilers = new Patch[0];

		public Patch[] finalizers = new Patch[0];

		public Patch[] ilmanipulators = new Patch[0];

		public bool Debugging
		{
			get
			{
				if (!prefixes.Any((Patch p) => p.debug) && !postfixes.Any((Patch p) => p.debug) && !transpilers.Any((Patch p) => p.debug) && !finalizers.Any((Patch p) => p.debug))
				{
					return ilmanipulators.Any((Patch p) => p.debug);
				}
				return true;
			}
		}

		public string[] DebugEmitPaths => (from p in prefixes.Concat(postfixes).Concat(transpilers).Concat(finalizers)
				.Concat(ilmanipulators)
			select p.debugEmitPath into p
			where p != null
			select p).ToArray();

		internal void AddPrefixes(string owner, params HarmonyMethod[] methods)
		{
			prefixes = Add(owner, methods, prefixes);
		}

		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
		public void AddPrefix(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
		{
			AddPrefixes(owner, new HarmonyMethod(patch, priority, before, after, debug));
		}

		public void RemovePrefix(string owner)
		{
			prefixes = Remove(owner, prefixes);
		}

		internal void AddPostfixes(string owner, params HarmonyMethod[] methods)
		{
			postfixes = Add(owner, methods, postfixes);
		}

		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
		public void AddPostfix(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
		{
			AddPostfixes(owner, new HarmonyMethod(patch, priority, before, after, debug));
		}

		public void RemovePostfix(string owner)
		{
			postfixes = Remove(owner, postfixes);
		}

		internal void AddTranspilers(string owner, params HarmonyMethod[] methods)
		{
			transpilers = Add(owner, methods, transpilers);
		}

		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
		public void AddTranspiler(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
		{
			AddTranspilers(owner, new HarmonyMethod(patch, priority, before, after, debug));
		}

		public void RemoveTranspiler(string owner)
		{
			transpilers = Remove(owner, transpilers);
		}

		internal void AddFinalizers(string owner, params HarmonyMethod[] methods)
		{
			finalizers = Add(owner, methods, finalizers);
		}

		[Obsolete("This method only exists for backwards compatibility since the class is public.")]
		public void AddFinalizer(MethodInfo patch, string owner, int priority, string[] before, string[] after, bool debug)
		{
			AddFinalizers(owner, new HarmonyMethod(patch, priority, before, after, debug));
		}

		public void RemoveFinalizer(string owner)
		{
			finalizers = Remove(owner, finalizers);
		}

		internal void AddILManipulators(string owner, params HarmonyMethod[] methods)
		{
			ilmanipulators = Add(owner, methods, ilmanipulators);
		}

		public void RemoveILManipulator(string owner)
		{
			ilmanipulators = Remove(owner, ilmanipulators);
		}

		public void RemovePatch(MethodInfo patch)
		{
			prefixes = prefixes.Where((Patch p) => p.PatchMethod != patch).ToArray();
			postfixes = postfixes.Where((Patch p) => p.PatchMethod != patch).ToArray();
			transpilers = transpilers.Where((Patch p) => p.PatchMethod != patch).ToArray();
			finalizers = finalizers.Where((Patch p) => p.PatchMethod != patch).ToArray();
			ilmanipulators = ilmanipulators.Where((Patch p) => p.PatchMethod != patch).ToArray();
		}

		private static Patch[] Add(string owner, HarmonyMethod[] add, Patch[] current)
		{
			if (add.Length == 0)
			{
				return current;
			}
			int initialIndex = current.Length;
			return current.Concat(add.Where((HarmonyMethod method) => method != null).Select((HarmonyMethod method, int i) => new Patch(method, i + initialIndex, owner))).ToArray();
		}

		private static Patch[] Remove(string owner, Patch[] current)
		{
			if (!(owner == "*"))
			{
				return current.Where((Patch patch) => patch.owner != owner).ToArray();
			}
			return new Patch[0];
		}
	}
	[Serializable]
	public class Patch : IComparable
	{
		public readonly int index;

		public readonly string owner;

		public readonly int priority;

		public readonly string[] before;

		public readonly string[] after;

		public readonly bool debug;

		public readonly string debugEmitPath;

		public readonly bool wrapTryCatch;

		[NonSerialized]
		private MethodInfo patchMethod;

		private int methodToken;

		private string moduleGUID;

		public MethodInfo PatchMethod
		{
			get
			{
				if ((object)patchMethod == null)
				{
					Module module = (from a in AppDomain.CurrentDomain.GetAssemblies()
						where !a.FullName.StartsWith("Microsoft.VisualStudio")
						select a).SelectMany((Assembly a) => a.GetLoadedModules()).First((Module m) => m.ModuleVersionId.ToString() == moduleGUID);
					patchMethod = (MethodInfo)module.ResolveMethod(methodToken);
				}
				return patchMethod;
			}
			set
			{
				patchMethod = value;
				methodToken = patchMethod.MetadataToken;
				moduleGUID = patchMethod.Module.ModuleVersionId.ToString();
			}
		}

		public Patch(MethodInfo patch, int index, string owner, int priority, string[] before, string[] after, bool debug)
		{
			if (patch is DynamicMethod)
			{
				throw new Exception("Cannot directly reference dynamic method \"" + patch.FullDescription() + "\" in Harmony. Use a factory method instead that will return the dynamic method.");
			}
			this.index = index;
			this.owner = owner;
			this.priority = ((priority == -1) ? 400 : priority);
			this.before = before ?? new string[0];
			this.after = after ?? new string[0];
			this.debug = debug;
			PatchMethod = patch;
		}

		public Patch(MethodInfo patch, int index, string owner, int priority, string[] before, string[] after, bool debug, bool wrapTryCatch)
		{
			if (patch is DynamicMethod)
			{
				throw new Exception("Cannot directly reference dynamic method \"" + patch.FullDescription() + "\" in Harmony. Use a factory method instead that will return the dynamic method.");
			}
			this.index = index;
			this.owner = owner;
			this.priority = ((priority == -1) ? 400 : priority);
			this.before = before ?? new string[0];
			this.after = after ?? new string[0];
			this.debug = debug;
			this.wrapTryCatch = wrapTryCatch;
			PatchMethod = patch;
		}

		public Patch(MethodInfo patch, int index, string owner, int priority, string[] before, string[] after, bool debug, bool wrapTryCatch, string debugEmitPath)
		{
			if (patch is DynamicMethod)
			{
				throw new Exception("Cannot directly reference dynamic method \"" + patch.FullDescription() + "\" in Harmony. Use a factory method instead that will return the dynamic method.");
			}
			this.index = index;
			this.owner = owner;
			this.priority = ((priority == -1) ? 400 : priority);
			this.before = before ?? new string[0];
			this.after = after ?? new string[0];
			this.debug = debug;
			this.debugEmitPath = debugEmitPath;
			this.wrapTryCatch = wrapTryCatch;
			PatchMethod = patch;
		}

		public Patch(HarmonyMethod method, int index, string owner)
			: this(method.method, index, owner, method.priority, method.before, method.after, method.debug.GetValueOrDefault(), method.wrapTryCatch.GetValueOrDefault(), method.debugEmitPath)
		{
		}

		public MethodInfo GetMethod(MethodBase original)
		{
			MethodInfo methodInfo = PatchMethod;
			if (methodInfo.ReturnType != typeof(DynamicMethod) && methodInfo.ReturnType != typeof(MethodInfo))
			{
				return methodInfo;
			}
			if (!methodInfo.IsStatic)
			{
				return methodInfo;
			}
			ParameterInfo[] parameters = methodInfo.GetParameters();
			if (parameters.Length != 1)
			{
				return methodInfo;
			}
			if (parameters[0].ParameterType != typeof(MethodBase))
			{
				return methodInfo;
			}
			return methodInfo.Invoke(null, new object[1] { original }) as MethodInfo;
		}

		public override bool Equals(object obj)
		{
			if (obj != null && obj is Patch)
			{
				return PatchMethod == ((Patch)obj).PatchMethod;
			}
			return false;
		}

		public int CompareTo(object obj)
		{
			return PatchInfoSerialization.PriorityComparer(obj, index, priority);
		}

		public override int GetHashCode()
		{
			return PatchMethod.GetHashCode();
		}
	}
	public class PatchClassProcessor
	{
		private readonly Harmony instance;

		private readonly Type containerType;

		private readonly HarmonyMethod containerAttributes;

		private readonly Dictionary<Type, MethodInfo> auxilaryMethods;

		private readonly List<AttributePatch> patchMethods;

		private static readonly List<Type> auxilaryTypes = new List<Type>
		{
			typeof(HarmonyPrepare),
			typeof(HarmonyCleanup),
			typeof(HarmonyTargetMethod),
			typeof(HarmonyTargetMethods)
		};

		public PatchClassProcessor(Harmony instance, Type type)
			: this(instance, type, allowUnannotatedType: false)
		{
		}

		public PatchClassProcessor(Harmony instance, Type type, bool allowUnannotatedType)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			this.instance = instance;
			containerType = type;
			List<HarmonyMethod> fromType = HarmonyMethodExtensions.GetFromType(type);
			if (!allowUnannotatedType && (fromType == null || fromType.Count == 0))
			{
				return;
			}
			containerAttributes = HarmonyMethod.Merge(fromType);
			MethodType? methodType = containerAttributes.methodType;
			if (!methodType.HasValue)
			{
				containerAttributes.methodType = MethodType.Normal;
			}
			auxilaryMethods = new Dictionary<Type, MethodInfo>();
			foreach (Type auxilaryType in auxilaryTypes)
			{
				MethodInfo patchMethod = PatchTools.GetPatchMethod(containerType, auxilaryType.FullName);
				if ((object)patchMethod != null)
				{
					auxilaryMethods[auxilaryType] = patchMethod;
				}
			}
			patchMethods = PatchTools.GetPatchMethods(containerType, containerAttributes.GetDeclaringType() != null);
			foreach (AttributePatch patchMethod2 in patchMethods)
			{
				MethodInfo method = patchMethod2.info.method;
				patchMethod2.info = containerAttributes.Merge(patchMethod2.info);
				patchMethod2.info.method = method;
			}
		}

		public List<MethodInfo> Patch()
		{
			if (containerAttributes == null)
			{
				return null;
			}
			Exception exception = null;
			if (!RunMethod<HarmonyPrepare, bool>(defaultIfNotExisting: true, defaultIfFailing: false, null, Array.Empty<object>()))
			{
				RunMethod<HarmonyCleanup>(ref exception, Array.Empty<object>());
				ReportException(exception, null);
				return new List<MethodInfo>();
			}
			List<MethodInfo> result = new List<MethodInfo>();
			MethodBase lastOriginal = null;
			try
			{
				List<MethodBase> bulkMethods = GetBulkMethods();
				if (bulkMethods.Count == 1)
				{
					lastOriginal = bulkMethods[0];
				}
				ReversePatch(ref lastOriginal);
				result = ((bulkMethods.Count > 0) ? BulkPatch(bulkMethods, ref lastOriginal) : PatchWithAttributes(ref lastOriginal));
			}
			catch (Exception ex)
			{
				exception = ex;
			}
			RunMethod<HarmonyCleanup>(ref exception, new object[1] { exception });
			ReportException(exception, lastOriginal);
			return result;
		}

		private void ReversePatch(ref MethodBase lastOriginal)
		{
			for (int i = 0; i < patchMethods.Count; i++)
			{
				AttributePatch attributePatch = patchMethods[i];
				if (attributePatch.type == HarmonyPatchType.ReversePatch)
				{
					MethodBase originalMethod = attributePatch.info.GetOriginalMethod();
					if ((object)originalMethod != null)
					{
						lastOriginal = originalMethod;
					}
					ReversePatcher reversePatcher = instance.CreateReversePatcher(lastOriginal, attributePatch.info);
					lock (PatchProcessor.locker)
					{
						reversePatcher.Patch();
					}
				}
			}
		}

		private List<MethodInfo> BulkPatch(List<MethodBase> originals, ref MethodBase lastOriginal)
		{
			PatchJobs<MethodInfo> patchJobs = new PatchJobs<MethodInfo>();
			for (int i = 0; i < originals.Count; i++)
			{
				lastOriginal = originals[i];
				PatchJobs<MethodInfo>.Job job = patchJobs.GetJob(lastOriginal);
				foreach (AttributePatch patchMethod in patchMethods)
				{
					string text = "You cannot combine TargetMethod, TargetMethods or [HarmonyPatchAll] with individual annotations";
					HarmonyMethod info = patchMethod.info;
					if (info.methodName != null)
					{
						throw new ArgumentException(text + " [" + info.methodName + "]");
					}
					if (info.methodType.HasValue && info.methodType.Value != 0)
					{
						throw new ArgumentException($"{text} [{info.methodType}]");
					}
					if (info.argumentTypes != null)
					{
						throw new ArgumentException(text + " [" + info.argumentTypes.Description() + "]");
					}
					job.AddPatch(patchMethod);
				}
			}
			foreach (PatchJobs<MethodInfo>.Job job2 in patchJobs.GetJobs())
			{
				lastOriginal = job2.original;
				ProcessPatchJob(job2);
			}
			return patchJobs.GetReplacements();
		}

		private List<MethodInfo> PatchWithAttributes(ref MethodBase lastOriginal)
		{
			PatchJobs<MethodInfo> patchJobs = new PatchJobs<MethodInfo>();
			foreach (AttributePatch patchMethod in patchMethods)
			{
				lastOriginal = patchMethod.info.GetOriginalMethod();
				if ((object)lastOriginal == null)
				{
					throw new ArgumentException("Undefined target method for patch method " + patchMethod.info.method.FullDescription());
				}
				patchJobs.GetJob(lastOriginal).AddPatch(patchMethod);
			}
			foreach (PatchJobs<MethodInfo>.Job job in patchJobs.GetJobs())
			{
				lastOriginal = job.original;
				ProcessPatchJob(job);
			}
			return patchJobs.GetReplacements();
		}

		private void ProcessPatchJob(PatchJobs<MethodInfo>.Job job)
		{
			MethodInfo replacement = null;
			bool num = RunMethod<HarmonyPrepare, bool>(defaultIfNotExisting: true, defaultIfFailing: false, null, new object[1] { job.original });
			Exception exception = null;
			if (num)
			{
				lock (PatchProcessor.locker)
				{
					try
					{
						PatchInfo patchInfo = job.original.ToPatchInfo();
						patchInfo.AddPrefixes(instance.Id, job.prefixes.ToArray());
						patchInfo.AddPostfixes(instance.Id, job.postfixes.ToArray());
						patchInfo.AddTranspilers(instance.Id, job.transpilers.ToArray());
						patchInfo.AddFinalizers(instance.Id, job.finalizers.ToArray());
						patchInfo.AddILManipulators(instance.Id, job.ilmanipulators.ToArray());
						replacement = PatchFunctions.UpdateWrapper(job.original, patchInfo);
						PatchManager.AddReplacementOriginal(job.original, replacement);
					}
					catch (Exception ex)
					{
						exception = ex;
					}
				}
			}
			RunMethod<HarmonyCleanup>(ref exception, new object[2] { job.original, exception });
			ReportException(exception, job.original);
			job.replacement = replacement;
		}

		private List<MethodBase> GetBulkMethods()
		{
			if (containerType.GetCustomAttributes(inherit: true).Any((object a) => a.GetType().FullName == typeof(HarmonyPatchAll).FullName))
			{
				Type declaringType = containerAttributes.GetDeclaringType();
				if ((object)declaringType == null)
				{
					throw new ArgumentException("Using " + typeof(HarmonyPatchAll).FullName + " requires an additional attribute for specifying the Class/Type");
				}
				List<MethodBase> list = new List<MethodBase>();
				list.AddRange(AccessTools.GetDeclaredConstructors(declaringType).Cast<MethodBase>());
				list.AddRange(AccessTools.GetDeclaredMethods(declaringType).Cast<MethodBase>());
				List<PropertyInfo> declaredProperties = AccessTools.GetDeclaredProperties(declaringType);
				list.AddRange((from prop in declaredProperties
					select prop.GetGetMethod(nonPublic: true) into method
					where (object)method != null
					select method).Cast<MethodBase>());
				list.AddRange((from prop in declaredProperties
					select prop.GetSetMethod(nonPublic: true) into method
					where (object)method != null
					select method).Cast<MethodBase>());
				return list;
			}
			IEnumerable<MethodBase> enumerable = RunMethod<HarmonyTargetMethods, IEnumerable<MethodBase>>(null, null, FailOnResult, Array.Empty<object>());
			if (enumerable != null)
			{
				return enumerable.ToList();
			}
			List<MethodBase> list2 = new List<MethodBase>();
			MethodBase methodBase = RunMethod<HarmonyTargetMethod, MethodBase>(null, null, (MethodBase method) => ((object)method != null) ? null : "null", Array.Empty<object>());
			if ((object)methodBase != null)
			{
				list2.Add(methodBase);
			}
			return list2;
			static string FailOnResult(IEnumerable<MethodBase> res)
			{
				if (res == null)
				{
					return "null";
				}
				if (res.Any((MethodBase m) => (object)m == null))
				{
					return "some element was null";
				}
				return null;
			}
		}

		private void ReportException(Exception exception, MethodBase original)
		{
			if (exception == null)
			{
				return;
			}
			Logger.Log(Logger.LogChannel.Debug, delegate
			{
				Harmony.VersionInfo(out var currentVersion);
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine($"### Exception from user \"{instance.Id}\", Harmony v{currentVersion}");
				stringBuilder.AppendLine("### Original: " + (original?.FullDescription() ?? "NULL"));
				stringBuilder.AppendLine("### Patch class: " + containerType.FullDescription());
				Exception ex = exception;
				if (ex is HarmonyException ex2)
				{
					ex = ex2.InnerException;
				}
				string text = ex.ToString();
				while (text.Contains("\n\n"))
				{
					text = text.Replace("\n\n", "\n");
				}
				text = text.Split(new char[1] { '\n' }).Join((string line) => "### " + line, "\n");
				stringBuilder.AppendLine(text.Trim());
				return stringBuilder.ToString();
			});
			if (exception is HarmonyException)
			{
				throw exception;
			}
			throw new HarmonyException("Patching exception in method " + original.FullDescription(), exception);
		}

		private T RunMethod<S, T>(T defaultIfNotExisting, T defaultIfFailing, Func<T, string> failOnResult = null, params object[] parameters)
		{
			if (auxilaryMethods.TryGetValue(typeof(S), out var value))
			{
				object[] inputs = (parameters ?? new object[0]).Union(new object[1] { instance }).ToArray();
				object[] parameters2 = AccessTools.ActualParameters(value, inputs);
				if (value.ReturnType != typeof(void) && !typeof(T).IsAssignableFrom(value.ReturnType))
				{
					throw new Exception("Method " + value.FullDescription() + " has wrong return type (should be assignable to " + typeof(T).FullName + ")");
				}
				T val = defaultIfFailing;
				try
				{
					if (value.ReturnType == typeof(void))
					{
						value.Invoke(null, parameters2);
						val = defaultIfNotExisting;
					}
					else
					{
						val = (T)value.Invoke(null, parameters2);
					}
					if (failOnResult != null)
					{
						string text = failOnResult(val);
						if (text != null)
						{
							throw new Exception("Method " + value.FullDescription() + " returned an unexpected result: " + text);
						}
					}
				}
				catch (Exception exception)
				{
					ReportException(exception, value);
				}
				return val;
			}
			return defaultIfNotExisting;
		}

		private void RunMethod<S>(ref Exception exception, params object[] parameters)
		{
			if (!auxilaryMethods.TryGetValue(typeof(S), out var value))
			{
				return;
			}
			object[] inputs = (parameters ?? new object[0]).Union(new object[1] { instance }).ToArray();
			object[] parameters2 = AccessTools.ActualParameters(value, inputs);
			try
			{
				object obj = value.Invoke(null, parameters2);
				if (value.ReturnType == typeof(Exception))
				{
					exception = obj as Exception;
				}
			}
			catch (Exception exception2)
			{
				ReportException(exception2, value);
			}
		}
	}
	public class Patches
	{
		public readonly ReadOnlyCollection<Patch> Prefixes;

		public readonly ReadOnlyCollection<Patch> Postfixes;

		public readonly ReadOnlyCollection<Patch> Transpilers;

		public readonly ReadOnlyCollection<Patch> Finalizers;

		public readonly ReadOnlyCollection<Patch> ILManipulators;

		public ReadOnlyCollection<string> Owners
		{
			get
			{
				HashSet<string> hashSet = new HashSet<string>();
				hashSet.UnionWith(Prefixes.Select((Patch p) => p.owner));
				hashSet.UnionWith(Postfixes.Select((Patch p) => p.owner));
				hashSet.UnionWith(Transpilers.Select((Patch p) => p.owner));
				hashSet.UnionWith(Finalizers.Select((Patch p) => p.owner));
				hashSet.UnionWith(ILManipulators.Select((Patch p) => p.owner));
				return hashSet.ToList().AsReadOnly();
			}
		}

		public Patches(Patch[] prefixes, Patch[] postfixes, Patch[] transpilers, Patch[] finalizers, Patch[] ilmanipulators)
		{
			if (prefixes == null)
			{
				prefixes = new Patch[0];
			}
			if (postfixes == null)
			{
				postfixes = new Patch[0];
			}
			if (transpilers == null)
			{
				transpilers = new Patch[0];
			}
			if (finalizers == null)
			{
				finalizers = new Patch[0];
			}
			if (ilmanipulators == null)
			{
				ilmanipulators = new Patch[0];
			}
			Prefixes = prefixes.ToList().AsReadOnly();
			Postfixes = postfixes.ToList().AsReadOnly();
			Transpilers = transpilers.ToList().AsReadOnly();
			Finalizers = finalizers.ToList().AsReadOnly();
			ILManipulators = ilmanipulators.ToList().AsReadOnly();
		}

		[Obsolete("Use newer constructor instead", true)]
		public Patches(Patch[] prefixes, Patch[] postfixes, Patch[] transpilers, Patch[] finalizers)
			: this(prefixes, postfixes, transpilers, finalizers, null)
		{
		}
	}
	public class PatchProcessor
	{
		private readonly Harmony instance;

		private readonly MethodBase original;

		private HarmonyMethod prefix;

		private HarmonyMethod postfix;

		private HarmonyMethod transpiler;

		private HarmonyMethod finalizer;

		private HarmonyMethod ilmanipulator;

		internal static readonly object locker = new object();

		public PatchProcessor(Harmony instance, MethodBase original)
		{
			this.instance = instance;
			this.original = original;
		}

		public PatchProcessor AddPrefix(HarmonyMethod prefix)
		{
			this.prefix = prefix;
			return this;
		}

		public PatchProcessor AddPrefix(MethodInfo fixMethod)
		{
			prefix = new HarmonyMethod(fixMethod);
			return this;
		}

		public PatchProcessor AddPostfix(HarmonyMethod postfix)
		{
			this.postfix = postfix;
			return this;
		}

		public PatchProcessor AddPostfix(MethodInfo fixMethod)
		{
			postfix = new HarmonyMethod(fixMethod);
			return this;
		}

		public PatchProcessor AddTranspiler(HarmonyMethod transpiler)
		{
			this.transpiler = transpiler;
			return this;
		}

		public PatchProcessor AddTranspiler(MethodInfo fixMethod)
		{
			transpiler = new HarmonyMethod(fixMethod);
			return this;
		}

		public PatchProcessor AddFinalizer(HarmonyMethod finalizer)
		{
			this.finalizer = finalizer;
			return this;
		}

		public PatchProcessor AddFinalizer(MethodInfo fixMethod)
		{
			finalizer = new HarmonyMethod(fixMethod);
			return this;
		}

		public PatchProcessor AddILManipulator(HarmonyMethod ilmanipulator)
		{
			this.ilmanipulator = ilmanipulator;
			return this;
		}

		public PatchProcessor AddILManipulator(MethodInfo fixMethod)
		{
			ilmanipulator = new HarmonyMethod(fixMethod);
			return this;
		}

		public static IEnumerable<MethodBase> GetAllPatchedMethods()
		{
			return PatchManager.GetPatchedMethods();
		}

		public MethodInfo Patch()
		{
			if ((object)original == null)
			{
				throw new NullReferenceException("Null method for " + instance.Id);
			}
			if (!original.IsDeclaredMember())
			{
				Logger.Log(Logger.LogChannel.Warn, () => instance.Id + ": You should only patch implemented methods/constructors to avoid issues. Patch the declared method " + original.GetDeclaredMember().FullDescription() + " instead of " + original.FullDescription() + ".");
			}
			lock (locker)
			{
				PatchInfo patchInfo = original.ToPatchInfo();
				patchInfo.AddPrefixes(instance.Id, prefix);
				patchInfo.AddPostfixes(instance.Id, postfix);
				patchInfo.AddTranspilers(instance.Id, transpiler);
				patchInfo.AddFinalizers(instance.Id, finalizer);
				patchInfo.AddILManipulators(instance.Id, ilmanipulator);
				MethodInfo methodInfo = PatchFunctions.UpdateWrapper(original, patchInfo);
				PatchManager.AddReplacementOriginal(original, methodInfo);
				return methodInfo;
			}
		}

		public PatchProcessor Unpatch(HarmonyPatchType type, string harmonyID)
		{
			lock (locker)
			{
				PatchInfo patchInfo = original.ToPatchInfo();
				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Prefix)
				{
					patchInfo.RemovePrefix(harmonyID);
				}
				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Postfix)
				{
					patchInfo.RemovePostfix(harmonyID);
				}
				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Transpiler)
				{
					patchInfo.RemoveTranspiler(harmonyID);
				}
				if (type == HarmonyPatchType.All || type == HarmonyPatchType.Finalizer)
				{
					patchInfo.RemoveFinalizer(harmonyID);
				}
				if (type == HarmonyPatchType.All || type == HarmonyPatchType.ILManipulator)
				{
					patchInfo.RemoveILManipulator(harmonyID);
				}
				MethodInfo replacement = PatchFunctions.UpdateWrapper(original, patchInfo);
				PatchManager.AddReplacementOriginal(original, replacement);
				return this;
			}
		}

		public PatchProcessor Unpatch(MethodInfo patch)
		{
			lock (locker)
			{
				PatchInfo patchInfo = original.ToPatchInfo();
				patchInfo.RemovePatch(patch);
				MethodInfo replacement = PatchFunctions.UpdateWrapper(original, patchInfo);
				PatchManager.AddReplacementOriginal(original, replacement);
				return this;
			}
		}

		public static Patches GetPatchInfo(MethodBase method)
		{
			PatchInfo patchInfo = method.GetPatchInfo();
			if (patchInfo == null)
			{
				return null;
			}
			return new Patches(patchInfo.prefixes, patchInfo.postfixes, patchInfo.transpilers, patchInfo.finalizers, patchInfo.ilmanipulators);
		}

		public static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches)
		{
			return PatchFunctions.GetSortedPatchMethods(original, patches, debug: false);
		}

		public static Dictionary<string, Version> VersionInfo(out Version currentVersion)
		{
			currentVersion = typeof(Harmony).Assembly.GetName().Version;
			Dictionary<string, Assembly> assemblies = new Dictionary<string, Assembly>();
			GetAllPatchedMethods().Do(delegate(MethodBase method)
			{
				PatchInfo patchInfo = method.GetPatchInfo();
				patchInfo.prefixes.Do(delegate(Patch fix)
				{
					assemblies[fix.owner] = fix.PatchMethod.DeclaringType.Assembly;
				});
				patchInfo.postfixes.Do(delegate(Patch fix)
				{
					assemblies[fix.owner] = fix.PatchMethod.DeclaringType.Assembly;
				});
				patchInfo.transpilers.Do(delegate(Patch fix)
				{
					assemblies[fix.owner] = fix.PatchMethod.DeclaringType.Assembly;
				});
				patchInfo.finalizers.Do(delegate(Patch fix)
				{
					assemblies[fix.owner] = fix.PatchMethod.DeclaringType.Assembly;
				});
				patchInfo.ilmanipulators.Do(delegate(Patch fix)
				{
					assemblies[fix.owner] = fix.PatchMethod.DeclaringType.Assembly;
				});
			});
			Dictionary<string, Version> result = new Dictionary<string, Version>();
			assemblies.Do(delegate(KeyValuePair<string, Assembly> info)
			{
				AssemblyName assemblyName = info.Value.GetReferencedAssemblies().FirstOrDefault((AssemblyName a) => a.FullName.StartsWith("0Harmony, Version", StringComparison.Ordinal));
				if (assemblyName != null)
				{
					result[info.Key] = assemblyName.Version;
				}
			});
			return result;
		}

		public static ILGenerator CreateILGenerator()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			return new DynamicMethodDefinition($"ILGenerator_{Guid.NewGuid()}", typeof(void), new Type[0]).GetILGenerator();
		}

		public static ILGenerator CreateILGenerator(MethodBase original)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Type type = ((original is MethodInfo methodInfo) ? methodInfo.ReturnType : typeof(void));
			List<Type> list = (from pi in original.GetParameters()
				select pi.ParameterType).ToList();
			if (!original.IsStatic)
			{
				list.Insert(0, original.DeclaringType);
			}
			return new DynamicMethodDefinition("ILGenerator_" + original.Name, type, list.ToArray()).GetILGenerator();
		}

		public static List<CodeInstruction> GetOriginalInstructions(MethodBase original, ILGenerator generator = null)
		{
			return PatchFunctions.ApplyTranspilers(original, generator ?? CreateILGenerator(original)).ToList();
		}

		public static List<CodeInstruction> GetOriginalInstructions(MethodBase original, out ILGenerator generator)
		{
			generator = CreateILGenerator(original);
			return PatchFunctions.ApplyTranspilers(original, generator).ToList();
		}

		public static List<CodeInstruction> GetCurrentInstructions(MethodBase original, int maxTranspilers = int.MaxValue, ILGenerator generator = null)
		{
			return PatchFunctions.ApplyTranspilers(original, generator ?? CreateILGenerator(original), maxTranspilers).ToList();
		}

		public static List<CodeInstruction> GetCurrentInstructions(MethodBase original, out ILGenerator generator, int maxTranspilers = int.MaxValue)
		{
			generator = CreateILGenerator(original);
			return PatchFunctions.ApplyTranspilers(original, generator, maxTranspilers).ToList();
		}

		public static IEnumerable<KeyValuePair<OpCode, object>> ReadMethodBody(MethodBase method)
		{
			DynamicMethodDefinition val = method.GetMethodPatcher().CopyOriginal();
			if (val == null)
			{
				return null;
			}
			return new ILManipulator(val.Definition.Body, debug: false).GetRawInstructions();
		}

		public static IEnumerable<KeyValuePair<OpCode, object>> ReadMethodBody(MethodBase method, ILGenerator generator)
		{
			DynamicMethodDefinition val = method.GetMethodPatcher().CopyOriginal();
			if (val == null)
			{
				return null;
			}
			ILManipulator iLManipulator = new ILManipulator(val.Definition.Body, debug: false);
			iLManipulator.GetInstructions(generator);
			return iLManipulator.GetRawInstructions();
		}
	}
	public static class Priority
	{
		public const int Last = 0;

		public const int VeryLow = 100;

		public const int Low = 200;

		public const int LowerThanNormal = 300;

		public const int Normal = 400;

		public const int HigherThanNormal = 500;

		public const int High = 600;

		public const int VeryHigh = 700;

		public const int First = 800;
	}
	public class ReversePatcher
	{
		private readonly Harmony instance;

		private readonly MethodBase original;

		private readonly HarmonyMethod standin;

		public ReversePatcher(Harmony instance, MethodBase original, HarmonyMethod standin)
		{
			this.instance = instance;
			this.original = original;
			this.standin = standin;
		}

		public MethodInfo Patch(HarmonyReversePatchType type = HarmonyReversePatchType.Original)
		{
			if ((object)original == null)
			{
				throw new NullReferenceException("Null method for " + instance.Id);
			}
			standin.reversePatchType = type;
			MethodInfo transpiler = GetTranspiler(standin.method);
			MethodInfo manipulator = GetManipulator(standin.method);
			return PatchFunctions.ReversePatch(standin, original, transpiler, manipulator);
		}

		internal static MethodInfo GetTranspiler(MethodInfo method)
		{
			string methodName = method.Name;
			List<MethodInfo> declaredMethods = AccessTools.GetDeclaredMethods(method.DeclaringType);
			Type ici = typeof(IEnumerable<CodeInstruction>);
			return declaredMethods.FirstOrDefault((MethodInfo m) => !(m.ReturnType != ici) && m.Name.StartsWith("<" + methodName + ">"));
		}

		internal static MethodInfo GetManipulator(MethodInfo method)
		{
			string methodName = method.Name;
			List<MethodInfo> declaredMethods = AccessTools.GetDeclaredMethods(method.DeclaringType);
			Type ctxType = typeof(ILContext);
			return declaredMethods.FirstOrDefault((MethodInfo m) => (from p in m.GetParameters()
				select p.ParameterType).Contains(ctxType) && m.Name.StartsWith("<" + methodName + ">"));
		}
	}
	public static class Transpilers
	{
		private static readonly Dictionary<int, Delegate> DelegateCache = new Dictionary<int, Delegate>();

		private static int delegateCounter;

		public static CodeInstruction EmitDelegate<T>(T action) where T : Delegate
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			if (action.Method.IsStatic && action.Target == null)
			{
				return new CodeInstruction(OpCodes.Call, action.Method);
			}
			Type[] array = (from x in action.Method.GetParameters()
				select x.ParameterType).ToArray();
			DynamicMethodDefinition val = new DynamicMethodDefinition(action.Method.Name, action.Method.ReturnType, array);
			ILGenerator iLGenerator = val.GetILGenerator();
			Type type = action.Target.GetType();
			if (action.Target != null && type.GetFields().Any((FieldInfo x) => !x.IsStatic))
			{
				int num = delegateCounter++;
				DelegateCache[num] = action;
				FieldInfo field = AccessTools.Field(typeof(Transpilers), "DelegateCache");
				MethodInfo meth = AccessTools.Method(typeof(Dictionary<int, Delegate>), "get_Item");
				iLGenerator.Emit(OpCodes.Ldsfld, field);
				iLGenerator.Emit(OpCodes.Ldc_I4, num);
				iLGenerator.Emit(OpCodes.Callvirt, meth);
			}
			else
			{
				if (action.Target == null)
				{
					iLGenerator.Emit(OpCodes.Ldnull);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Newobj, AccessTools.FirstConstructor(type, (ConstructorInfo x) => x.GetParameters().Length == 0 && !x.IsStatic));
				}
				iLGenerator.Emit(OpCodes.Ldftn, action.Method);
				iLGenerator.Emit(OpCodes.Newobj, AccessTools.Constructor(typeof(T), new Type[2]
				{
					typeof(object),
					typeof(IntPtr)
				}));
			}
			for (int i = 0; i < array.Length; i++)
			{
				iLGenerator.Emit(OpCodes.Ldarg_S, (short)i);
			}
			iLGenerator.Emit(OpCodes.Callvirt, AccessTools.Method(typeof(T), "Invoke"));
			iLGenerator.Emit(OpCodes.Ret);
			return new CodeInstruction(OpCodes.Call, val.Generate());
		}

		public static IEnumerable<CodeInstruction> MethodReplacer(this IEnumerable<CodeInstruction> instructions, MethodBase from, MethodBase to)
		{
			if ((object)from == null)
			{
				throw new ArgumentException("Unexpected null argument", "from");
			}
			if ((object)to == null)
			{
				throw new ArgumentException("Unexpected null argument", "to");
			}
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.operand as MethodBase == from)
				{
					instruction.opcode = (to.IsConstructor ? OpCodes.Newobj : OpCodes.Call);
					instruction.operand = to;
				}
				yield return instruction;
			}
		}

		public static IEnumerable<CodeInstruction> Manipulator(this IEnumerable<CodeInstruction> instructions, Func<CodeInstruction, bool> predicate, Action<CodeInstruction> action)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return instructions.Select(delegate(CodeInstruction instruction)
			{
				if (predicate(instruction))
				{
					action(instruction);
				}
				return instruction;
			}).AsEnumerable();
		}

		public static IEnumerable<CodeInstruction> DebugLogger(this IEnumerable<CodeInstruction> instructions, string text)
		{
			yield return new CodeInstruction(OpCodes.Ldc_I4, Logger.LogChannel.Debug);
			yield return new CodeInstruction(OpCodes.Ldstr, text);
			yield return new CodeInstruction(OpCodes.Ldc_I4_1);
			yield return new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(Logger), "LogText"));
			foreach (CodeInstruction instruction in instructions)
			{
				yield return instruction;
			}
		}

		public static IEnumerable<CodeInstruction> ReplaceWith(MethodBase replacement, ILGenerator ilGenerator)
		{
			if (replacement.GetMethodBody() == null)
			{
				throw new ArgumentException("Replacement method must be a managed method", "replacement");
			}
			Traverse.Create(ilGenerator).Field("Target").GetValue<CecilILGenerator>()
				.IL.Body.Variables.Clear();
			return PatchProcessor.GetOriginalInstructions(replacement, ilGenerator);
		}
	}
	public static class AccessTools
	{
		public delegate ref F FieldRef<in T, F>(T instance = default(T));

		public delegate ref F StructFieldRef<T, F>(ref T instance) where T : struct;

		public delegate ref F FieldRef<F>();

		public static readonly BindingFlags all = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty;

		public static readonly BindingFlags allDeclared = all | BindingFlags.DeclaredOnly;

		private static readonly Dictionary<Type, FastInvokeHandler> addHandlerCache = new Dictionary<Type, FastInvokeHandler>();

		private static readonly ReaderWriterLockSlim addHandlerCacheLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);

		public static bool IsMonoRuntime { get; } = (object)Type.GetType("Mono.Runtime") != null;


		public static bool IsNetFrameworkRuntime { get; } = Type.GetType("System.Runtime.InteropServices.RuntimeInformation", throwOnError: false)?.GetProperty("FrameworkDescription").GetValue(null, null).ToString()
			.StartsWith(".NET Framework") ?? (!IsMonoRuntime);


		public static bool IsNetCoreRuntime { get; } = Type.GetType("System.Runtime.InteropServices.RuntimeInformation", throwOnError: false)?.GetProperty("FrameworkDescription").GetValue(null, null).ToString()
			.StartsWith(".NET Core") ?? false;


		public static IEnumerable<Assembly> AllAssemblies()
		{
			return from a in AppDomain.CurrentDomain.GetAssemblies()
				where !a.FullName.StartsWith("Microsoft.VisualStudio")
				select a;
		}

		public static Type TypeByName(string name)
		{
			Type type = Type.GetType(name, throwOnError: false);
			if ((object)type == null)
			{
				type = AllTypes().FirstOrDefault((Type t) => t.FullName == name);
			}
			if ((object)type == null)
			{
				type = AllTypes().FirstOrDefault((Type t) => t.Name == name);
			}
			if ((object)type == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => "AccessTools.TypeByName: Could not find type named " + name);
			}
			return type;
		}

		public static Type[] GetTypesFromAssembly(Assembly assembly)
		{
			try
			{
				return assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex2)
			{
				ReflectionTypeLoadException ex = ex2;
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.GetTypesFromAssembly: assembly {assembly} => {ex}");
				return ex.Types.Where((Type type) => (object)type != null).ToArray();
			}
		}

		public static IEnumerable<Type> AllTypes()
		{
			return AllAssemblies().SelectMany((Assembly a) => GetTypesFromAssembly(a));
		}

		public static T FindIncludingBaseTypes<T>(Type type, Func<Type, T> func) where T : class
		{
			do
			{
				T val = func(type);
				if (val != null)
				{
					return val;
				}
				type = type.BaseType;
			}
			while ((object)type != null);
			return null;
		}

		public static T FindIncludingInnerTypes<T>(Type type, Func<Type, T> func) where T : class
		{
			T val = func(type);
			if (val != null)
			{
				return val;
			}
			Type[] nestedTypes = type.GetNestedTypes(all);
			for (int i = 0; i < nestedTypes.Length; i++)
			{
				val = FindIncludingInnerTypes(nestedTypes[i], func);
				if (val != null)
				{
					break;
				}
			}
			return val;
		}

		public static FieldInfo DeclaredField(Type type, string name)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredField: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredField: name is null");
				return null;
			}
			FieldInfo? field = type.GetField(name, allDeclared);
			if ((object)field == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.DeclaredField: Could not find field for type {type} and name {name}");
			}
			return field;
		}

		public static FieldInfo DeclaredField(string typeColonName)
		{
			ReflectionTools.TypeAndName info = ReflectionTools.TypColonName(typeColonName);
			FieldInfo? field = info.type.GetField(info.name, allDeclared);
			if ((object)field == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.DeclaredField: Could not find field for type {info.type} and name {info.name}");
			}
			return field;
		}

		public static FieldInfo Field(Type type, string name)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Field: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Field: name is null");
				return null;
			}
			FieldInfo? fieldInfo = FindIncludingBaseTypes(type, (Type t) => t.GetField(name, all));
			if ((object)fieldInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.Field: Could not find field for type {type} and name {name}");
			}
			return fieldInfo;
		}

		public static FieldInfo Field(string typeColonName)
		{
			ReflectionTools.TypeAndName info = ReflectionTools.TypColonName(typeColonName);
			FieldInfo? fieldInfo = FindIncludingBaseTypes(info.type, (Type t) => t.GetField(info.name, all));
			if ((object)fieldInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.Field: Could not find field for type {info.type} and name {info.name}");
			}
			return fieldInfo;
		}

		public static FieldInfo DeclaredField(Type type, int idx)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredField: type is null");
				return null;
			}
			FieldInfo? fieldInfo = GetDeclaredFields(type).ElementAtOrDefault(idx);
			if ((object)fieldInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.DeclaredField: Could not find field for type {type} and idx {idx}");
			}
			return fieldInfo;
		}

		public static PropertyInfo DeclaredProperty(Type type, string name)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredProperty: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredProperty: name is null");
				return null;
			}
			PropertyInfo? property = type.GetProperty(name, allDeclared);
			if ((object)property == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.DeclaredProperty: Could not find property for type {type} and name {name}");
			}
			return property;
		}

		public static PropertyInfo DeclaredProperty(string typeColonName)
		{
			ReflectionTools.TypeAndName info = ReflectionTools.TypColonName(typeColonName);
			PropertyInfo? property = info.type.GetProperty(info.name, allDeclared);
			if ((object)property == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.DeclaredProperty: Could not find property for type {info.type} and name {info.name}");
			}
			return property;
		}

		public static MethodInfo DeclaredPropertyGetter(Type type, string name)
		{
			return DeclaredProperty(type, name)?.GetGetMethod(nonPublic: true);
		}

		public static MethodInfo DeclaredPropertyGetter(string typeColonName)
		{
			return DeclaredProperty(typeColonName)?.GetGetMethod(nonPublic: true);
		}

		public static MethodInfo DeclaredPropertySetter(Type type, string name)
		{
			return DeclaredProperty(type, name)?.GetSetMethod(nonPublic: true);
		}

		public static MethodInfo DeclaredPropertySetter(string typeColonName)
		{
			return DeclaredProperty(typeColonName)?.GetSetMethod(nonPublic: true);
		}

		public static PropertyInfo Property(Type type, string name)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Property: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Property: name is null");
				return null;
			}
			PropertyInfo? propertyInfo = FindIncludingBaseTypes(type, (Type t) => t.GetProperty(name, all));
			if ((object)propertyInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.Property: Could not find property for type {type} and name {name}");
			}
			return propertyInfo;
		}

		public static PropertyInfo Property(string typeColonName)
		{
			ReflectionTools.TypeAndName info = ReflectionTools.TypColonName(typeColonName);
			PropertyInfo? propertyInfo = FindIncludingBaseTypes(info.type, (Type t) => t.GetProperty(info.name, all));
			if ((object)propertyInfo == null)
			{
				Logger.Log(Logger.LogChannel.Debug, () => $"AccessTools.Property: Could not find property for type {info.type} and name {info.name}");
			}
			return propertyInfo;
		}

		public static MethodInfo PropertyGetter(Type type, string name)
		{
			return Property(type, name)?.GetGetMethod(nonPublic: true);
		}

		public static MethodInfo PropertyGetter(string typeColonName)
		{
			return Property(typeColonName)?.GetGetMethod(nonPublic: true);
		}

		public static MethodInfo PropertySetter(Type type, string name)
		{
			return Property(type, name)?.GetSetMethod(nonPublic: true);
		}

		public static MethodInfo PropertySetter(string typeColonName)
		{
			return Property(typeColonName)?.GetSetMethod(nonPublic: true);
		}

		public static MethodInfo DeclaredMethod(Type type, string name, Type[] parameters = null, Type[] generics = null)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredMethod: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredMethod: name is null");
				return null;
			}
			ParameterModifier[] modifiers = new ParameterModifier[0];
			MethodInfo methodInfo = ((parameters != null) ? type.GetMethod(name, allDeclared, null, parameters, modifiers) : type.GetMethod(name, allDeclared));
			if ((object)methodInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.DeclaredMethod: Could not find method for type {type} and name {name} and parameters {parameters?.Description()}");
				return null;
			}
			if (generics != null)
			{
				methodInfo = methodInfo.MakeGenericMethod(generics);
			}
			return methodInfo;
		}

		public static MethodInfo DeclaredMethod(string typeColonName, Type[] parameters = null, Type[] generics = null)
		{
			ReflectionTools.TypeAndName typeAndName = ReflectionTools.TypColonName(typeColonName);
			return DeclaredMethod(typeAndName.type, typeAndName.name, parameters, generics);
		}

		public static MethodInfo Method(Type type, string name, Type[] parameters = null, Type[] generics = null)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Method: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Method: name is null");
				return null;
			}
			ParameterModifier[] modifiers = new ParameterModifier[0];
			MethodInfo methodInfo;
			if (parameters == null)
			{
				try
				{
					methodInfo = FindIncludingBaseTypes(type, (Type t) => t.GetMethod(name, all));
				}
				catch (AmbiguousMatchException inner)
				{
					methodInfo = FindIncludingBaseTypes(type, (Type t) => t.GetMethod(name, all, null, new Type[0], modifiers));
					if ((object)methodInfo == null)
					{
						throw new AmbiguousMatchException($"Ambiguous match in Harmony patch for {type}:{name}", inner);
					}
				}
			}
			else
			{
				methodInfo = FindIncludingBaseTypes(type, (Type t) => t.GetMethod(name, all, null, parameters, modifiers));
			}
			if ((object)methodInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.Method: Could not find method for type {type} and name {name} and parameters {parameters?.Description()}");
				return null;
			}
			if (generics != null)
			{
				methodInfo = methodInfo.MakeGenericMethod(generics);
			}
			return methodInfo;
		}

		public static MethodInfo Method(string typeColonName, Type[] parameters = null, Type[] generics = null)
		{
			ReflectionTools.TypeAndName typeAndName = ReflectionTools.TypColonName(typeColonName);
			return Method(typeAndName.type, typeAndName.name, parameters, generics);
		}

		public static MethodInfo EnumeratorMoveNext(MethodBase enumerator)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if ((object)enumerator == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "EnumeratorMoveNext.Method: enumerator is null");
				return null;
			}
			ILContext val = new ILContext(new DynamicMethodDefinition(enumerator).Definition);
			ILCursor val2 = new ILCursor(val);
			Type enumeratorType;
			if (((MemberReference)((MethodReference)val.Method).ReturnType).Name.StartsWith("UniTask"))
			{
				VariableDefinition? obj = ((IEnumerable<VariableDefinition>)val.Body.Variables).FirstOrDefault();
				TypeReference firstVar = ((obj != null) ? ((VariableReference)obj).VariableType : null);
				if (firstVar != null && !((MemberReference)firstVar).Name.Contains(enumerator.Name))
				{
					Logger.Log(Logger.LogChannel.Warn, () => "EnumeratorMoveNext.Method: Unexpected type name " + ((MemberReference)firstVar).Name + ", should contain " + enumerator.Name);
					return null;
				}
				enumeratorType = ReflectionHelper.ResolveReflection(firstVar);
			}
			else
			{
				MethodReference enumeratorCtor = null;
				val2.GotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction i) => ILPatternMatchingExt.MatchNewobj(i, ref enumeratorCtor)
				});
				if (enumeratorCtor == null)
				{
					Logger.Log(Logger.LogChannel.Warn, () => "EnumeratorMoveNext.Method: " + enumerator.FullDescription() + " does not create enumerators");
					return null;
				}
				if (((MemberReference)enumeratorCtor).Name != ".ctor")
				{
					Logger.Log(Logger.LogChannel.Warn, () => "EnumeratorMoveNext.Method: " + enumerator.FullDescription() + " does not create an enumerator (got " + Extensions.GetID(enumeratorCtor, (string)null, (string)null, true, true) + ")");
					return null;
				}
				enumeratorType = ReflectionHelper.ResolveReflection(((MemberReference)enumeratorCtor).DeclaringType);
			}
			MethodInfo methodInfo = Method(enumeratorType, "MoveNext");
			if ((object)methodInfo == null)
			{
				Logger.Log(Logger.LogChannel.Warn, () => "EnumeratorMoveNext.Method: " + enumerator.FullDescription() + " creates an object " + enumeratorType.FullDescription() + " but it doesn't have MoveNext");
				return null;
			}
			return methodInfo;
		}

		public static List<string> GetMethodNames(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetMethodNames: type is null");
				return new List<string>();
			}
			return (from m in GetDeclaredMethods(type)
				select m.Name).ToList();
		}

		public static List<string> GetMethodNames(object instance)
		{
			if (instance == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetMethodNames: instance is null");
				return new List<string>();
			}
			return GetMethodNames(instance.GetType());
		}

		public static List<string> GetFieldNames(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetFieldNames: type is null");
				return new List<string>();
			}
			return (from f in GetDeclaredFields(type)
				select f.Name).ToList();
		}

		public static List<string> GetFieldNames(object instance)
		{
			if (instance == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetFieldNames: instance is null");
				return new List<string>();
			}
			return GetFieldNames(instance.GetType());
		}

		public static List<string> GetPropertyNames(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetPropertyNames: type is null");
				return new List<string>();
			}
			return (from f in GetDeclaredProperties(type)
				select f.Name).ToList();
		}

		public static List<string> GetPropertyNames(object instance)
		{
			if (instance == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetPropertyNames: instance is null");
				return new List<string>();
			}
			return GetPropertyNames(instance.GetType());
		}

		public static Type GetUnderlyingType(this MemberInfo member)
		{
			return member.MemberType switch
			{
				MemberTypes.Event => ((EventInfo)member).EventHandlerType, 
				MemberTypes.Field => ((FieldInfo)member).FieldType, 
				MemberTypes.Method => ((MethodInfo)member).ReturnType, 
				MemberTypes.Property => ((PropertyInfo)member).PropertyType, 
				_ => throw new ArgumentException("Member must be of type EventInfo, FieldInfo, MethodInfo, or PropertyInfo"), 
			};
		}

		public static bool IsDeclaredMember<T>(this T member) where T : MemberInfo
		{
			return member.DeclaringType == member.ReflectedType;
		}

		public static T GetDeclaredMember<T>(this T member) where T : MemberInfo
		{
			if ((object)member.DeclaringType == null || member.IsDeclaredMember())
			{
				return member;
			}
			int metadataToken = member.MetadataToken;
			MemberInfo[] array = member.DeclaringType?.GetMembers(all) ?? new MemberInfo[0];
			foreach (MemberInfo memberInfo in array)
			{
				if (memberInfo.MetadataToken == metadataToken)
				{
					return (T)memberInfo;
				}
			}
			return member;
		}

		public static ConstructorInfo DeclaredConstructor(Type type, Type[] parameters = null, bool searchForStatic = false)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredConstructor: type is null");
				return null;
			}
			if (parameters == null)
			{
				parameters = new Type[0];
			}
			BindingFlags bindingAttr = (searchForStatic ? (allDeclared & ~BindingFlags.Instance) : (allDeclared & ~BindingFlags.Static));
			return type.GetConstructor(bindingAttr, null, parameters, new ParameterModifier[0]);
		}

		public static ConstructorInfo Constructor(Type type, Type[] parameters = null, bool searchForStatic = false)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.ConstructorInfo: type is null");
				return null;
			}
			if (parameters == null)
			{
				parameters = new Type[0];
			}
			BindingFlags flags = (searchForStatic ? (all & ~BindingFlags.Instance) : (all & ~BindingFlags.Static));
			return FindIncludingBaseTypes(type, (Type t) => t.GetConstructor(flags, null, parameters, new ParameterModifier[0]));
		}

		public static List<ConstructorInfo> GetDeclaredConstructors(Type type, bool? searchForStatic = null)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetDeclaredConstructors: type is null");
				return new List<ConstructorInfo>();
			}
			BindingFlags bindingFlags = allDeclared;
			if (searchForStatic.HasValue)
			{
				bindingFlags = (searchForStatic.Value ? (bindingFlags & ~BindingFlags.Instance) : (bindingFlags & ~BindingFlags.Static));
			}
			return (from method in type.GetConstructors(bindingFlags)
				where method.DeclaringType == type
				select method).ToList();
		}

		public static List<MethodInfo> GetDeclaredMethods(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetDeclaredMethods: type is null");
				return new List<MethodInfo>();
			}
			return type.GetMethods(allDeclared).ToList();
		}

		public static List<PropertyInfo> GetDeclaredProperties(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetDeclaredProperties: type is null");
				return new List<PropertyInfo>();
			}
			return type.GetProperties(allDeclared).ToList();
		}

		public static List<FieldInfo> GetDeclaredFields(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetDeclaredFields: type is null");
				return new List<FieldInfo>();
			}
			return type.GetFields(allDeclared).ToList();
		}

		public static Type GetReturnedType(MethodBase methodOrConstructor)
		{
			if ((object)methodOrConstructor == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetReturnedType: methodOrConstructor is null");
				return null;
			}
			if (methodOrConstructor is ConstructorInfo)
			{
				return typeof(void);
			}
			return ((MethodInfo)methodOrConstructor).ReturnType;
		}

		public static Type Inner(Type type, string name)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Inner: type is null");
				return null;
			}
			if (name == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Inner: name is null");
				return null;
			}
			return FindIncludingBaseTypes(type, (Type t) => t.GetNestedType(name, all));
		}

		public static Type FirstInner(Type type, Func<Type, bool> predicate)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstInner: type is null");
				return null;
			}
			if (predicate == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstInner: predicate is null");
				return null;
			}
			return type.GetNestedTypes(all).FirstOrDefault((Type subType) => predicate(subType));
		}

		public static MethodInfo FirstMethod(Type type, Func<MethodInfo, bool> predicate)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstMethod: type is null");
				return null;
			}
			if (predicate == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstMethod: predicate is null");
				return null;
			}
			return type.GetMethods(allDeclared).FirstOrDefault((MethodInfo method) => predicate(method));
		}

		public static ConstructorInfo FirstConstructor(Type type, Func<ConstructorInfo, bool> predicate)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstConstructor: type is null");
				return null;
			}
			if (predicate == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstConstructor: predicate is null");
				return null;
			}
			return type.GetConstructors(allDeclared).FirstOrDefault((ConstructorInfo constructor) => predicate(constructor));
		}

		public static PropertyInfo FirstProperty(Type type, Func<PropertyInfo, bool> predicate)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstProperty: type is null");
				return null;
			}
			if (predicate == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.FirstProperty: predicate is null");
				return null;
			}
			return type.GetProperties(allDeclared).FirstOrDefault((PropertyInfo property) => predicate(property));
		}

		public static Type[] GetTypes(object[] parameters)
		{
			if (parameters == null)
			{
				return new Type[0];
			}
			return parameters.Select((object p) => (p != null) ? p.GetType() : typeof(object)).ToArray();
		}

		public static object[] ActualParameters(MethodBase method, object[] inputs)
		{
			List<Type> inputTypes = inputs.Select((object obj) => obj?.GetType()).ToList();
			return (from p in method.GetParameters()
				select p.ParameterType).Select(delegate(Type pType)
			{
				int num = inputTypes.FindIndex((Type inType) => (object)inType != null && pType.IsAssignableFrom(inType));
				return (num >= 0) ? inputs[num] : GetDefaultValue(pType);
			}).ToArray();
		}

		public static FieldRef<T, F> FieldRefAccess<T, F>(string fieldName)
		{
			if (fieldName == null)
			{
				throw new ArgumentNullException("fieldName");
			}
			try
			{
				Type typeFromHandle = typeof(T);
				if (typeFromHandle.IsValueType)
				{
					throw new ArgumentException("T (FieldRefAccess instance type) must not be a value type");
				}
				return ReflectionTools.FieldRefAccess<T, F>(ReflectionTools.GetInstanceField(typeFromHandle, fieldName), needCastclass: false);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"FieldRefAccess<{typeof(T)}, {typeof(F)}> for {fieldName} caused an exception", innerException);
			}
		}

		public static ref F FieldRefAccess<T, F>(T instance, string fieldName)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if (fieldName == null)
			{
				throw new ArgumentNullException("fieldName");
			}
			try
			{
				Type typeFromHandle = typeof(T);
				if (typeFromHandle.IsValueType)
				{
					throw new ArgumentException("T (FieldRefAccess instance type) must not be a value type");
				}
				return ref ReflectionTools.FieldRefAccess<T, F>(ReflectionTools.GetInstanceField(typeFromHandle, fieldName), needCastclass: false)(instance);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"FieldRefAccess<{typeof(T)}, {typeof(F)}> for {instance}, {fieldName} caused an exception", innerException);
			}
		}

		public static FieldRef<object, F> FieldRefAccess<F>(Type type, string fieldName)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (fieldName == null)
			{
				throw new ArgumentNullException("fieldName");
			}
			try
			{
				FieldInfo fieldInfo = Field(type, fieldName);
				if ((object)fieldInfo == null)
				{
					throw new MissingFieldException(type.Name, fieldName);
				}
				if (!fieldInfo.IsStatic)
				{
					Type declaringType = fieldInfo.DeclaringType;
					if ((object)declaringType != null && declaringType.IsValueType)
					{
						throw new ArgumentException("Either FieldDeclaringType must be a class or field must be static");
					}
				}
				return ReflectionTools.FieldRefAccess<object, F>(fieldInfo, needCastclass: true);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"FieldRefAccess<{typeof(F)}> for {type}, {fieldName} caused an exception", innerException);
			}
		}

		public static FieldRef<object, F> FieldRefAccess<F>(string typeColonName)
		{
			ReflectionTools.TypeAndName typeAndName = ReflectionTools.TypColonName(typeColonName);
			return FieldRefAccess<F>(typeAndName.type, typeAndName.name);
		}

		public static FieldRef<T, F> FieldRefAccess<T, F>(FieldInfo fieldInfo)
		{
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			try
			{
				Type typeFromHandle = typeof(T);
				if (typeFromHandle.IsValueType)
				{
					throw new ArgumentException("T (FieldRefAccess instance type) must not be a value type");
				}
				bool needCastclass = false;
				if (!fieldInfo.IsStatic)
				{
					Type declaringType = fieldInfo.DeclaringType;
					if ((object)declaringType != null)
					{
						if (declaringType.IsValueType)
						{
							throw new ArgumentException("Either FieldDeclaringType must be a class or field must be static");
						}
						needCastclass = ReflectionTools.FieldRefNeedsClasscast(typeFromHandle, declaringType);
					}
				}
				return ReflectionTools.FieldRefAccess<T, F>(fieldInfo, needCastclass);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"FieldRefAccess<{typeof(T)}, {typeof(F)}> for {fieldInfo} caused an exception", innerException);
			}
		}

		public static ref F FieldRefAccess<T, F>(T instance, FieldInfo fieldInfo)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			try
			{
				Type typeFromHandle = typeof(T);
				if (typeFromHandle.IsValueType)
				{
					throw new ArgumentException("T (FieldRefAccess instance type) must not be a value type");
				}
				if (fieldInfo.IsStatic)
				{
					throw new ArgumentException("Field must not be static");
				}
				bool needCastclass = false;
				Type declaringType = fieldInfo.DeclaringType;
				if ((object)declaringType != null)
				{
					if (declaringType.IsValueType)
					{
						throw new ArgumentException("FieldDeclaringType must be a class");
					}
					needCastclass = ReflectionTools.FieldRefNeedsClasscast(typeFromHandle, declaringType);
				}
				return ref ReflectionTools.FieldRefAccess<T, F>(fieldInfo, needCastclass)(instance);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"FieldRefAccess<{typeof(T)}, {typeof(F)}> for {instance}, {fieldInfo} caused an exception", innerException);
			}
		}

		public static StructFieldRef<T, F> StructFieldRefAccess<T, F>(string fieldName) where T : struct
		{
			if (fieldName == null)
			{
				throw new ArgumentNullException("fieldName");
			}
			try
			{
				return ReflectionTools.StructFieldRefAccess<T, F>(ReflectionTools.GetInstanceField(typeof(T), fieldName));
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StructFieldRefAccess<{typeof(T)}, {typeof(F)}> for {fieldName} caused an exception", innerException);
			}
		}

		public static ref F StructFieldRefAccess<T, F>(ref T instance, string fieldName) where T : struct
		{
			if (fieldName == null)
			{
				throw new ArgumentNullException("fieldName");
			}
			try
			{
				return ref ReflectionTools.StructFieldRefAccess<T, F>(ReflectionTools.GetInstanceField(typeof(T), fieldName))(ref instance);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StructFieldRefAccess<{typeof(T)}, {typeof(F)}> for {instance}, {fieldName} caused an exception", innerException);
			}
		}

		public static StructFieldRef<T, F> StructFieldRefAccess<T, F>(FieldInfo fieldInfo) where T : struct
		{
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			try
			{
				ReflectionTools.ValidateStructField<T, F>(fieldInfo);
				return ReflectionTools.StructFieldRefAccess<T, F>(fieldInfo);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StructFieldRefAccess<{typeof(T)}, {typeof(F)}> for {fieldInfo} caused an exception", innerException);
			}
		}

		public static ref F StructFieldRefAccess<T, F>(ref T instance, FieldInfo fieldInfo) where T : struct
		{
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			try
			{
				ReflectionTools.ValidateStructField<T, F>(fieldInfo);
				return ref ReflectionTools.StructFieldRefAccess<T, F>(fieldInfo)(ref instance);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StructFieldRefAccess<{typeof(T)}, {typeof(F)}> for {instance}, {fieldInfo} caused an exception", innerException);
			}
		}

		public static ref F StaticFieldRefAccess<T, F>(string fieldName)
		{
			return ref StaticFieldRefAccess<F>(typeof(T), fieldName);
		}

		public static ref F StaticFieldRefAccess<F>(Type type, string fieldName)
		{
			try
			{
				return ref ReflectionTools.StaticFieldRefAccess<F>(Field(type, fieldName) ?? throw new MissingFieldException(type.Name, fieldName))();
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StaticFieldRefAccess<{typeof(F)}> for {type}, {fieldName} caused an exception", innerException);
			}
		}

		public static ref F StaticFieldRefAccess<F>(string typeColonName)
		{
			ReflectionTools.TypeAndName typeAndName = ReflectionTools.TypColonName(typeColonName);
			return ref StaticFieldRefAccess<F>(typeAndName.type, typeAndName.name);
		}

		public static ref F StaticFieldRefAccess<T, F>(FieldInfo fieldInfo)
		{
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			try
			{
				return ref ReflectionTools.StaticFieldRefAccess<F>(fieldInfo)();
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StaticFieldRefAccess<{typeof(T)}, {typeof(F)}> for {fieldInfo} caused an exception", innerException);
			}
		}

		public static FieldRef<F> StaticFieldRefAccess<F>(FieldInfo fieldInfo)
		{
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			try
			{
				return ReflectionTools.StaticFieldRefAccess<F>(fieldInfo);
			}
			catch (Exception innerException)
			{
				throw new ArgumentException($"StaticFieldRefAccess<{typeof(F)}> for {fieldInfo} caused an exception", innerException);
			}
		}

		public static DelegateType MethodDelegate<DelegateType>(MethodInfo method, object instance = null, bool virtualCall = true) where DelegateType : Delegate
		{
			//IL_0295: 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_02a3: Expected O, but got Unknown
			//IL_0192: 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_01a0: Expected O, but got Unknown
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			Type typeFromHandle = typeof(DelegateType);
			if (method.IsStatic)
			{
				return (DelegateType)Delegate.CreateDelegate(typeFromHandle, method);
			}
			Type type = method.DeclaringType;
			if (type != null && type.IsInterface && !virtualCall)
			{
				throw new ArgumentException("Interface methods must be called virtually");
			}
			if (instance == null)
			{
				ParameterInfo[] parameters = typeFromHandle.GetMethod("Invoke").GetParameters();
				if (parameters.Length == 0)
				{
					Delegate.CreateDelegate(typeof(DelegateType), method);
					throw new ArgumentException("Invalid delegate type");
				}
				Type parameterType = parameters[0].ParameterType;
				if (type != null && type.IsInterface && parameterType.IsValueType)
				{
					InterfaceMapping interfaceMap = parameterType.GetInterfaceMap(type);
					method = interfaceMap.TargetMethods[Array.IndexOf(interfaceMap.InterfaceMethods, method)];
					type = parameterType;
				}
				if (type != null && virtualCall)
				{
					if (type.IsInterface)
					{
						return (DelegateType)Delegate.CreateDelegate(typeFromHandle, method);
					}
					if (parameterType.IsInterface)
					{
						InterfaceMapping interfaceMap2 = type.GetInterfaceMap(parameterType);
						MethodInfo method2 = interfaceMap2.InterfaceMethods[Array.IndexOf(interfaceMap2.TargetMethods, method)];
						return (DelegateType)Delegate.CreateDelegate(typeFromHandle, method2);
					}
					if (!type.IsValueType)
					{
						return (DelegateType)Delegate.CreateDelegate(typeFromHandle, method.GetBaseDefinition());
					}
				}
				ParameterInfo[] parameters2 = method.GetParameters();
				int num = parameters2.Length;
				Type[] array = new Type[num + 1];
				array[0] = type;
				for (int i = 0; i < num; i++)
				{
					array[i + 1] = parameters2[i].ParameterType;
				}
				DynamicMethodDefinition val = new DynamicMethodDefinition("OpenInstanceDelegate_" + method.Name, method.ReturnType, array)
				{
					OwnerType = type
				};
				ILGenerator iLGenerator = val.GetILGenerator();
				if (type != null && type.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Ldarga_S, 0);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Ldarg_0);
				}
				for (int j = 1; j < array.Length; j++)
				{
					iLGenerator.Emit(OpCodes.Ldarg, j);
				}
				iLGenerator.Emit(OpCodes.Call, method);
				iLGenerator.Emit(OpCodes.Ret);
				return (DelegateType)val.Generate().CreateDelegate(typeFromHandle);
			}
			if (virtualCall)
			{
				return (DelegateType)Delegate.CreateDelegate(typeFromHandle, instance, method.GetBaseDefinition());
			}
			if (type != null && !type.IsInstanceOfType(instance))
			{
				Delegate.CreateDelegate(typeof(DelegateType), instance, method);
				throw new ArgumentException("Invalid delegate type");
			}
			if (IsMonoRuntime)
			{
				DynamicMethodDefinition val2 = new DynamicMethodDefinition("LdftnDelegate_" + method.Name, typeFromHandle, new Type[1] { typeof(object) })
				{
					OwnerType = typeFromHandle
				};
				ILGenerator iLGenerator2 = val2.GetILGenerator();
				iLGenerator2.Emit(OpCodes.Ldarg_0);
				iLGenerator2.Emit(OpCodes.Ldftn, method);
				iLGenerator2.Emit(OpCodes.Newobj, typeFromHandle.GetConstructor(new Type[2]
				{
					typeof(object),
					typeof(IntPtr)
				}));
				iLGenerator2.Emit(OpCodes.Ret);
				return (DelegateType)val2.Generate().Invoke(null, new object[1] { instance });
			}
			return (DelegateType)Activator.CreateInstance(typeFromHandle, instance, method.MethodHandle.GetFunctionPointer());
		}

		public static DelegateType MethodDelegate<DelegateType>(string typeColonName, object instance = null, bool virtualCall = true) where DelegateType : Delegate
		{
			return MethodDelegate<DelegateType>(DeclaredMethod(typeColonName), instance, virtualCall);
		}

		public static DelegateType HarmonyDelegate<DelegateType>(object instance = null) where DelegateType : Delegate
		{
			HarmonyMethod mergedFromType = HarmonyMethodExtensions.GetMergedFromType(typeof(DelegateType));
			MethodType? methodType = mergedFromType.methodType;
			if (!methodType.HasValue)
			{
				mergedFromType.methodType = MethodType.Normal;
			}
			return MethodDelegate<DelegateType>((mergedFromType.GetOriginalMethod() as MethodInfo) ?? throw new NullReferenceException($"Delegate {typeof(DelegateType)} has no defined original method"), instance, !mergedFromType.nonVirtualDelegate);
		}

		public static MethodBase GetOutsideCaller()
		{
			StackFrame[] frames = new StackTrace(fNeedFileInfo: true).GetFrames();
			for (int i = 0; i < frames.Length; i++)
			{
				MethodBase method = frames[i].GetMethod();
				if (method.DeclaringType?.Namespace != typeof(Harmony).Namespace)
				{
					return method;
				}
			}
			throw new Exception("Unexpected end of stack trace");
		}

		public static void RethrowException(Exception exception)
		{
			ExceptionDispatchInfo.Capture(exception).Throw();
			throw exception;
		}

		public static void ThrowMissingMemberException(Type type, params string[] names)
		{
			string text = string.Join(",", GetFieldNames(type).ToArray());
			string text2 = string.Join(",", GetPropertyNames(type).ToArray());
			throw new MissingMemberException(string.Join(",", names) + "; available fields: " + text + "; available properties: " + text2);
		}

		public static object GetDefaultValue(Type type)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.GetDefaultValue: type is null");
				return null;
			}
			if (type == typeof(void))
			{
				return null;
			}
			if (type.IsValueType)
			{
				return Activator.CreateInstance(type);
			}
			return null;
		}

		public static object CreateInstance(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			ConstructorInfo constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, new Type[0], null);
			if ((object)constructor != null)
			{
				return constructor.Invoke(null);
			}
			return FormatterServices.GetUninitializedObject(type);
		}

		public static T CreateInstance<T>()
		{
			object obj = CreateInstance(typeof(T));
			if (obj is T)
			{
				return (T)obj;
			}
			return default(T);
		}

		public static T MakeDeepCopy<T>(object source) where T : class
		{
			return MakeDeepCopy(source, typeof(T)) as T;
		}

		public static void MakeDeepCopy<T>(object source, out T result, Func<string, Traverse, Traverse, object> processor = null, string pathRoot = "")
		{
			result = (T)MakeDeepCopy(source, typeof(T), processor, pathRoot);
		}

		public static object MakeDeepCopy(object source, Type resultType, Func<string, Traverse, Traverse, object> processor = null, string pathRoot = "")
		{
			if (source == null || (object)resultType == null)
			{
				return null;
			}
			resultType = Nullable.GetUnderlyingType(resultType) ?? resultType;
			Type type = source.GetType();
			if (type.IsPrimitive)
			{
				return source;
			}
			if (type.IsEnum)
			{
				return Enum.ToObject(resultType, (int)source);
			}
			if (type.IsGenericType && resultType.IsGenericType)
			{
				addHandlerCacheLock.EnterUpgradeableReadLock();
				try
				{
					if (!addHandlerCache.TryGetValue(resultType, out var value))
					{
						MethodInfo methodInfo = FirstMethod(resultType, (MethodInfo m) => m.Name == "Add" && m.GetParameters().Length == 1);
						if ((object)methodInfo != null)
						{
							value = MethodInvoker.GetHandler(methodInfo);
						}
						addHandlerCacheLock.EnterWriteLock();
						try
						{
							addHandlerCache[resultType] = value;
						}
						finally
						{
							addHandlerCacheLock.ExitWriteLock();
						}
					}
					if (value != null)
					{
						object obj = Activator.CreateInstance(resultType);
						Type resultType2 = resultType.GetGenericArguments()[0];
						int num = 0;
						foreach (object item in source as IEnumerable)
						{
							string text = num++.ToString();
							object obj2 = MakeDeepCopy(pathRoot: (pathRoot.Length > 0) ? (pathRoot + "." + text) : text, source: item, resultType: resultType2, processor: processor);
							value(obj, obj2);
						}
						return obj;
					}
				}
				finally
				{
					addHandlerCacheLock.ExitUpgradeableReadLock();
				}
			}
			if (type.IsArray && resultType.IsArray)
			{
				Type elementType = resultType.GetElementType();
				int length = ((Array)source).Length;
				object[] array = Activator.CreateInstance(resultType, length) as object[];
				object[] array2 = source as object[];
				for (int i = 0; i < length; i++)
				{
					string text2 = i.ToString();
					string pathRoot3 = ((pathRoot.Length > 0) ? (pathRoot + "." + text2) : text2);
					array[i] = MakeDeepCopy(array2[i], elementType, processor, pathRoot3);
				}
				return array;
			}
			string @namespace = type.Namespace;
			if (@namespace == "System" || (@namespace != null && @namespace.StartsWith("System.")))
			{
				return source;
			}
			object obj3 = CreateInstance((resultType == typeof(object)) ? type : resultType);
			Traverse.IterateFields(source, obj3, delegate(string name, Traverse src, Traverse dst)
			{
				string text3 = ((pathRoot.Length > 0) ? (pathRoot + "." + name) : name);
				object source2 = ((processor != null) ? processor(text3, src, dst) : src.GetValue());
				dst.SetValue(MakeDeepCopy(source2, dst.GetValueType(), processor, text3));
			});
			return obj3;
		}

		public static bool IsStruct(Type type)
		{
			if (type == null)
			{
				return false;
			}
			if (type.IsValueType && !IsValue(type))
			{
				return !IsVoid(type);
			}
			return false;
		}

		public static bool IsClass(Type type)
		{
			if (type == null)
			{
				return false;
			}
			return !type.IsValueType;
		}

		public static bool IsValue(Type type)
		{
			if (type == null)
			{
				return false;
			}
			if (!type.IsPrimitive)
			{
				return type.IsEnum;
			}
			return true;
		}

		public static bool IsInteger(Type type)
		{
			if (type == null)
			{
				return false;
			}
			TypeCode typeCode = Type.GetTypeCode(type);
			if ((uint)(typeCode - 5) <= 7u)
			{
				return true;
			}
			return false;
		}

		public static bool IsFloatingPoint(Type type)
		{
			if (type == null)
			{
				return false;
			}
			TypeCode typeCode = Type.GetTypeCode(type);
			if ((uint)(typeCode - 13) <= 2u)
			{
				return true;
			}
			return false;
		}

		public static bool IsNumber(Type type)
		{
			if (!IsInteger(type))
			{
				return IsFloatingPoint(type);
			}
			return true;
		}

		public static bool IsVoid(Type type)
		{
			return type == typeof(void);
		}

		public static bool IsOfNullableType<T>(T instance)
		{
			return (object)Nullable.GetUnderlyingType(typeof(T)) != null;
		}

		public static bool IsStatic(MemberInfo member)
		{
			if ((object)member == null)
			{
				throw new ArgumentNullException("member");
			}
			switch (member.MemberType)
			{
			case MemberTypes.Constructor:
			case MemberTypes.Method:
				return ((MethodBase)member).IsStatic;
			case MemberTypes.Event:
				return IsStatic((EventInfo)member);
			case MemberTypes.Field:
				return ((FieldInfo)member).IsStatic;
			case MemberTypes.Property:
				return IsStatic((PropertyInfo)member);
			case MemberTypes.TypeInfo:
			case MemberTypes.NestedType:
				return IsStatic((Type)member);
			default:
				throw new ArgumentException($"Unknown member type: {member.MemberType}");
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool IsStatic(Type type)
		{
			if ((object)type == null)
			{
				return false;
			}
			if (type.IsAbstract)
			{
				return type.IsSealed;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool IsStatic(PropertyInfo propertyInfo)
		{
			if ((object)propertyInfo == null)
			{
				throw new ArgumentNullException("propertyInfo");
			}
			return propertyInfo.GetAccessors(nonPublic: true)[0].IsStatic;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool IsStatic(EventInfo eventInfo)
		{
			if ((object)eventInfo == null)
			{
				throw new ArgumentNullException("eventInfo");
			}
			return eventInfo.GetAddMethod(nonPublic: true).IsStatic;
		}

		public static int CombinedHashCode(IEnumerable<object> objects)
		{
			int num = 352654597;
			int num2 = num;
			int num3 = 0;
			foreach (object @object in objects)
			{
				if (num3 % 2 == 0)
				{
					num = ((num << 5) + num + (num >> 27)) ^ @object.GetHashCode();
				}
				else
				{
					num2 = ((num2 << 5) + num2 + (num2 >> 27)) ^ @object.GetHashCode();
				}
				num3++;
			}
			return num + num2 * 1566083941;
		}
	}
	public static class Code
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Operand_ : CodeMatch
		{
			public Operand_ this[object operand = null, string name = null] => (Operand_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Nop_ : CodeMatch
		{
			public Nop_ this[object operand = null, string name = null] => (Nop_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Break_ : CodeMatch
		{
			public Break_ this[object operand = null, string name = null] => (Break_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarg_0_ : CodeMatch
		{
			public Ldarg_0_ this[object operand = null, string name = null] => (Ldarg_0_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarg_1_ : CodeMatch
		{
			public Ldarg_1_ this[object operand = null, string name = null] => (Ldarg_1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarg_2_ : CodeMatch
		{
			public Ldarg_2_ this[object operand = null, string name = null] => (Ldarg_2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarg_3_ : CodeMatch
		{
			public Ldarg_3_ this[object operand = null, string name = null] => (Ldarg_3_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloc_0_ : CodeMatch
		{
			public Ldloc_0_ this[object operand = null, string name = null] => (Ldloc_0_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloc_1_ : CodeMatch
		{
			public Ldloc_1_ this[object operand = null, string name = null] => (Ldloc_1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloc_2_ : CodeMatch
		{
			public Ldloc_2_ this[object operand = null, string name = null] => (Ldloc_2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloc_3_ : CodeMatch
		{
			public Ldloc_3_ this[object operand = null, string name = null] => (Ldloc_3_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stloc_0_ : CodeMatch
		{
			public Stloc_0_ this[object operand = null, string name = null] => (Stloc_0_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stloc_1_ : CodeMatch
		{
			public Stloc_1_ this[object operand = null, string name = null] => (Stloc_1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stloc_2_ : CodeMatch
		{
			public Stloc_2_ this[object operand = null, string name = null] => (Stloc_2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stloc_3_ : CodeMatch
		{
			public Stloc_3_ this[object operand = null, string name = null] => (Stloc_3_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarg_S_ : CodeMatch
		{
			public Ldarg_S_ this[object operand = null, string name = null] => (Ldarg_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarga_S_ : CodeMatch
		{
			public Ldarga_S_ this[object operand = null, string name = null] => (Ldarga_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Starg_S_ : CodeMatch
		{
			public Starg_S_ this[object operand = null, string name = null] => (Starg_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloc_S_ : CodeMatch
		{
			public Ldloc_S_ this[object operand = null, string name = null] => (Ldloc_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloca_S_ : CodeMatch
		{
			public Ldloca_S_ this[object operand = null, string name = null] => (Ldloca_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stloc_S_ : CodeMatch
		{
			public Stloc_S_ this[object operand = null, string name = null] => (Stloc_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldnull_ : CodeMatch
		{
			public Ldnull_ this[object operand = null, string name = null] => (Ldnull_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_M1_ : CodeMatch
		{
			public Ldc_I4_M1_ this[object operand = null, string name = null] => (Ldc_I4_M1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_0_ : CodeMatch
		{
			public Ldc_I4_0_ this[object operand = null, string name = null] => (Ldc_I4_0_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_1_ : CodeMatch
		{
			public Ldc_I4_1_ this[object operand = null, string name = null] => (Ldc_I4_1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_2_ : CodeMatch
		{
			public Ldc_I4_2_ this[object operand = null, string name = null] => (Ldc_I4_2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_3_ : CodeMatch
		{
			public Ldc_I4_3_ this[object operand = null, string name = null] => (Ldc_I4_3_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_4_ : CodeMatch
		{
			public Ldc_I4_4_ this[object operand = null, string name = null] => (Ldc_I4_4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_5_ : CodeMatch
		{
			public Ldc_I4_5_ this[object operand = null, string name = null] => (Ldc_I4_5_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_6_ : CodeMatch
		{
			public Ldc_I4_6_ this[object operand = null, string name = null] => (Ldc_I4_6_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_7_ : CodeMatch
		{
			public Ldc_I4_7_ this[object operand = null, string name = null] => (Ldc_I4_7_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_8_ : CodeMatch
		{
			public Ldc_I4_8_ this[object operand = null, string name = null] => (Ldc_I4_8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_S_ : CodeMatch
		{
			public Ldc_I4_S_ this[object operand = null, string name = null] => (Ldc_I4_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I4_ : CodeMatch
		{
			public Ldc_I4_ this[object operand = null, string name = null] => (Ldc_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_I8_ : CodeMatch
		{
			public Ldc_I8_ this[object operand = null, string name = null] => (Ldc_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_R4_ : CodeMatch
		{
			public Ldc_R4_ this[object operand = null, string name = null] => (Ldc_R4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldc_R8_ : CodeMatch
		{
			public Ldc_R8_ this[object operand = null, string name = null] => (Ldc_R8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Dup_ : CodeMatch
		{
			public Dup_ this[object operand = null, string name = null] => (Dup_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Pop_ : CodeMatch
		{
			public Pop_ this[object operand = null, string name = null] => (Pop_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Jmp_ : CodeMatch
		{
			public Jmp_ this[object operand = null, string name = null] => (Jmp_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Call_ : CodeMatch
		{
			public Call_ this[object operand = null, string name = null] => (Call_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Calli_ : CodeMatch
		{
			public Calli_ this[object operand = null, string name = null] => (Calli_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ret_ : CodeMatch
		{
			public Ret_ this[object operand = null, string name = null] => (Ret_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Br_S_ : CodeMatch
		{
			public Br_S_ this[object operand = null, string name = null] => (Br_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Brfalse_S_ : CodeMatch
		{
			public Brfalse_S_ this[object operand = null, string name = null] => (Brfalse_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Brtrue_S_ : CodeMatch
		{
			public Brtrue_S_ this[object operand = null, string name = null] => (Brtrue_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Beq_S_ : CodeMatch
		{
			public Beq_S_ this[object operand = null, string name = null] => (Beq_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bge_S_ : CodeMatch
		{
			public Bge_S_ this[object operand = null, string name = null] => (Bge_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bgt_S_ : CodeMatch
		{
			public Bgt_S_ this[object operand = null, string name = null] => (Bgt_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ble_S_ : CodeMatch
		{
			public Ble_S_ this[object operand = null, string name = null] => (Ble_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Blt_S_ : CodeMatch
		{
			public Blt_S_ this[object operand = null, string name = null] => (Blt_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bne_Un_S_ : CodeMatch
		{
			public Bne_Un_S_ this[object operand = null, string name = null] => (Bne_Un_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bge_Un_S_ : CodeMatch
		{
			public Bge_Un_S_ this[object operand = null, string name = null] => (Bge_Un_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bgt_Un_S_ : CodeMatch
		{
			public Bgt_Un_S_ this[object operand = null, string name = null] => (Bgt_Un_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ble_Un_S_ : CodeMatch
		{
			public Ble_Un_S_ this[object operand = null, string name = null] => (Ble_Un_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Blt_Un_S_ : CodeMatch
		{
			public Blt_Un_S_ this[object operand = null, string name = null] => (Blt_Un_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Br_ : CodeMatch
		{
			public Br_ this[object operand = null, string name = null] => (Br_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Brfalse_ : CodeMatch
		{
			public Brfalse_ this[object operand = null, string name = null] => (Brfalse_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Brtrue_ : CodeMatch
		{
			public Brtrue_ this[object operand = null, string name = null] => (Brtrue_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Beq_ : CodeMatch
		{
			public Beq_ this[object operand = null, string name = null] => (Beq_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bge_ : CodeMatch
		{
			public Bge_ this[object operand = null, string name = null] => (Bge_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bgt_ : CodeMatch
		{
			public Bgt_ this[object operand = null, string name = null] => (Bgt_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ble_ : CodeMatch
		{
			public Ble_ this[object operand = null, string name = null] => (Ble_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Blt_ : CodeMatch
		{
			public Blt_ this[object operand = null, string name = null] => (Blt_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bne_Un_ : CodeMatch
		{
			public Bne_Un_ this[object operand = null, string name = null] => (Bne_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bge_Un_ : CodeMatch
		{
			public Bge_Un_ this[object operand = null, string name = null] => (Bge_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Bgt_Un_ : CodeMatch
		{
			public Bgt_Un_ this[object operand = null, string name = null] => (Bgt_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ble_Un_ : CodeMatch
		{
			public Ble_Un_ this[object operand = null, string name = null] => (Ble_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Blt_Un_ : CodeMatch
		{
			public Blt_Un_ this[object operand = null, string name = null] => (Blt_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Switch_ : CodeMatch
		{
			public Switch_ this[object operand = null, string name = null] => (Switch_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_I1_ : CodeMatch
		{
			public Ldind_I1_ this[object operand = null, string name = null] => (Ldind_I1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_U1_ : CodeMatch
		{
			public Ldind_U1_ this[object operand = null, string name = null] => (Ldind_U1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_I2_ : CodeMatch
		{
			public Ldind_I2_ this[object operand = null, string name = null] => (Ldind_I2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_U2_ : CodeMatch
		{
			public Ldind_U2_ this[object operand = null, string name = null] => (Ldind_U2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_I4_ : CodeMatch
		{
			public Ldind_I4_ this[object operand = null, string name = null] => (Ldind_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_U4_ : CodeMatch
		{
			public Ldind_U4_ this[object operand = null, string name = null] => (Ldind_U4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_I8_ : CodeMatch
		{
			public Ldind_I8_ this[object operand = null, string name = null] => (Ldind_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_I_ : CodeMatch
		{
			public Ldind_I_ this[object operand = null, string name = null] => (Ldind_I_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_R4_ : CodeMatch
		{
			public Ldind_R4_ this[object operand = null, string name = null] => (Ldind_R4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_R8_ : CodeMatch
		{
			public Ldind_R8_ this[object operand = null, string name = null] => (Ldind_R8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldind_Ref_ : CodeMatch
		{
			public Ldind_Ref_ this[object operand = null, string name = null] => (Ldind_Ref_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_Ref_ : CodeMatch
		{
			public Stind_Ref_ this[object operand = null, string name = null] => (Stind_Ref_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_I1_ : CodeMatch
		{
			public Stind_I1_ this[object operand = null, string name = null] => (Stind_I1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_I2_ : CodeMatch
		{
			public Stind_I2_ this[object operand = null, string name = null] => (Stind_I2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_I4_ : CodeMatch
		{
			public Stind_I4_ this[object operand = null, string name = null] => (Stind_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_I8_ : CodeMatch
		{
			public Stind_I8_ this[object operand = null, string name = null] => (Stind_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_R4_ : CodeMatch
		{
			public Stind_R4_ this[object operand = null, string name = null] => (Stind_R4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_R8_ : CodeMatch
		{
			public Stind_R8_ this[object operand = null, string name = null] => (Stind_R8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Add_ : CodeMatch
		{
			public Add_ this[object operand = null, string name = null] => (Add_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Sub_ : CodeMatch
		{
			public Sub_ this[object operand = null, string name = null] => (Sub_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Mul_ : CodeMatch
		{
			public Mul_ this[object operand = null, string name = null] => (Mul_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Div_ : CodeMatch
		{
			public Div_ this[object operand = null, string name = null] => (Div_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Div_Un_ : CodeMatch
		{
			public Div_Un_ this[object operand = null, string name = null] => (Div_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Rem_ : CodeMatch
		{
			public Rem_ this[object operand = null, string name = null] => (Rem_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Rem_Un_ : CodeMatch
		{
			public Rem_Un_ this[object operand = null, string name = null] => (Rem_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class And_ : CodeMatch
		{
			public And_ this[object operand = null, string name = null] => (And_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Or_ : CodeMatch
		{
			public Or_ this[object operand = null, string name = null] => (Or_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Xor_ : CodeMatch
		{
			public Xor_ this[object operand = null, string name = null] => (Xor_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Shl_ : CodeMatch
		{
			public Shl_ this[object operand = null, string name = null] => (Shl_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Shr_ : CodeMatch
		{
			public Shr_ this[object operand = null, string name = null] => (Shr_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Shr_Un_ : CodeMatch
		{
			public Shr_Un_ this[object operand = null, string name = null] => (Shr_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Neg_ : CodeMatch
		{
			public Neg_ this[object operand = null, string name = null] => (Neg_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Not_ : CodeMatch
		{
			public Not_ this[object operand = null, string name = null] => (Not_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_I1_ : CodeMatch
		{
			public Conv_I1_ this[object operand = null, string name = null] => (Conv_I1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_I2_ : CodeMatch
		{
			public Conv_I2_ this[object operand = null, string name = null] => (Conv_I2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_I4_ : CodeMatch
		{
			public Conv_I4_ this[object operand = null, string name = null] => (Conv_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_I8_ : CodeMatch
		{
			public Conv_I8_ this[object operand = null, string name = null] => (Conv_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_R4_ : CodeMatch
		{
			public Conv_R4_ this[object operand = null, string name = null] => (Conv_R4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_R8_ : CodeMatch
		{
			public Conv_R8_ this[object operand = null, string name = null] => (Conv_R8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_U4_ : CodeMatch
		{
			public Conv_U4_ this[object operand = null, string name = null] => (Conv_U4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_U8_ : CodeMatch
		{
			public Conv_U8_ this[object operand = null, string name = null] => (Conv_U8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Callvirt_ : CodeMatch
		{
			public Callvirt_ this[object operand = null, string name = null] => (Callvirt_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Cpobj_ : CodeMatch
		{
			public Cpobj_ this[object operand = null, string name = null] => (Cpobj_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldobj_ : CodeMatch
		{
			public Ldobj_ this[object operand = null, string name = null] => (Ldobj_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldstr_ : CodeMatch
		{
			public Ldstr_ this[object operand = null, string name = null] => (Ldstr_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Newobj_ : CodeMatch
		{
			public Newobj_ this[object operand = null, string name = null] => (Newobj_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Castclass_ : CodeMatch
		{
			public Castclass_ this[object operand = null, string name = null] => (Castclass_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Isinst_ : CodeMatch
		{
			public Isinst_ this[object operand = null, string name = null] => (Isinst_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_R_Un_ : CodeMatch
		{
			public Conv_R_Un_ this[object operand = null, string name = null] => (Conv_R_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Unbox_ : CodeMatch
		{
			public Unbox_ this[object operand = null, string name = null] => (Unbox_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Throw_ : CodeMatch
		{
			public Throw_ this[object operand = null, string name = null] => (Throw_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldfld_ : CodeMatch
		{
			public Ldfld_ this[object operand = null, string name = null] => (Ldfld_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldflda_ : CodeMatch
		{
			public Ldflda_ this[object operand = null, string name = null] => (Ldflda_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stfld_ : CodeMatch
		{
			public Stfld_ this[object operand = null, string name = null] => (Stfld_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldsfld_ : CodeMatch
		{
			public Ldsfld_ this[object operand = null, string name = null] => (Ldsfld_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldsflda_ : CodeMatch
		{
			public Ldsflda_ this[object operand = null, string name = null] => (Ldsflda_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stsfld_ : CodeMatch
		{
			public Stsfld_ this[object operand = null, string name = null] => (Stsfld_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stobj_ : CodeMatch
		{
			public Stobj_ this[object operand = null, string name = null] => (Stobj_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I1_Un_ : CodeMatch
		{
			public Conv_Ovf_I1_Un_ this[object operand = null, string name = null] => (Conv_Ovf_I1_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I2_Un_ : CodeMatch
		{
			public Conv_Ovf_I2_Un_ this[object operand = null, string name = null] => (Conv_Ovf_I2_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I4_Un_ : CodeMatch
		{
			public Conv_Ovf_I4_Un_ this[object operand = null, string name = null] => (Conv_Ovf_I4_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I8_Un_ : CodeMatch
		{
			public Conv_Ovf_I8_Un_ this[object operand = null, string name = null] => (Conv_Ovf_I8_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U1_Un_ : CodeMatch
		{
			public Conv_Ovf_U1_Un_ this[object operand = null, string name = null] => (Conv_Ovf_U1_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U2_Un_ : CodeMatch
		{
			public Conv_Ovf_U2_Un_ this[object operand = null, string name = null] => (Conv_Ovf_U2_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U4_Un_ : CodeMatch
		{
			public Conv_Ovf_U4_Un_ this[object operand = null, string name = null] => (Conv_Ovf_U4_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U8_Un_ : CodeMatch
		{
			public Conv_Ovf_U8_Un_ this[object operand = null, string name = null] => (Conv_Ovf_U8_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I_Un_ : CodeMatch
		{
			public Conv_Ovf_I_Un_ this[object operand = null, string name = null] => (Conv_Ovf_I_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U_Un_ : CodeMatch
		{
			public Conv_Ovf_U_Un_ this[object operand = null, string name = null] => (Conv_Ovf_U_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Box_ : CodeMatch
		{
			public Box_ this[object operand = null, string name = null] => (Box_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Newarr_ : CodeMatch
		{
			public Newarr_ this[object operand = null, string name = null] => (Newarr_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldlen_ : CodeMatch
		{
			public Ldlen_ this[object operand = null, string name = null] => (Ldlen_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelema_ : CodeMatch
		{
			public Ldelema_ this[object operand = null, string name = null] => (Ldelema_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_I1_ : CodeMatch
		{
			public Ldelem_I1_ this[object operand = null, string name = null] => (Ldelem_I1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_U1_ : CodeMatch
		{
			public Ldelem_U1_ this[object operand = null, string name = null] => (Ldelem_U1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_I2_ : CodeMatch
		{
			public Ldelem_I2_ this[object operand = null, string name = null] => (Ldelem_I2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_U2_ : CodeMatch
		{
			public Ldelem_U2_ this[object operand = null, string name = null] => (Ldelem_U2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_I4_ : CodeMatch
		{
			public Ldelem_I4_ this[object operand = null, string name = null] => (Ldelem_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_U4_ : CodeMatch
		{
			public Ldelem_U4_ this[object operand = null, string name = null] => (Ldelem_U4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_I8_ : CodeMatch
		{
			public Ldelem_I8_ this[object operand = null, string name = null] => (Ldelem_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_I_ : CodeMatch
		{
			public Ldelem_I_ this[object operand = null, string name = null] => (Ldelem_I_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_R4_ : CodeMatch
		{
			public Ldelem_R4_ this[object operand = null, string name = null] => (Ldelem_R4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_R8_ : CodeMatch
		{
			public Ldelem_R8_ this[object operand = null, string name = null] => (Ldelem_R8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_Ref_ : CodeMatch
		{
			public Ldelem_Ref_ this[object operand = null, string name = null] => (Ldelem_Ref_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_I_ : CodeMatch
		{
			public Stelem_I_ this[object operand = null, string name = null] => (Stelem_I_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_I1_ : CodeMatch
		{
			public Stelem_I1_ this[object operand = null, string name = null] => (Stelem_I1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_I2_ : CodeMatch
		{
			public Stelem_I2_ this[object operand = null, string name = null] => (Stelem_I2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_I4_ : CodeMatch
		{
			public Stelem_I4_ this[object operand = null, string name = null] => (Stelem_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_I8_ : CodeMatch
		{
			public Stelem_I8_ this[object operand = null, string name = null] => (Stelem_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_R4_ : CodeMatch
		{
			public Stelem_R4_ this[object operand = null, string name = null] => (Stelem_R4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_R8_ : CodeMatch
		{
			public Stelem_R8_ this[object operand = null, string name = null] => (Stelem_R8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_Ref_ : CodeMatch
		{
			public Stelem_Ref_ this[object operand = null, string name = null] => (Stelem_Ref_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldelem_ : CodeMatch
		{
			public Ldelem_ this[object operand = null, string name = null] => (Ldelem_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stelem_ : CodeMatch
		{
			public Stelem_ this[object operand = null, string name = null] => (Stelem_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Unbox_Any_ : CodeMatch
		{
			public Unbox_Any_ this[object operand = null, string name = null] => (Unbox_Any_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I1_ : CodeMatch
		{
			public Conv_Ovf_I1_ this[object operand = null, string name = null] => (Conv_Ovf_I1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U1_ : CodeMatch
		{
			public Conv_Ovf_U1_ this[object operand = null, string name = null] => (Conv_Ovf_U1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I2_ : CodeMatch
		{
			public Conv_Ovf_I2_ this[object operand = null, string name = null] => (Conv_Ovf_I2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U2_ : CodeMatch
		{
			public Conv_Ovf_U2_ this[object operand = null, string name = null] => (Conv_Ovf_U2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I4_ : CodeMatch
		{
			public Conv_Ovf_I4_ this[object operand = null, string name = null] => (Conv_Ovf_I4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U4_ : CodeMatch
		{
			public Conv_Ovf_U4_ this[object operand = null, string name = null] => (Conv_Ovf_U4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I8_ : CodeMatch
		{
			public Conv_Ovf_I8_ this[object operand = null, string name = null] => (Conv_Ovf_I8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U8_ : CodeMatch
		{
			public Conv_Ovf_U8_ this[object operand = null, string name = null] => (Conv_Ovf_U8_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Refanyval_ : CodeMatch
		{
			public Refanyval_ this[object operand = null, string name = null] => (Refanyval_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ckfinite_ : CodeMatch
		{
			public Ckfinite_ this[object operand = null, string name = null] => (Ckfinite_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Mkrefany_ : CodeMatch
		{
			public Mkrefany_ this[object operand = null, string name = null] => (Mkrefany_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldtoken_ : CodeMatch
		{
			public Ldtoken_ this[object operand = null, string name = null] => (Ldtoken_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_U2_ : CodeMatch
		{
			public Conv_U2_ this[object operand = null, string name = null] => (Conv_U2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_U1_ : CodeMatch
		{
			public Conv_U1_ this[object operand = null, string name = null] => (Conv_U1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_I_ : CodeMatch
		{
			public Conv_I_ this[object operand = null, string name = null] => (Conv_I_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_I_ : CodeMatch
		{
			public Conv_Ovf_I_ this[object operand = null, string name = null] => (Conv_Ovf_I_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_Ovf_U_ : CodeMatch
		{
			public Conv_Ovf_U_ this[object operand = null, string name = null] => (Conv_Ovf_U_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Add_Ovf_ : CodeMatch
		{
			public Add_Ovf_ this[object operand = null, string name = null] => (Add_Ovf_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Add_Ovf_Un_ : CodeMatch
		{
			public Add_Ovf_Un_ this[object operand = null, string name = null] => (Add_Ovf_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Mul_Ovf_ : CodeMatch
		{
			public Mul_Ovf_ this[object operand = null, string name = null] => (Mul_Ovf_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Mul_Ovf_Un_ : CodeMatch
		{
			public Mul_Ovf_Un_ this[object operand = null, string name = null] => (Mul_Ovf_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Sub_Ovf_ : CodeMatch
		{
			public Sub_Ovf_ this[object operand = null, string name = null] => (Sub_Ovf_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Sub_Ovf_Un_ : CodeMatch
		{
			public Sub_Ovf_Un_ this[object operand = null, string name = null] => (Sub_Ovf_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Endfinally_ : CodeMatch
		{
			public Endfinally_ this[object operand = null, string name = null] => (Endfinally_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Leave_ : CodeMatch
		{
			public Leave_ this[object operand = null, string name = null] => (Leave_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Leave_S_ : CodeMatch
		{
			public Leave_S_ this[object operand = null, string name = null] => (Leave_S_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stind_I_ : CodeMatch
		{
			public Stind_I_ this[object operand = null, string name = null] => (Stind_I_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Conv_U_ : CodeMatch
		{
			public Conv_U_ this[object operand = null, string name = null] => (Conv_U_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix7_ : CodeMatch
		{
			public Prefix7_ this[object operand = null, string name = null] => (Prefix7_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix6_ : CodeMatch
		{
			public Prefix6_ this[object operand = null, string name = null] => (Prefix6_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix5_ : CodeMatch
		{
			public Prefix5_ this[object operand = null, string name = null] => (Prefix5_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix4_ : CodeMatch
		{
			public Prefix4_ this[object operand = null, string name = null] => (Prefix4_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix3_ : CodeMatch
		{
			public Prefix3_ this[object operand = null, string name = null] => (Prefix3_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix2_ : CodeMatch
		{
			public Prefix2_ this[object operand = null, string name = null] => (Prefix2_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefix1_ : CodeMatch
		{
			public Prefix1_ this[object operand = null, string name = null] => (Prefix1_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Prefixref_ : CodeMatch
		{
			public Prefixref_ this[object operand = null, string name = null] => (Prefixref_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Arglist_ : CodeMatch
		{
			public Arglist_ this[object operand = null, string name = null] => (Arglist_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ceq_ : CodeMatch
		{
			public Ceq_ this[object operand = null, string name = null] => (Ceq_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Cgt_ : CodeMatch
		{
			public Cgt_ this[object operand = null, string name = null] => (Cgt_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Cgt_Un_ : CodeMatch
		{
			public Cgt_Un_ this[object operand = null, string name = null] => (Cgt_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Clt_ : CodeMatch
		{
			public Clt_ this[object operand = null, string name = null] => (Clt_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Clt_Un_ : CodeMatch
		{
			public Clt_Un_ this[object operand = null, string name = null] => (Clt_Un_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldftn_ : CodeMatch
		{
			public Ldftn_ this[object operand = null, string name = null] => (Ldftn_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldvirtftn_ : CodeMatch
		{
			public Ldvirtftn_ this[object operand = null, string name = null] => (Ldvirtftn_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarg_ : CodeMatch
		{
			public Ldarg_ this[object operand = null, string name = null] => (Ldarg_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldarga_ : CodeMatch
		{
			public Ldarga_ this[object operand = null, string name = null] => (Ldarga_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Starg_ : CodeMatch
		{
			public Starg_ this[object operand = null, string name = null] => (Starg_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloc_ : CodeMatch
		{
			public Ldloc_ this[object operand = null, string name = null] => (Ldloc_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Ldloca_ : CodeMatch
		{
			public Ldloca_ this[object operand = null, string name = null] => (Ldloca_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Stloc_ : CodeMatch
		{
			public Stloc_ this[object operand = null, string name = null] => (Stloc_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Localloc_ : CodeMatch
		{
			public Localloc_ this[object operand = null, string name = null] => (Localloc_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Endfilter_ : CodeMatch
		{
			public Endfilter_ this[object operand = null, string name = null] => (Endfilter_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Unaligned_ : CodeMatch
		{
			public Unaligned_ this[object operand = null, string name = null] => (Unaligned_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Volatile_ : CodeMatch
		{
			public Volatile_ this[object operand = null, string name = null] => (Volatile_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Tailcall_ : CodeMatch
		{
			public Tailcall_ this[object operand = null, string name = null] => (Tailcall_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Initobj_ : CodeMatch
		{
			public Initobj_ this[object operand = null, string name = null] => (Initobj_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Constrained_ : CodeMatch
		{
			public Constrained_ this[object operand = null, string name = null] => (Constrained_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Cpblk_ : CodeMatch
		{
			public Cpblk_ this[object operand = null, string name = null] => (Cpblk_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Initblk_ : CodeMatch
		{
			public Initblk_ this[object operand = null, string name = null] => (Initblk_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Rethrow_ : CodeMatch
		{
			public Rethrow_ this[object operand = null, string name = null] => (Rethrow_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Sizeof_ : CodeMatch
		{
			public Sizeof_ this[object operand = null, string name = null] => (Sizeof_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Refanytype_ : CodeMatch
		{
			public Refanytype_ this[object operand = null, string name = null] => (Refanytype_)Set(operand, name);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public class Readonly_ : CodeMatch
		{
			public Readonly_ this[object operand = null, string name = null] => (Readonly_)Set(operand, name);
		}

		public static Operand_ Operand => new Operand_();

		public static Nop_ Nop => new Nop_
		{
			opcode = OpCodes.Nop
		};

		public static Break_ Break => new Break_
		{
			opcode = OpCodes.Break
		};

		public static Ldarg_0_ Ldarg_0 => new Ldarg_0_
		{
			opcode = OpCodes.Ldarg_0
		};

		public static Ldarg_1_ Ldarg_1 => new Ldarg_1_
		{
			opcode = OpCodes.Ldarg_1
		};

		public static Ldarg_2_ Ldarg_2 => new Ldarg_2_
		{
			opcode = OpCodes.Ldarg_2
		};

		public static Ldarg_3_ Ldarg_3 => new Ldarg_3_
		{
			opcode = OpCodes.Ldarg_3
		};

		public static Ldloc_0_ Ldloc_0 => new Ldloc_0_
		{
			opcode = OpCodes.Ldloc_0
		};

		public static Ldloc_1_ Ldloc_1 => new Ldloc_1_
		{
			opcode = OpCodes.Ldloc_1
		};

		public static Ldloc_2_ Ldloc_2 => new Ldloc_2_
		{
			opcode = OpCodes.Ldloc_2
		};

		public static Ldloc_3_ Ldloc_3 => new Ldloc_3_
		{
			opcode = OpCodes.Ldloc_3
		};

		public static Stloc_0_ Stloc_0 => new Stloc_0_
		{
			opcode = OpCodes.Stloc_0
		};

		public static Stloc_1_ Stloc_1 => new Stloc_1_
		{
			opcode = OpCodes.Stloc_1
		};

		public static Stloc_2_ Stloc_2 => new Stloc_2_
		{
			opcode = OpCodes.Stloc_2
		};

		public static Stloc_3_ Stloc_3 => new Stloc_3_
		{
			opcode = OpCodes.Stloc_3
		};

		public static Ldarg_S_ Ldarg_S => new Ldarg_S_
		{
			opcode = OpCodes.Ldarg_S
		};

		public static Ldarga_S_ Ldarga_S => new Ldarga_S_
		{
			opcode = OpCodes.Ldarga_S
		};

		public static Starg_S_ Starg_S => new Starg_S_
		{
			opcode = OpCodes.Starg_S
		};

		public static Ldloc_S_ Ldloc_S => new Ldloc_S_
		{
			opcode = OpCodes.Ldloc_S
		};

		public static Ldloca_S_ Ldloca_S => new Ldloca_S_
		{
			opcode = OpCodes.Ldloca_S
		};

		public static Stloc_S_ Stloc_S => new Stloc_S_
		{
			opcode = OpCodes.Stloc_S
		};

		public static Ldnull_ Ldnull => new Ldnull_
		{
			opcode = OpCodes.Ldnull
		};

		public static Ldc_I4_M1_ Ldc_I4_M1 => new Ldc_I4_M1_
		{
			opcode = OpCodes.Ldc_I4_M1
		};

		public static Ldc_I4_0_ Ldc_I4_0 => new Ldc_I4_0_
		{
			opcode = OpCodes.Ldc_I4_0
		};

		public static Ldc_I4_1_ Ldc_I4_1 => new Ldc_I4_1_
		{
			opcode = OpCodes.Ldc_I4_1
		};

		public static Ldc_I4_2_ Ldc_I4_2 => new Ldc_I4_2_
		{
			opcode = OpCodes.Ldc_I4_2
		};

		public static Ldc_I4_3_ Ldc_I4_3 => new Ldc_I4_3_
		{
			opcode = OpCodes.Ldc_I4_3
		};

		public static Ldc_I4_4_ Ldc_I4_4 => new Ldc_I4_4_
		{
			opcode = OpCodes.Ldc_I4_4
		};

		public static Ldc_I4_5_ Ldc_I4_5 => new Ldc_I4_5_
		{
			opcode = OpCodes.Ldc_I4_5
		};

		public static Ldc_I4_6_ Ldc_I4_6 => new Ldc_I4_6_
		{
			opcode = OpCodes.Ldc_I4_6
		};

		public static Ldc_I4_7_ Ldc_I4_7 => new Ldc_I4_7_
		{
			opcode = OpCodes.Ldc_I4_7
		};

		public static Ldc_I4_8_ Ldc_I4_8 => new Ldc_I4_8_
		{
			opcode = OpCodes.Ldc_I4_8
		};

		public static Ldc_I4_S_ Ldc_I4_S => new Ldc_I4_S_
		{
			opcode = OpCodes.Ldc_I4_S
		};

		public static Ldc_I4_ Ldc_I4 => new Ldc_I4_
		{
			opcode = OpCodes.Ldc_I4
		};

		public static Ldc_I8_ Ldc_I8 => new Ldc_I8_
		{
			opcode = OpCodes.Ldc_I8
		};

		public static Ldc_R4_ Ldc_R4 => new Ldc_R4_
		{
			opcode = OpCodes.Ldc_R4
		};

		public static Ldc_R8_ Ldc_R8 => new Ldc_R8_
		{
			opcode = OpCodes.Ldc_R8
		};

		public static Dup_ Dup => new Dup_
		{
			opcode = OpCodes.Dup
		};

		public static Pop_ Pop => new Pop_
		{
			opcode = OpCodes.Pop
		};

		public static Jmp_ Jmp => new Jmp_
		{
			opcode = OpCodes.Jmp
		};

		public static Call_ Call => new Call_
		{
			opcode = OpCodes.Call
		};

		public static Calli_ Calli => new Calli_
		{
			opcode = OpCodes.Calli
		};

		public static Ret_ Ret => new Ret_
		{
			opcode = OpCodes.Ret
		};

		public static Br_S_ Br_S => new Br_S_
		{
			opcode = OpCodes.Br_S
		};

		public static Brfalse_S_ Brfalse_S => new Brfalse_S_
		{
			opcode = OpCodes.Brfalse_S
		};

		public static Brtrue_S_ Brtrue_S => new Brtrue_S_
		{
			opcode = OpCodes.Brtrue_S
		};

		public static Beq_S_ Beq_S => new Beq_S_
		{
			opcode = OpCodes.Beq_S
		};

		public static Bge_S_ Bge_S => new Bge_S_
		{
			opcode = OpCodes.Bge_S
		};

		public static Bgt_S_ Bgt_S => new Bgt_S_
		{
			opcode = OpCodes.Bgt_S
		};

		public static Ble_S_ Ble_S => new Ble_S_
		{
			opcode = OpCodes.Ble_S
		};

		public static Blt_S_ Blt_S => new Blt_S_
		{
			opcode = OpCodes.Blt_S
		};

		public static Bne_Un_S_ Bne_Un_S => new Bne_Un_S_
		{
			opcode = OpCodes.Bne_Un_S
		};

		public static Bge_Un_S_ Bge_Un_S => new Bge_Un_S_
		{
			opcode = OpCodes.Bge_Un_S
		};

		public static Bgt_Un_S_ Bgt_Un_S => new Bgt_Un_S_
		{
			opcode = OpCodes.Bgt_Un_S
		};

		public static Ble_Un_S_ Ble_Un_S => new Ble_Un_S_
		{
			opcode = OpCodes.Ble_Un_S
		};

		public static Blt_Un_S_ Blt_Un_S => new Blt_Un_S_
		{
			opcode = OpCodes.Blt_Un_S
		};

		public static Br_ Br => new Br_
		{
			opcode = OpCodes.Br
		};

		public static Brfalse_ Brfalse => new Brfalse_
		{
			opcode = OpCodes.Brfalse
		};

		public static Brtrue_ Brtrue => new Brtrue_
		{
			opcode = OpCodes.Brtrue
		};

		public static Beq_ Beq => new Beq_
		{
			opcode = OpCodes.Beq
		};

		public static Bge_ Bge => new Bge_
		{
			opcode = OpCodes.Bge
		};

		public static Bgt_ Bgt => new Bgt_
		{
			opcode = OpCodes.Bgt
		};

		public static Ble_ Ble => new Ble_
		{
			opcode = OpCodes.Ble
		};

		public static Blt_ Blt => new Blt_
		{
			opcode = OpCodes.Blt
		};

		public static Bne_Un_ Bne_Un => new Bne_Un_
		{
			opcode = OpCodes.Bne_Un
		};

		public static Bge_Un_ Bge_Un => new Bge_Un_
		{
			opcode = OpCodes.Bge_Un
		};

		public static Bgt_Un_ Bgt_Un => new Bgt_Un_
		{
			opcode = OpCodes.Bgt_Un
		};

		public static Ble_Un_ Ble_Un => new Ble_Un_
		{
			opcode = OpCodes.Ble_Un
		};

		public static Blt_Un_ Blt_Un => new Blt_Un_
		{
			opcode = OpCodes.Blt_Un
		};

		public static Switch_ Switch => new Switch_
		{
			opcode = OpCodes.Switch
		};

		public static Ldind_I1_ Ldind_I1 => new Ldind_I1_
		{
			opcode = OpCodes.Ldind_I1
		};

		public static Ldind_U1_ Ldind_U1 => new Ldind_U1_
		{
			opcode = OpCodes.Ldind_U1
		};

		public static Ldind_I2_ Ldind_I2 => new Ldind_I2_
		{
			opcode = OpCodes.Ldind_I2
		};

		public static Ldind_U2_ Ldind_U2 => new Ldind_U2_
		{
			opcode = OpCodes.Ldind_U2
		};

		public static Ldind_I4_ Ldind_I4 => new Ldind_I4_
		{
			opcode = OpCodes.Ldind_I4
		};

		public static Ldind_U4_ Ldind_U4 => new Ldind_U4_
		{
			opcode = OpCodes.Ldind_U4
		};

		public static Ldind_I8_ Ldind_I8 => new Ldind_I8_
		{
			opcode = OpCodes.Ldind_I8
		};

		public static Ldind_I_ Ldind_I => new Ldind_I_
		{
			opcode = OpCodes.Ldind_I
		};

		public static Ldind_R4_ Ldind_R4 => new Ldind_R4_
		{
			opcode = OpCodes.Ldind_R4
		};

		public static Ldind_R8_ Ldind_R8 => new Ldind_R8_
		{
			opcode = OpCodes.Ldind_R8
		};

		public static Ldind_Ref_ Ldind_Ref => new Ldind_Ref_
		{
			opcode = OpCodes.Ldind_Ref
		};

		public static Stind_Ref_ Stind_Ref => new Stind_Ref_
		{
			opcode = OpCodes.Stind_Ref
		};

		public static Stind_I1_ Stind_I1 => new Stind_I1_
		{
			opcode = OpCodes.Stind_I1
		};

		public static Stind_I2_ Stind_I2 => new Stind_I2_
		{
			opcode = OpCodes.Stind_I2
		};

		public static Stind_I4_ Stind_I4 => new Stind_I4_
		{
			opcode = OpCodes.Stind_I4
		};

		public static Stind_I8_ Stind_I8 => new Stind_I8_
		{
			opcode = OpCodes.Stind_I8
		};

		public static Stind_R4_ Stind_R4 => new Stind_R4_
		{
			opcode = OpCodes.Stind_R4
		};

		public static Stind_R8_ Stind_R8 => new Stind_R8_
		{
			opcode = OpCodes.Stind_R8
		};

		public static Add_ Add => new Add_
		{
			opcode = OpCodes.Add
		};

		public static Sub_ Sub => new Sub_
		{
			opcode = OpCodes.Sub
		};

		public static Mul_ Mul => new Mul_
		{
			opcode = OpCodes.Mul
		};

		public static Div_ Div => new Div_
		{
			opcode = OpCodes.Div
		};

		public static Div_Un_ Div_Un => new Div_Un_
		{
			opcode = OpCodes.Div_Un
		};

		public static Rem_ Rem => new Rem_
		{
			opcode = OpCodes.Rem
		};

		public static Rem_Un_ Rem_Un => new Rem_Un_
		{
			opcode = OpCodes.Rem_Un
		};

		public static And_ And => new And_
		{
			opcode = OpCodes.And
		};

		public static Or_ Or => new Or_
		{
			opcode = OpCodes.Or
		};

		public static Xor_ Xor => new Xor_
		{
			opcode = OpCodes.Xor
		};

		public static Shl_ Shl => new Shl_
		{
			opcode = OpCodes.Shl
		};

		public static Shr_ Shr => new Shr_
		{
			opcode = OpCodes.Shr
		};

		public static Shr_Un_ Shr_Un => new Shr_Un_
		{
			opcode = OpCodes.Shr_Un
		};

		public static Neg_ Neg => new Neg_
		{
			opcode = OpCodes.Neg
		};

		public static Not_ Not => new Not_
		{
			opcode = OpCodes.Not
		};

		public static Conv_I1_ Conv_I1 => new Conv_I1_
		{
			opcode = OpCodes.Conv_I1
		};

		public static Conv_I2_ Conv_I2 => new Conv_I2_
		{
			opcode = OpCodes.Conv_I2
		};

		public static Conv_I4_ Conv_I4 => new Conv_I4_
		{
			opcode = OpCodes.Conv_I4
		};

		public static Conv_I8_ Conv_I8 => new Conv_I8_
		{
			opcode = OpCodes.Conv_I8
		};

		public static Conv_R4_ Conv_R4 => new Conv_R4_
		{
			opcode = OpCodes.Conv_R4
		};

		public static Conv_R8_ Conv_R8 => new Conv_R8_
		{
			opcode = OpCodes.Conv_R8
		};

		public static Conv_U4_ Conv_U4 => new Conv_U4_
		{
			opcode = OpCodes.Conv_U4
		};

		public static Conv_U8_ Conv_U8 => new Conv_U8_
		{
			opcode = OpCodes.Conv_U8
		};

		public static Callvirt_ Callvirt => new Callvirt_
		{
			opcode = OpCodes.Callvirt
		};

		public static Cpobj_ Cpobj => new Cpobj_
		{
			opcode = OpCodes.Cpobj
		};

		public static Ldobj_ Ldobj => new Ldobj_
		{
			opcode = OpCodes.Ldobj
		};

		public static Ldstr_ Ldstr => new Ldstr_
		{
			opcode = OpCodes.Ldstr
		};

		public static Newobj_ Newobj => new Newobj_
		{
			opcode = OpCodes.Newobj
		};

		public static Castclass_ Castclass => new Castclass_
		{
			opcode = OpCodes.Castclass
		};

		public static Isinst_ Isinst => new Isinst_
		{
			opcode = OpCodes.Isinst
		};

		public static Conv_R_Un_ Conv_R_Un => new Conv_R_Un_
		{
			opcode = OpCodes.Conv_R_Un
		};

		public static Unbox_ Unbox => new Unbox_
		{
			opcode = OpCodes.Unbox
		};

		public static Throw_ Throw => new Throw_
		{
			opcode = OpCodes.Throw
		};

		public static Ldfld_ Ldfld => new Ldfld_
		{
			opcode = OpCodes.Ldfld
		};

		public static Ldflda_ Ldflda => new Ldflda_
		{
			opcode = OpCodes.Ldflda
		};

		public static Stfld_ Stfld => new Stfld_
		{
			opcode = OpCodes.Stfld
		};

		public static Ldsfld_ Ldsfld => new Ldsfld_
		{
			opcode = OpCodes.Ldsfld
		};

		public static Ldsflda_ Ldsflda => new Ldsflda_
		{
			opcode = OpCodes.Ldsflda
		};

		public static Stsfld_ Stsfld => new Stsfld_
		{
			opcode = OpCodes.Stsfld
		};

		public static Stobj_ Stobj => new Stobj_
		{
			opcode = OpCodes.Stobj
		};

		public static Conv_Ovf_I1_Un_ Conv_Ovf_I1_Un => new Conv_Ovf_I1_Un_
		{
			opcode = OpCodes.Conv_Ovf_I1_Un
		};

		public static Conv_Ovf_I2_Un_ Conv_Ovf_I2_Un => new Conv_Ovf_I2_Un_
		{
			opcode = OpCodes.Conv_Ovf_I2_Un
		};

		public static Conv_Ovf_I4_Un_ Conv_Ovf_I4_Un => new Conv_Ovf_I4_Un_
		{
			opcode = OpCodes.Conv_Ovf_I4_Un
		};

		public static Conv_Ovf_I8_Un_ Conv_Ovf_I8_Un => new Conv_Ovf_I8_Un_
		{
			opcode = OpCodes.Conv_Ovf_I8_Un
		};

		public static Conv_Ovf_U1_Un_ Conv_Ovf_U1_Un => new Conv_Ovf_U1_Un_
		{
			opcode = OpCodes.Conv_Ovf_U1_Un
		};

		public static Conv_Ovf_U2_Un_ Conv_Ovf_U2_Un => new Conv_Ovf_U2_Un_
		{
			opcode = OpCodes.Conv_Ovf_U2_Un
		};

		public static Conv_Ovf_U4_Un_ Conv_Ovf_U4_Un => new Conv_Ovf_U4_Un_
		{
			opcode = OpCodes.Conv_Ovf_U4_Un
		};

		public static Conv_Ovf_U8_Un_ Conv_Ovf_U8_Un => new Conv_Ovf_U8_Un_
		{
			opcode = OpCodes.Conv_Ovf_U8_Un
		};

		public static Conv_Ovf_I_Un_ Conv_Ovf_I_Un => new Conv_Ovf_I_Un_
		{
			opcode = OpCodes.Conv_Ovf_I_Un
		};

		public static Conv_Ovf_U_Un_ Conv_Ovf_U_Un => new Conv_Ovf_U_Un_
		{
			opcode = OpCodes.Conv_Ovf_U_Un
		};

		public static Box_ Box => new Box_
		{
			opcode = OpCodes.Box
		};

		public static Newarr_ Newarr => new Newarr_
		{
			opcode = OpCodes.Newarr
		};

		public static Ldlen_ Ldlen => new Ldlen_
		{
			opcode = OpCodes.Ldlen
		};

		public static Ldelema_ Ldelema => new Ldelema_
		{
			opcode = OpCodes.Ldelema
		};

		public static Ldelem_I1_ Ldelem_I1 => new Ldelem_I1_
		{
			opcode = OpCodes.Ldelem_I1
		};

		public static Ldelem_U1_ Ldelem_U1 => new Ldelem_U1_
		{
			opcode = OpCodes.Ldelem_U1
		};

		public static Ldelem_I2_ Ldelem_I2 => new Ldelem_I2_
		{
			opcode = OpCodes.Ldelem_I2
		};

		public static Ldelem_U2_ Ldelem_U2 => new Ldelem_U2_
		{
			opcode = OpCodes.Ldelem_U2
		};

		public static Ldelem_I4_ Ldelem_I4 => new Ldelem_I4_
		{
			opcode = OpCodes.Ldelem_I4
		};

		public static Ldelem_U4_ Ldelem_U4 => new Ldelem_U4_
		{
			opcode = OpCodes.Ldelem_U4
		};

		public static Ldelem_I8_ Ldelem_I8 => new Ldelem_I8_
		{
			opcode = OpCodes.Ldelem_I8
		};

		public static Ldelem_I_ Ldelem_I => new Ldelem_I_
		{
			opcode = OpCodes.Ldelem_I
		};

		public static Ldelem_R4_ Ldelem_R4 => new Ldelem_R4_
		{
			opcode = OpCodes.Ldelem_R4
		};

		public static Ldelem_R8_ Ldelem_R8 => new Ldelem_R8_
		{
			opcode = OpCodes.Ldelem_R8
		};

		public static Ldelem_Ref_ Ldelem_Ref => new Ldelem_Ref_
		{
			opcode = OpCodes.Ldelem_Ref
		};

		public static Stelem_I_ Stelem_I => new Stelem_I_
		{
			opcode = OpCodes.Stelem_I
		};

		public static Stelem_I1_ Stelem_I1 => new Stelem_I1_
		{
			opcode = OpCodes.Stelem_I1
		};

		public static Stelem_I2_ Stelem_I2 => new Stelem_I2_
		{
			opcode = OpCodes.Stelem_I2
		};

		public static Stelem_I4_ Stelem_I4 => new Stelem_I4_
		{
			opcode = OpCodes.Stelem_I4
		};

		public static Stelem_I8_ Stelem_I8 => new Stelem_I8_
		{
			opcode = OpCodes.Stelem_I8
		};

		public static Stelem_R4_ Stelem_R4 => new Stelem_R4_
		{
			opcode = OpCodes.Stelem_R4
		};

		public static Stelem_R8_ Stelem_R8 => new Stelem_R8_
		{
			opcode = OpCodes.Stelem_R8
		};

		public static Stelem_Ref_ Stelem_Ref => new Stelem_Ref_
		{
			opcode = OpCodes.Stelem_Ref
		};

		public static Ldelem_ Ldelem => new Ldelem_
		{
			opcode = OpCodes.Ldelem
		};

		public static Stelem_ Stelem => new Stelem_
		{
			opcode = OpCodes.Stelem
		};

		public static Unbox_Any_ Unbox_Any => new Unbox_Any_
		{
			opcode = OpCodes.Unbox_Any
		};

		public static Conv_Ovf_I1_ Conv_Ovf_I1 => new Conv_Ovf_I1_
		{
			opcode = OpCodes.Conv_Ovf_I1
		};

		public static Conv_Ovf_U1_ Conv_Ovf_U1 => new Conv_Ovf_U1_
		{
			opcode = OpCodes.Conv_Ovf_U1
		};

		public static Conv_Ovf_I2_ Conv_Ovf_I2 => new Conv_Ovf_I2_
		{
			opcode = OpCodes.Conv_Ovf_I2
		};

		public static Conv_Ovf_U2_ Conv_Ovf_U2 => new Conv_Ovf_U2_
		{
			opcode = OpCodes.Conv_Ovf_U2
		};

		public static Conv_Ovf_I4_ Conv_Ovf_I4 => new Conv_Ovf_I4_
		{
			opcode = OpCodes.Conv_Ovf_I4
		};

		public static Conv_Ovf_U4_ Conv_Ovf_U4 => new Conv_Ovf_U4_
		{
			opcode = OpCodes.Conv_Ovf_U4
		};

		public static Conv_Ovf_I8_ Conv_Ovf_I8 => new Conv_Ovf_I8_
		{
			opcode = OpCodes.Conv_Ovf_I8
		};

		public static Conv_Ovf_U8_ Conv_Ovf_U8 => new Conv_Ovf_U8_
		{
			opcode = OpCodes.Conv_Ovf_U8
		};

		public static Refanyval_ Refanyval => new Refanyval_
		{
			opcode = OpCodes.Refanyval
		};

		public static Ckfinite_ Ckfinite => new Ckfinite_
		{
			opcode = OpCodes.Ckfinite
		};

		public static Mkrefany_ Mkrefany => new Mkrefany_
		{
			opcode = OpCodes.Mkrefany
		};

		public static Ldtoken_ Ldtoken => new Ldtoken_
		{
			opcode = OpCodes.Ldtoken
		};

		public static Conv_U2_ Conv_U2 => new Conv_U2_
		{
			opcode = OpCodes.Conv_U2
		};

		public static Conv_U1_ Conv_U1 => new Conv_U1_
		{
			opcode = OpCodes.Conv_U1
		};

		public static Conv_I_ Conv_I => new Conv_I_
		{
			opcode = OpCodes.Conv_I
		};

		public static Conv_Ovf_I_ Conv_Ovf_I => new Conv_Ovf_I_
		{
			opcode = OpCodes.Conv_Ovf_I
		};

		public static Conv_Ovf_U_ Conv_Ovf_U => new Conv_Ovf_U_
		{
			opcode = OpCodes.Conv_Ovf_U
		};

		public static Add_Ovf_ Add_Ovf => new Add_Ovf_
		{
			opcode = OpCodes.Add_Ovf
		};

		public static Add_Ovf_Un_ Add_Ovf_Un => new Add_Ovf_Un_
		{
			opcode = OpCodes.Add_Ovf_Un
		};

		public static Mul_Ovf_ Mul_Ovf => new Mul_Ovf_
		{
			opcode = OpCodes.Mul_Ovf
		};

		public static Mul_Ovf_Un_ Mul_Ovf_Un => new Mul_Ovf_Un_
		{
			opcode = OpCodes.Mul_Ovf_Un
		};

		public static Sub_Ovf_ Sub_Ovf => new Sub_Ovf_
		{
			opcode = OpCodes.Sub_Ovf
		};

		public static Sub_Ovf_Un_ Sub_Ovf_Un => new Sub_Ovf_Un_
		{
			opcode = OpCodes.Sub_Ovf_Un
		};

		public static Endfinally_ Endfinally => new Endfinally_
		{
			opcode = OpCodes.Endfinally
		};

		public static Leave_ Leave => new Leave_
		{
			opcode = OpCodes.Leave
		};

		public static Leave_S_ Leave_S => new Leave_S_
		{
			opcode = OpCodes.Leave_S
		};

		public static Stind_I_ Stind_I => new Stind_I_
		{
			opcode = OpCodes.Stind_I
		};

		public static Conv_U_ Conv_U => new Conv_U_
		{
			opcode = OpCodes.Conv_U
		};

		public static Prefix7_ Prefix7 => new Prefix7_
		{
			opcode = OpCodes.Prefix7
		};

		public static Prefix6_ Prefix6 => new Prefix6_
		{
			opcode = OpCodes.Prefix6
		};

		public static Prefix5_ Prefix5 => new Prefix5_
		{
			opcode = OpCodes.Prefix5
		};

		public static Prefix4_ Prefix4 => new Prefix4_
		{
			opcode = OpCodes.Prefix4
		};

		public static Prefix3_ Prefix3 => new Prefix3_
		{
			opcode = OpCodes.Prefix3
		};

		public static Prefix2_ Prefix2 => new Prefix2_
		{
			opcode = OpCodes.Prefix2
		};

		public static Prefix1_ Prefix1 => new Prefix1_
		{
			opcode = OpCodes.Prefix1
		};

		public static Prefixref_ Prefixref => new Prefixref_
		{
			opcode = OpCodes.Prefixref
		};

		public static Arglist_ Arglist => new Arglist_
		{
			opcode = OpCodes.Arglist
		};

		public static Ceq_ Ceq => new Ceq_
		{
			opcode = OpCodes.Ceq
		};

		public static Cgt_ Cgt => new Cgt_
		{
			opcode = OpCodes.Cgt
		};

		public static Cgt_Un_ Cgt_Un => new Cgt_Un_
		{
			opcode = OpCodes.Cgt_Un
		};

		public static Clt_ Clt => new Clt_
		{
			opcode = OpCodes.Clt
		};

		public static Clt_Un_ Clt_Un => new Clt_Un_
		{
			opcode = OpCodes.Clt_Un
		};

		public static Ldftn_ Ldftn => new Ldftn_
		{
			opcode = OpCodes.Ldftn
		};

		public static Ldvirtftn_ Ldvirtftn => new Ldvirtftn_
		{
			opcode = OpCodes.Ldvirtftn
		};

		public static Ldarg_ Ldarg => new Ldarg_
		{
			opcode = OpCodes.Ldarg
		};

		public static Ldarga_ Ldarga => new Ldarga_
		{
			opcode = OpCodes.Ldarga
		};

		public static Starg_ Starg => new Starg_
		{
			opcode = OpCodes.Starg
		};

		public static Ldloc_ Ldloc => new Ldloc_
		{
			opcode = OpCodes.Ldloc
		};

		public static Ldloca_ Ldloca => new Ldloca_
		{
			opcode = OpCodes.Ldloca
		};

		public static Stloc_ Stloc => new Stloc_
		{
			opcode = OpCodes.Stloc
		};

		public static Localloc_ Localloc => new Localloc_
		{
			opcode = OpCodes.Localloc
		};

		public static Endfilter_ Endfilter => new Endfilter_
		{
			opcode = OpCodes.Endfilter
		};

		public static Unaligned_ Unaligned => new Unaligned_
		{
			opcode = OpCodes.Unaligned
		};

		public static Volatile_ Volatile => new Volatile_
		{
			opcode = OpCodes.Volatile
		};

		public static Tailcall_ Tailcall => new Tailcall_
		{
			opcode = OpCodes.Tailcall
		};

		public static Initobj_ Initobj => new Initobj_
		{
			opcode = OpCodes.Initobj
		};

		public static Constrained_ Constrained => new Constrained_
		{
			opcode = OpCodes.Constrained
		};

		public static Cpblk_ Cpblk => new Cpblk_
		{
			opcode = OpCodes.Cpblk
		};

		public static Initblk_ Initblk => new Initblk_
		{
			opcode = OpCodes.Initblk
		};

		public static Rethrow_ Rethrow => new Rethrow_
		{
			opcode = OpCodes.Rethrow
		};

		public static Sizeof_ Sizeof => new Sizeof_
		{
			opcode = OpCodes.Sizeof
		};

		public static Refanytype_ Refanytype => new Refanytype_
		{
			opcode = OpCodes.Refanytype
		};

		public static Readonly_ Readonly => new Readonly_
		{
			opcode = OpCodes.Readonly
		};
	}
	public class CodeMatch : CodeInstruction
	{
		public string name;

		public List<OpCode> opcodes = new List<OpCode>();

		public List<object> operands = new List<object>();

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

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

		public Func<CodeInstruction, bool> predicate;

		internal CodeMatch Set(object operand, string name)
		{
			if (base.operand == null)
			{
				base.operand = operand;
			}
			if (this.name == null)
			{
				this.name = name;
			}
			return this;
		}

		public CodeMatch(OpCode? opcode = null, object operand = null, string name = null)
		{
			if (opcode.HasValue)
			{
				OpCode item = (base.opcode = opcode.GetValueOrDefault());
				opcodes.Add(item);
			}
			if (operand != null)
			{
				operands.Add(operand);
				base.operand = operand;
			}
			this.name = name;
		}

		public CodeMatch(CodeInstruction instruction, string name = null)
			: this(instruction.opcode, instruction.operand, name)
		{
		}

		public CodeMatch(Func<CodeInstruction, bool> predicate, string name = null)
		{
			this.predicate = predicate;
			this.name = name;
		}

		internal bool Matches(List<CodeInstruction> codes, CodeInstruction instruction)
		{
			if (predicate != null)
			{
				return predicate(instruction);
			}
			if (opcodes.Count > 0 && !opcodes.Contains(instruction.opcode))
			{
				return false;
			}
			if (opcode.Size != 0 && opcode.Value != instruction.opcode.Value)
			{
				return false;
			}
			if (operands.Count > 0 && !operands.Contains(instruction.operand))
			{
				return false;
			}
			if (operand != null && !operand.Equals(instruction.operand))
			{
				return false;
			}
			if (labels.Count > 0 && !labels.Intersect(instruction.labels).Any())
			{
				return false;
			}
			if (blocks.Count > 0 && !blocks.Intersect(instruction.blocks).Any())
			{
				return false;
			}
			if (jumpsFrom.Count > 0 && !jumpsFrom.Select((int index) => codes[index].operand).OfType<Label>().Intersect(instruction.labels)
				.Any())
			{
				return false;
			}
			if (jumpsTo.Count > 0)
			{
				object obj = instruction.operand;
				if (obj == null || obj.GetType() != typeof(Label))
				{
					return false;
				}
				Label label = (Label)obj;
				IEnumerable<int> second = from idx in Enumerable.Range(0, codes.Count)
					where codes[idx].labels.Contains(label)
					select idx;
				if (!jumpsTo.Intersect(second).Any())
				{
					return false;
				}
			}
			return true;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (name != null)
			{
				stringBuilder.Append(name + ": ");
			}
			if (opcodes.Count > 0)
			{
				stringBuilder.Append("opcodes=" + (from o in opcodes.Union(new OpCode[1] { opcode })
					where o.Size != 0
					select o).Join() + " ");
			}
			if (operands.Count > 0)
			{
				stringBuilder.Append("operands=" + (from o in operands.Union(new object[1] { operand })
					where o != null
					select o).Join() + " ");
			}
			if (labels.Count > 0)
			{
				stringBuilder.Append("labels=" + labels.Join() + " ");
			}
			if (blocks.Count > 0)
			{
				stringBuilder.Append("blocks=" + blocks.Join() + " ");
			}
			if (jumpsFrom.Count > 0)
			{
				stringBuilder.Append("jumpsFrom=" + jumpsFrom.Join() + " ");
			}
			if (jumpsTo.Count > 0)
			{
				stringBuilder.Append("jumpsTo=" + jumpsTo.Join() + " ");
			}
			if (predicate != null)
			{
				stringBuilder.Append("predicate=yes ");
			}
			if (stringBuilder.Length == 0)
			{
				return base.ToString();
			}
			return "[" + stringBuilder.ToString().Trim() + "]";
		}

		public static implicit operator CodeMatch(OpCode opcode)
		{
			return new CodeMatch(opcode);
		}
	}
	public class CodeMatcher
	{
		private delegate CodeMatcher MatchDelegate();

		private readonly ILGenerator generator;

		private readonly List<CodeInstruction> codes = new List<CodeInstruction>();

		private Dictionary<string, CodeInstruction> lastMatches = new Dictionary<string, CodeInstruction>();

		private string lastError;

		private MatchDelegate lastMatchCall;

		public int Pos { get; private set; } = -1;


		public int Length => codes.Count;

		public bool IsValid
		{
			get
			{
				if (Pos >= 0)
				{
					return Pos < Length;
				}
				return false;
			}
		}

		public bool IsInvalid
		{
			get
			{
				if (Pos >= 0)
				{
					return Pos >= Length;
				}
				return true;
			}
		}

		public int Remaining => Length - Math.Max(0, Pos);

		public ref OpCode Opcode => ref codes[Pos].opcode;

		public ref object Operand => ref codes[Pos].operand;

		public ref List<Label> Labels => ref codes[Pos].labels;

		public ref List<ExceptionBlock> Blocks => ref codes[Pos].blocks;

		public CodeInstruction Instruction => codes[Pos];

		private void FixStart()
		{
			Pos = Math.Max(0, Pos);
		}

		private void SetOutOfBounds(int direction)
		{
			Pos = ((direction > 0) ? Length : (-1));
		}

		public CodeMatcher()
		{
		}

		public CodeMatcher(IEnumerable<CodeInstruction> instructions, ILGenerator generator = null)
		{
			this.generator = generator;
			codes = instructions.Select((CodeInstruction c) => new CodeInstruction(c)).ToList();
		}

		public CodeMatcher Clone()
		{
			return new CodeMatcher(codes, generator)
			{
				Pos = Pos,
				lastMatches = lastMatches,
				lastError = lastError,
				lastMatchCall = lastMatchCall
			};
		}

		public CodeInstruction InstructionAt(int offset)
		{
			return codes[Pos + offset];
		}

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

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

		public List<CodeInstruction> Instructions(int count)
		{
			return (from c in codes.GetRange(Pos, count)
				select new CodeInstruction(c)).ToList();
		}

		public List<CodeInstruction> InstructionsInRange(int start, int end)
		{
			List<CodeInstruction> list = codes;
			if (start > end)
			{
				int num = end;
				int num2 = start;
				start = num;
				end = num2;
			}
			return (from c in list.GetRange(start, end - start + 1)
				select new CodeInstruction(c)).ToList();
		}

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

		public List<Label> DistinctLabels(IEnumerable<CodeInstruction> instructions)
		{
			return instructions.SelectMany((CodeInstruction instruction) => instruction.labels).Distinct().ToList();
		}

		public bool ReportFailure(MethodBase method, Action<string> logger)
		{
			if (IsValid)
			{
				return false;
			}
			string arg = lastError ?? "Unexpected code";
			logger($"{arg} in {method}");
			return true;
		}

		public CodeMatcher ThrowIfInvalid(string explanation)
		{
			if (explanation == null)
			{
				throw new ArgumentNullException("explanation");
			}
			if (IsInvalid)
			{
				string text = explanation + " - Current state is invalid.";
				if (lastError != null)
				{
					text = text + " Details: " + lastError;
				}
				throw new InvalidOperationException(text);
			}
			return this;
		}

		public CodeMatcher ThrowIfNotMatch(string explanation, params CodeMatch[] matches)
		{
			ThrowIfInvalid(explanation);
			if (!MatchSequence(Pos, matches))
			{
				throw new InvalidOperationException(explanation + " - Match failed");
			}
			return this;
		}

		private void ThrowIfNotMatch(string explanation, int direction, CodeMatch[] matches)
		{
			ThrowIfInvalid(explanation);
			int pos = Pos;
			try
			{
				if (Match(matches, direction, useEnd: false).IsInvalid)
				{
					throw new InvalidOperationException(explanation + " - Match failed");
				}
			}
			finally
			{
				Pos = pos;
			}
		}

		public CodeMatcher ThrowIfNotMatchForward(string explanation, params CodeMatch[] matches)
		{
			ThrowIfNotMatch(explanation, 1, matches);
			return this;
		}

		public CodeMatcher ThrowIfNotMatchBack(string explanation, params CodeMatch[] matches)
		{
			ThrowIfNotMatch(explanation, -1, matches);
			return this;
		}

		public CodeMatcher ThrowIfFalse(string explanation, Func<CodeMatcher, bool> stateCheckFunc)
		{
			if (stateCheckFunc == null)
			{
				throw new ArgumentNullException("stateCheckFunc");
			}
			ThrowIfInvalid(explanation);
			if (!stateCheckFunc(this))
			{
				throw new InvalidOperationException(explanation + " - Check function returned false");
			}
			return this;
		}

		public CodeMatcher SetInstruction(CodeInstruction instruction)
		{
			codes[Pos] = instruction;
			return this;
		}

		public CodeMatcher SetInstructionAndAdvance(CodeInstruction instruction)
		{
			SetInstruction(instruction);
			Pos++;
			return this;
		}

		public CodeMatcher Set(OpCode opcode, object operand)
		{
			Opcode = opcode;
			Operand = operand;
			return this;
		}

		public CodeMatcher SetAndAdvance(OpCode opcode, object operand)
		{
			Set(opcode, operand);
			Pos++;
			return this;
		}

		public CodeMatcher SetOpcodeAndAdvance(OpCode opcode)
		{
			Opcode = opcode;
			Pos++;
			return this;
		}

		public CodeMatcher SetOperandAndAdvance(object operand)
		{
			Operand = operand;
			Pos++;
			return this;
		}

		public CodeMatcher CreateLabel(out Label label)
		{
			label = generator.DefineLabel();
			Labels.Add(label);
			return this;
		}

		public CodeMatcher CreateLabelAt(int position, out Label label)
		{
			label = generator.DefineLabel();
			AddLabelsAt(position, new Label[1] { label });
			return this;
		}

		public CodeMatcher CreateLabelWithOffsets(int offset, out Label label)
		{
			label = generator.DefineLabel();
			return AddLabelsAt(Pos + offset, new Label[1] { label });
		}

		public CodeMatcher AddLabels(IEnumerable<Label> labels)
		{
			Labels.AddRange(labels);
			return this;
		}

		public CodeMatcher AddLabelsAt(int position, IEnumerable<Label> labels)
		{
			codes[position].labels.AddRange(labels);
			return this;
		}

		public CodeMatcher SetJumpTo(OpCode opcode, int destination, out Label label)
		{
			CreateLabelAt(destination, out label);
			return Set(opcode, label);
		}

		public CodeMatcher Insert(params CodeInstruction[] instructions)
		{
			codes.InsertRange(Pos, instructions);
			return this;
		}

		public CodeMatcher Insert(IEnumerable<CodeInstruction> instructions)
		{
			codes.InsertRange(Pos, instructions);
			return this;
		}

		public CodeMatcher InsertBranch(OpCode opcode, int destination)
		{
			CreateLabelAt(destination, out var label);
			codes.Insert(Pos, new CodeInstruction(opcode, label));
			return this;
		}

		public CodeMatcher InsertAndAdvance(params CodeInstruction[] instructions)
		{
			foreach (CodeInstruction codeInstruction in instructions)
			{
				Insert(codeInstruction);
				Pos++;
			}
			return this;
		}

		public CodeMatcher InsertAndAdvance(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				InsertAndAdvance(instruction);
			}
			return this;
		}

		public CodeMatcher InsertBranchAndAdvance(OpCode opcode, int destination)
		{
			InsertBranch(opcode, destination);
			Pos++;
			return this;
		}

		public CodeMatcher RemoveInstruction()
		{
			codes.RemoveAt(Pos);
			return this;
		}

		public CodeMatcher RemoveInstructions(int count)
		{
			codes.RemoveRange(Pos, count);
			return this;
		}

		public CodeMatcher RemoveInstructionsInRange(int start, int end)
		{
			if (start > end)
			{
				int num = end;
				int num2 = start;
				start = num;
				end = num2;
			}
			codes.RemoveRange(start, end - start + 1);
			return this;
		}

		public CodeMatcher RemoveInstructionsWithOffsets(int startOffset, int endOffset)
		{
			return RemoveInstructionsInRange(Pos + startOffset, Pos + endOffset);
		}

		public CodeMatcher Advance(int offset)
		{
			Pos += offset;
			if (!IsValid)
			{
				SetOutOfBounds(offset);
			}
			return this;
		}

		public CodeMatcher Start()
		{
			Pos = 0;
			return this;
		}

		public CodeMatcher End()
		{
			Pos = Length - 1;
			return this;
		}

		public CodeMatcher SearchForward(Func<CodeInstruction, bool> predicate)
		{
			return Search(predicate, 1);
		}

		[Obsolete("Use SearchBackwards instead")]
		public CodeMatcher SearchBack(Func<CodeInstruction, bool> predicate)
		{
			return Search(predicate, -1);
		}

		public CodeMatcher SearchBackwards(Func<CodeInstruction, bool> predicate)
		{
			return Search(predicate, -1);
		}

		private CodeMatcher Search(Func<CodeInstruction, bool> predicate, int direction)
		{
			FixStart();
			while (IsValid && !predicate(Instruction))
			{
				Pos += direction;
			}
			lastError = (IsInvalid ? $"Cannot find {predicate}" : null);
			return this;
		}

		public CodeMatcher MatchForward(bool useEnd, params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd);
		}

		public CodeMatcher MatchBack(bool useEnd, params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd);
		}

		public CodeMatcher MatchStartForward(params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd: false);
		}

		public CodeMatcher MatchEndForward(params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd: true);
		}

		public CodeMatcher MatchStartBackwards(params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd: false);
		}

		public CodeMatcher MatchEndBackwards(params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd: true);
		}

		private CodeMatcher Match(CodeMatch[] matches, int direction, bool useEnd)
		{
			lastMatchCall = delegate
			{
				FixStart();
				while (IsValid)
				{
					if (MatchSequence(Pos, matches))
					{
						if (useEnd)
						{
							Pos += matches.Length - 1;
						}
						break;
					}
					Pos += direction;
				}
				lastError = (IsInvalid ? ("Cannot find " + matches.Join()) : null);
				return this;
			};
			return lastMatchCall();
		}

		public CodeMatcher Repeat(Action<CodeMatcher> matchAction, Action<string> notFoundAction = null)
		{
			int num = 0;
			if (lastMatchCall == null)
			{
				throw new InvalidOperationException("No previous Match operation - cannot repeat");
			}
			while (IsValid)
			{
				matchAction(this);
				lastMatchCall();
				num++;
			}
			lastMatchCall = null;
			if (num == 0)
			{
				notFoundAction?.Invoke(lastError);
			}
			return this;
		}

		public CodeInstruction NamedMatch(string name)
		{
			return lastMatches[name];
		}

		private bool MatchSequence(int start, CodeMatch[] matches)
		{
			if (start < 0)
			{
				return false;
			}
			lastMatches = new Dictionary<string, CodeInstruction>();
			foreach (CodeMatch codeMatch in matches)
			{
				if (start >= Length || !codeMatch.Matches(codes, codes[start]))
				{
					return false;
				}
				if (codeMatch.name != null)
				{
					lastMatches.Add(codeMatch.name, codes[start]);
				}
				start++;
			}
			return true;
		}
	}
	public static class GeneralExtensions
	{
		public static string Join<T>(this IEnumerable<T> enumeration, Func<T, string> converter = null, string delimiter = ", ")
		{
			if (converter == null)
			{
				converter = (T t) => t.ToString();
			}
			return enumeration.Aggregate("", (string prev, T curr) => prev + ((prev.Length > 0) ? delimiter : "") + converter(curr));
		}

		public static string Description(this Type[] parameters)
		{
			if (parameters == null)
			{
				return "NULL";
			}
			return "(" + parameters.Join((Type p) => p.FullDescription()) + ")";
		}

		public static string FullDescription(this Type type)
		{
			if ((object)type != null)
			{
				return TypeNameHelper.GetTypeDisplayName(type);
			}
			return "null";
		}

		public static string FullDescription(this MethodBase member)
		{
			if ((object)member == null)
			{
				return "null";
			}
			Type returnedType = AccessTools.GetReturnedType(member);
			StringBuilder stringBuilder = new StringBuilder();
			if (member.IsStatic)
			{
				stringBuilder.Append("static ");
			}
			if (member.IsAbstract)
			{
				stringBuilder.Append("abstract ");
			}
			if (member.IsVirtual)
			{
				stringBuilder.Append("virtual ");
			}
			stringBuilder.Append(returnedType.FullDescription() + " ");
			if ((object)member.DeclaringType != null)
			{
				stringBuilder.Append(member.DeclaringType.FullDescription() + "::");
			}
			string text = member.GetParameters().Join((ParameterInfo p) => p.ParameterType.FullDescription() + " " + p.Name);
			stringBuilder.Append(member.Name + "(" + text + ")");
			return stringBuilder.ToString();
		}

		public static Type[] Types(this ParameterInfo[] pinfo)
		{
			return pinfo.Select((ParameterInfo pi) => pi.ParameterType).ToArray();
		}

		public static T GetValueSafe<S, T>(this Dictionary<S, T> dictionary, S key)
		{
			if (dictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			return default(T);
		}

		public static T GetTypedValue<T>(this Dictionary<string, object> dictionary, string key)
		{
			if (dictionary.TryGetValue(key, out var value) && value is T)
			{
				return (T)value;
			}
			return default(T);
		}

		public static string ToLiteral(this string input, string quoteChar = "\"")
		{
			StringBuilder stringBuilder = new StringBuilder(input.Length + 2);
			stringBuilder.Append(quoteChar);
			foreach (char c in input)
			{
				switch (c)
				{
				case '\'':
					stringBuilder.Append("\\'");
					continue;
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '\0':
					stringBuilder.Append("\\0");
					continue;
				case '\a':
					stringBuilder.Append("\\a");
					continue;
				case '\b':
					stringBuilder.Append("\\b");
					continue;
				case '\f':
					stringBuilder.Append("\\f");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				case '\v':
					stringBuilder.Append("\\v");
					continue;
				}
				if (c >= ' ' && c <= '~')
				{
					stringBuilder.Append(c);
					continue;
				}
				stringBuilder.Append("\\u");
				int num = c;
				stringBuilder.Append(num.ToString("x4"));
			}
			stringBuilder.Append(quoteChar);
			return stringBuilder.ToString();
		}
	}
	public static class CodeInstructionExtensions
	{
		private static readonly HashSet<OpCode> loadVarCodes = new HashSet<OpCode>
		{
			OpCodes.Ldloc_0,
			OpCodes.Ldloc_1,
			OpCodes.Ldloc_2,
			OpCodes.Ldloc_3,
			OpCodes.Ldloc,
			OpCodes.Ldloca,
			OpCodes.Ldloc_S,
			OpCodes.Ldloca_S
		};

		private static readonly HashSet<OpCode> storeVarCodes = new HashSet<OpCode>
		{
			OpCodes.Stloc_0,
			OpCodes.Stloc_1,
			OpCodes.Stloc_2,
			OpCodes.Stloc_3,
			OpCodes.Stloc,
			OpCodes.Stloc_S
		};

		private static readonly HashSet<OpCode> branchCodes = new HashSet<OpCode>
		{
			OpCodes.Br_S,
			OpCodes.Brfalse_S,
			OpCodes.Brtrue_S,
			OpCodes.Beq_S,
			OpCodes.Bge_S,
			OpCodes.Bgt_S,
			OpCodes.Ble_S,
			OpCodes.Blt_S,
			OpCodes.Bne_Un_S,
			OpCodes.Bge_Un_S,
			OpCodes.Bgt_Un_S,
			OpCodes.Ble_Un_S,
			OpCodes.Blt_Un_S,
			OpCodes.Br,
			OpCodes.Brfalse,
			OpCodes.Brtrue,
			OpCodes.Beq,
			OpCodes.Bge,
			OpCodes.Bgt,
			OpCodes.Ble,
			OpCodes.Blt,
			OpCodes.Bne_Un,
			OpCodes.Bge_Un,
			OpCodes.Bgt_Un,
			OpCodes.Ble_Un,
			OpCodes.Blt_Un
		};

		private static readonly HashSet<OpCode> constantLoadingCodes = new HashSet<OpCode>
		{
			OpCodes.Ldc_I4_M1,
			OpCodes.Ldc_I4_0,
			OpCodes.Ldc_I4_1,
			OpCodes.Ldc_I4_2,
			OpCodes.Ldc_I4_3,
			OpCodes.Ldc_I4_4,
			OpCodes.Ldc_I4_5,
			OpCodes.Ldc_I4_6,
			OpCodes.Ldc_I4_7,
			OpCodes.Ldc_I4_8,
			OpCodes.Ldc_I4,
			OpCodes.Ldc_I4_S,
			OpCodes.Ldc_I8,
			OpCodes.Ldc_R4,
			OpCodes.Ldc_R8
		};

		public static bool IsValid(this OpCode code)
		{
			return code.Size > 0;
		}

		public static bool OperandIs(this CodeInstruction code, object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (code.operand == null)
			{
				return false;
			}
			Type type = value.GetType();
			Type type2 = code.operand.GetType();
			if (AccessTools.IsInteger(type) && AccessTools.IsNumber(type2))
			{
				return Convert.ToInt64(code.operand) == Convert.ToInt64(value);
			}
			if (AccessTools.IsFloatingPoint(type) && AccessTools.IsNumber(type2))
			{
				return Convert.ToDouble(code.operand) == Convert.ToDouble(value);
			}
			return object.Equals(code.operand, value);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool OperandIs(this CodeInstruction code, MemberInfo value)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			return object.Equals(code.operand, value);
		}

		public static bool Is(this CodeInstruction code, OpCode opcode, object operand)
		{
			if (code.opcode == opcode)
			{
				return code.OperandIs(operand);
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool Is(this CodeInstruction code, OpCode opcode, MemberInfo operand)
		{
			if (code.opcode == opcode)
			{
				return code.OperandIs(operand);
			}
			return false;
		}

		public static bool IsLdarg(this CodeInstruction code, int? n = null)
		{
			if ((!n.HasValue || n.Value == 0) && code.opcode == OpCodes.Ldarg_0)
			{
				return true;
			}
			if ((!n.HasValue || n.Value == 1) && code.opcode == OpCodes.Ldarg_1)
			{
				return true;
			}
			if ((!n.HasValue || n.Value == 2) && code.opcode == OpCodes.Ldarg_2)
			{
				return true;
			}
			if ((!n.HasValue || n.Value == 3) && code.opcode == OpCodes.Ldarg_3)
			{
				return true;
			}
			if (code.opcode == OpCodes.Ldarg && (!n.HasValue || n.Value == Convert.ToInt32(code.operand)))
			{
				return true;
			}
			if (code.opcode == OpCodes.Ldarg_S && (!n.HasValue || n.Value == Convert.ToInt32(code.operand)))
			{
				return true;
			}
			return false;
		}

		public static bool IsLdarga(this CodeInstruction code, int? n = null)
		{
			if (code.opcode != OpCodes.Ldarga && code.opcode != OpCodes.Ldarga_S)
			{
				return false;
			}
			if (n.HasValue)
			{
				return n.Value == Convert.ToInt32(code.operand);
			}
			return true;
		}

		public static bool IsStarg(this CodeInstruction code, int? n = null)
		{
			if (code.opcode != OpCodes.Starg && code.opcode != OpCodes.Starg_S)
			{
				return false;
			}
			if (n.HasValue)
			{
				return n.Value == Convert.ToInt32(code.operand);
			}
			return true;
		}

		public static bool IsLdloc(this CodeInstruction code, LocalBuilder variable = null)
		{
			if (!loadVarCodes.Contains(code.opcode))
			{
				return false;
			}
			if (variable != null)
			{
				return object.Equals(variable, code.operand);
			}
			return true;
		}

		public static bool IsStloc(this CodeInstruction code, LocalBuilder variable = null)
		{
			if (!storeVarCodes.Contains(code.opcode))
			{
				return false;
			}
			if (variable != null)
			{
				return object.Equals(variable, code.operand);
			}
			return true;
		}

		public static bool Branches(this CodeInstruction code, out Label? label)
		{
			if (branchCodes.Contains(code.opcode))
			{
				label = (Label)code.operand;
				return true;
			}
			label = null;
			return false;
		}

		public static bool Calls(this CodeInstruction code, MethodInfo method)
		{
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (code.opcode != OpCodes.Call && code.opcode != OpCodes.Callvirt)
			{
				return false;
			}
			return object.Equals(code.operand, method);
		}

		public static bool LoadsConstant(this CodeInstruction code)
		{
			return constantLoadingCodes.Contains(code.opcode);
		}

		public static bool LoadsConstant(this CodeInstruction code, long number)
		{
			OpCode opcode = code.opcode;
			if (number == -1 && opcode == OpCodes.Ldc_I4_M1)
			{
				return true;
			}
			if (number == 0L && opcode == OpCodes.Ldc_I4_0)
			{
				return true;
			}
			if (number == 1 && opcode == OpCodes.Ldc_I4_1)
			{
				return true;
			}
			if (number == 2 && opcode == OpCodes.Ldc_I4_2)
			{
				return true;
			}
			if (number == 3 && opcode == OpCodes.Ldc_I4_3)
			{
				return true;
			}
			if (number == 4 && opcode == OpCodes.Ldc_I4_4)
			{
				return true;
			}
			if (number == 5 && opcode == OpCodes.Ldc_I4_5)
			{
				return true;
			}
			if (number == 6 && opcode == OpCodes.Ldc_I4_6)
			{
				return true;
			}
			if (number == 7 && opcode == OpCodes.Ldc_I4_7)
			{
				return true;
			}
			if (number == 8 && opcode == OpCodes.Ldc_I4_8)
			{
				return true;
			}
			if (opcode != OpCodes.Ldc_I4 && opcode != OpCodes.Ldc_I4_S && opcode != OpCodes.Ldc_I8)
			{
				return false;
			}
			return Convert.ToInt64(code.operand) == number;
		}

		public static bool LoadsConstant(this CodeInstruction code, double number)
		{
			if (code.opcode != OpCodes.Ldc_R4 && code.opcode != OpCodes.Ldc_R8)
			{
				return false;
			}
			return Convert.ToDouble(code.operand) == number;
		}

		public static bool LoadsConstant(this CodeInstruction code, Enum e)
		{
			return code.LoadsConstant(Convert.ToInt64(e));
		}

		public static bool LoadsField(this CodeInstruction code, FieldInfo field, bool byAddress = false)
		{
			if ((object)field == null)
			{
				throw new ArgumentNullException("field");
			}
			OpCode opCode = (field.IsStatic ? OpCodes.Ldsfld : OpCodes.Ldfld);
			if (!byAddress && code.opcode == opCode && object.Equals(code.operand, field))
			{
				return true;
			}
			OpCode opCode2 = (field.IsStatic ? OpCodes.Ldsflda : OpCodes.Ldflda);
			if (byAddress && code.opcode == opCode2 && object.Equals(code.operand, field))
			{
				return true;
			}
			return false;
		}

		public static bool StoresField(this CodeInstruction code, FieldInfo field)
		{
			if ((object)field == null)
			{
				throw new ArgumentNullException("field");
			}
			OpCode opCode = (field.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld);
			if (code.opcode == opCode)
			{
				return object.Equals(code.operand, field);
			}
			return false;
		}

		public static CodeInstruction WithLabels(this CodeInstruction code, params Label[] labels)
		{
			code.labels.AddRange(labels);
			return code;
		}

		public static CodeInstruction WithLabels(this CodeInstruction code, IEnumerable<Label> labels)
		{
			code.labels.AddRange(labels);
			return code;
		}

		public static List<Label> ExtractLabels(this CodeInstruction code)
		{
			List<Label> result = new List<Label>(code.labels);
			code.labels.Clear();
			return result;
		}

		public static CodeInstruction MoveLabelsTo(this CodeInstruction code, CodeInstruction other)
		{
			other.WithLabels(code.ExtractLabels());
			return code;
		}

		public static CodeInstruction MoveLabelsFrom(this CodeInstruction code, CodeInstruction other)
		{
			return code.WithLabels(other.ExtractLabels());
		}

		public static CodeInstruction WithBlocks(this CodeInstruction code, params ExceptionBlock[] blocks)
		{
			code.blocks.AddRange(blocks);
			return code;
		}

		public static CodeInstruction WithBlocks(this CodeInstruction code, IEnumerable<ExceptionBlock> blocks)
		{
			code.blocks.AddRange(blocks);
			return code;
		}

		public static List<ExceptionBlock> ExtractBlocks(this CodeInstruction code)
		{
			List<ExceptionBlock> result = new List<ExceptionBlock>(code.blocks);
			code.blocks.Clear();
			return result;
		}

		public static CodeInstruction MoveBlocksTo(this CodeInstruction code, CodeInstruction other)
		{
			other.WithBlocks(code.ExtractBlocks());
			return code;
		}

		public static CodeInstruction MoveBlocksFrom(this CodeInstruction code, CodeInstruction other)
		{
			return code.WithBlocks(other.ExtractBlocks());
		}
	}
	public static class CollectionExtensions
	{
		public static void Do<T>(this IEnumerable<T> sequence, Action<T> action)
		{
			if (sequence != null)
			{
				IEnumerator<T> enumerator = sequence.GetEnumerator();
				while (enumerator.MoveNext())
				{
					action(enumerator.Current);
				}
			}
		}

		public static void DoIf<T>(this IEnumerable<T> sequence, Func<T, bool> condition, Action<T> action)
		{
			sequence.Where(condition).Do(action);
		}

		public static IEnumerable<T> AddItem<T>(this IEnumerable<T> sequence, T item)
		{
			return (sequence ?? Enumerable.Empty<T>()).Concat(new T[1] { item });
		}

		public static T[] AddToArray<T>(this T[] sequence, T item)
		{
			return sequence.AddItem(item).ToArray();
		}

		public static T[] AddRangeToArray<T>(this T[] sequence, T[] items)
		{
			return (sequence ?? Enumerable.Empty<T>()).Concat(items).ToArray();
		}

		internal static Dictionary<K, V> Merge<K, V>(this IEnumerable<KeyValuePair<K, V>> firstDict, params IEnumerable<KeyValuePair<K, V>>[] otherDicts)
		{
			Dictionary<K, V> dictionary = new Dictionary<K, V>();
			foreach (KeyValuePair<K, V> item in firstDict)
			{
				dictionary[item.Key] = item.Value;
			}
			for (int i = 0; i < otherDicts.Length; i++)
			{
				foreach (KeyValuePair<K, V> item2 in otherDicts[i])
				{
					dictionary[item2.Key] = item2.Value;
				}
			}
			return dictionary;
		}

		internal static Dictionary<K, V> TransformKeys<K, V>(this Dictionary<K, V> origDict, Func<K, K> transform)
		{
			Dictionary<K, V> dictionary = new Dictionary<K, V>();
			foreach (KeyValuePair<K, V> item in origDict)
			{
				dictionary.Add(transform(item.Key), item.Value);
			}
			return dictionary;
		}

		internal static IEnumerable<(T, T)> Pairwise<T>(this IEnumerable<T> self)
		{
			bool isFirst = true;
			T item = default(T);
			foreach (T e in self)
			{
				if (isFirst)
				{
					item = e;
					isFirst = false;
				}
				else
				{
					yield return (item, e);
					item = e;
				}
			}
			if (!isFirst)
			{
				yield return (item, default(T));
			}
		}
	}
	public static class MethodBaseExtensions
	{
		public static bool HasMethodBody(this MethodBase member)
		{
			return (member.GetMethodBody()?.GetILAsByteArray()?.Length).GetValueOrDefault() > 0;
		}
	}
	[Obsolete("Use HarmonyFileLog instead")]
	public static class FileLog
	{
		private static readonly object fileLock = new object();

		private static bool _logPathInited;

		private static string _logPath;

		public static char indentChar = '\t';

		public static int indentLevel = 0;

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

		public static StreamWriter LogWriter { get; set; }

		public static string LogPath
		{
			get
			{
				lock (fileLock)
				{
					if (!_logPathInited)
					{
						_logPathInited = true;
						if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HARMONY_NO_LOG")))
						{
							return null;
						}
						_logPath = Environment.GetEnvironmentVariable("HARMONY_LOG_FILE");
						if (string.IsNullOrEmpty(_logPath))
						{
							string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
							Directory.CreateDirectory(folderPath);
							_logPath = Path.Combine(folderPath, "harmony.log.txt");
						}
					}
					return _logPath;
				}
			}
		}

		private static string IndentString()
		{
			return new string(indentChar, indentLevel);
		}

		public static void ChangeIndent(int delta)
		{
			lock (fileLock)
			{
				indentLevel = Math.Max(0, indentLevel + delta);
			}
		}

		public static void LogBuffered(string str)
		{
			lock (fileLock)
			{
				buffer.Add(IndentString() + str);
			}
		}

		public static void LogBuffered(List<string> strings)
		{
			lock (fileLock)
			{
				buffer.AddRange(strings);
			}
		}

		public static List<string> GetBuffer(bool clear)
		{
			lock (fileLock)
			{
				List<string> result = buffer;
				if (clear)
				{
					buffer = new List<string>();
				}
				return result;
			}
		}

		public static void SetBuffer(List<string> buffer)
		{
			lock (fileLock)
			{
				FileLog.buffer = buffer;
			}
		}

		public static void FlushBuffer()
		{
			if (LogWriter != null)
			{
				foreach (string item in buffer)
				{
					LogWriter.WriteLine(item);
				}
				buffer.Clear();
			}
			else
			{
				if (LogPath == null)
				{
					return;
				}
				lock (fileLock)
				{
					if (buffer.Count <= 0)
					{
						return;
					}
					using StreamWriter streamWriter = File.AppendText(LogPath);
					foreach (string item2 in buffer)
					{
						streamWriter.WriteLine(item2);
					}
					buffer.Clear();
				}
			}
		}

		public static void Log(string str)
		{
			if (LogWriter != null)
			{
				LogWriter.WriteLine(IndentString() + str);
			}
			else
			{
				if (LogPath == null)
				{
					return;
				}
				lock (fileLock)
				{
					using StreamWriter streamWriter = File.AppendText(LogPath);
					streamWriter.WriteLine(IndentString() + str);
				}
			}
		}

		public static void Debug(string str)
		{
			if (Harmony.DEBUG)
			{
				Log(str);
			}
		}

		public static void Reset()
		{
			lock (fileLock)
			{
				File.Delete($"{Environment.GetFolderPath(Environment.SpecialFolder.Desktop)}{Path.DirectorySeparatorChar}harmony.log.txt");
			}
		}

		public unsafe static void LogBytes(long ptr, int len)
		{
			lock (fileLock)
			{
				byte* ptr2 = (byte*)ptr;
				string text = "";
				for (int i = 1; i <= len; i++)
				{
					if (text.Length == 0)
					{
						text = "#  ";
					}
					text += $"{*ptr2:X2} ";
					if (i > 1 || len == 1)
					{
						if (i % 8 == 0 || i == len)
						{
							Log(text);
							text = "";
						}
						else if (i % 4 == 0)
						{
							text += " ";
						}
					}
					ptr2++;
				}
				byte[] destination = new byte[len];
				Marshal.Copy((IntPtr)ptr, destination, 0, len);
				byte[] array = MD5.Create().ComputeHash(destination);
				StringBuilder stringBuilder = new StringBuilder();
				for (int j = 0; j < array.Length; j++)
				{
					stringBuilder.Append(array[j].ToString("X2"));
				}
				Log($"HASH: {stringBuilder}");
			}
		}
	}
	public static class SymbolExtensions
	{
		public static MethodInfo GetMethodInfo(Expression<Action> expression)
		{
			return GetMethodInfo((LambdaExpression)expression);
		}

		public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression)
		{
			return GetMethodInfo((LambdaExpression)expression);
		}

		public static MethodInfo GetMethodInfo<T, TResult>(Expression<Func<T, TResult>> expression)
		{
			return GetMethodInfo((LambdaExpression)expression);
		}

		public static MethodInfo GetMethodInfo(LambdaExpression expression)
		{
			return ((expression.Body as MethodCallExpression) ?? throw new ArgumentException("Invalid Expression. Expression should consist of a Method call only.")).Method ?? throw new Exception($"Cannot find method for expression {expression}");
		}
	}
	public class Traverse<T>
	{
		private readonly Traverse traverse;

		public T Value
		{
			get
			{
				return traverse.GetValue<T>();
			}
			set
			{
				traverse.SetValue(value);
			}
		}

		private Traverse()
		{
		}

		public Traverse(Traverse traverse)
		{
			this.traverse = traverse;
		}
	}
	public class Traverse
	{
		private static readonly AccessCache Cache;

		private readonly Type _type;

		private readonly object _root;

		private readonly MemberInfo _info;

		private readonly MethodBase _method;

		private readonly object[] _params;

		public static Action<Traverse, Traverse> CopyFields;

		[MethodImpl(MethodImplOptions.Synchronized)]
		static Traverse()
		{
			CopyFields = delegate(Traverse from, Traverse to)
			{
				to.SetValue(from.GetValue());
			};
			if (Cache == null)
			{
				Cache = new AccessCache();
			}
		}

		public static Traverse Create(Type type)
		{
			return new Traverse(type);
		}

		public static Traverse Create<T>()
		{
			return Create(typeof(T));
		}

		public static Traverse Create(object root)
		{
			return new Traverse(root);
		}

		public static Traverse CreateWithType(string name)
		{
			return new Traverse(AccessTools.TypeByName(name));
		}

		private Traverse()
		{
		}

		public Traverse(Type type)
		{
			_type = type;
		}

		public Traverse(object root)
		{
			_root = root;
			_type = root?.GetType();
		}

		private Traverse(object root, MemberInfo info, object[] index)
		{
			_root = root;
			_type = root?.GetType() ?? info.GetUnderlyingType();
			_info = info;
			_params = index;
		}

		private Traverse(object root, MethodInfo method, object[] parameter)
		{
			_root = root;
			_type = method.ReturnType;
			_method = method;
			_params = parameter;
		}

		public object GetValue()
		{
			if (_info is FieldInfo)
			{
				return ((FieldInfo)_info).GetValue(_root);
			}
			if (_info is PropertyInfo)
			{
				return ((PropertyInfo)_info).GetValue(_root, AccessTools.all, null, _params, CultureInfo.CurrentCulture);
			}
			if ((object)_method != null)
			{
				return _method.Invoke(_root, _params);
			}
			if (_root == null && (object)_type != null)
			{
				return _type;
			}
			return _root;
		}

		public T GetValue<T>()
		{
			object value = GetValue();
			if (value == null)
			{
				return default(T);
			}
			return (T)value;
		}

		public object GetValue(params object[] arguments)
		{
			if ((object)_method == null)
			{
				throw new Exception("cannot get method value without method");
			}
			return _method.Invoke(_root, arguments);
		}

		public T GetValue<T>(params object[] arguments)
		{
			if ((object)_method == null)
			{
				throw new Exception("cannot get method value without method");
			}
			return (T)_method.Invoke(_root, arguments);
		}

		public Traverse SetValue(object value)
		{
			if (_info is FieldInfo)
			{
				((FieldInfo)_info).SetValue(_root, value, AccessTools.all, null, CultureInfo.CurrentCulture);
			}
			if (_info is PropertyInfo)
			{
				((PropertyInfo)_info).SetValue(_root, value, AccessTools.all, null, _params, CultureInfo.CurrentCulture);
			}
			if ((object)_method != null)
			{
				throw new Exception("cannot set value of method " + _method.FullDescription());
			}
			return this;
		}

		public Type GetValueType()
		{
			if (_info is FieldInfo)
			{
				return ((FieldInfo)_info).FieldType;
			}
			if (_info is PropertyInfo)
			{
				return ((PropertyInfo)_info).PropertyType;
			}
			return null;
		}

		private Traverse Resolve()
		{
			if (_root == null)
			{
				if (_info is FieldInfo fieldInfo && fieldInfo.IsStatic)
				{
					return new Traverse(GetValue());
				}
				if (_info is PropertyInfo propertyInfo && propertyInfo.GetGetMethod().IsStatic)
				{
					return new Traverse(GetValue());
				}
				if ((object)_method != null && _method.IsStatic)
				{
					return new Traverse(GetValue());
				}
				if ((object)_type != null)
				{
					return this;
				}
			}
			return new Traverse(GetValue());
		}

		public Traverse Type(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if ((object)_type == null)
			{
				return new Traverse();
			}
			Type type = AccessTools.Inner(_type, name);
			if ((object)type == null)
			{
				return new Traverse();
			}
			return new Traverse(type);
		}

		public Traverse Field(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			Traverse traverse = Resolve();
			if ((object)traverse._type == null)
			{
				return new Traverse();
			}
			FieldInfo fieldInfo = Cache.GetFieldInfo(traverse._type, name);
			if ((object)fieldInfo == null)
			{
				return new Traverse();
			}
			if (!fieldInfo.IsStatic && traverse._root == null)
			{
				return new Traverse();
			}
			return new Traverse(traverse._root, fieldInfo, null);
		}

		public Traverse<T> Field<T>(string name)
		{
			return new Traverse<T>(Field(name));
		}

		public List<string> Fields()
		{
			return AccessTools.GetFieldNames(Resolve()._type);
		}

		public Traverse Property(string name, object[] index = null)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			Traverse traverse = Resolve();
			if ((object)traverse._type == null)
			{
				return new Traverse();
			}
			PropertyInfo propertyInfo = Cache.GetPropertyInfo(traverse._type, name);
			if ((object)propertyInfo == null)
			{
				return new Traverse();
			}
			return new Traverse(traverse._root, propertyInfo, index);
		}

		public Traverse<T> Property<T>(string name, object[] index = null)
		{
			return new Traverse<T>(Property(name, index));
		}

		public List<string> Properties()
		{
			return AccessTools.GetPropertyNames(Resolve()._type);
		}

		public Traverse Method(string name, params object[] arguments)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			Traverse traverse = Resolve();
			if ((object)traverse._type == null)
			{
				return new Traverse();
			}
			Type[] types = AccessTools.GetTypes(arguments);
			MethodBase methodInfo = Cache.GetMethodInfo(traverse._type, name, types);
			if ((object)methodInfo == null)
			{
				return new Traverse();
			}
			return new Traverse(traverse._root, (MethodInfo)methodInfo, arguments);
		}

		public Traverse Method(string name, Type[] paramTypes, object[] arguments = null)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			Traverse traverse = Resolve();
			if ((object)traverse._type == null)
			{
				return new Traverse();
			}
			MethodBase methodInfo = Cache.GetMethodInfo(traverse._type, name, paramTypes);
			if ((object)methodInfo == null)
			{
				return new Traverse();
			}
			return new Traverse(traverse._root, (MethodInfo)methodInfo, arguments);
		}

		public List<string> Methods()
		{
			return AccessTools.GetMethodNames(Resolve()._type);
		}

		public bool FieldExists()
		{
			if ((object)_info != null)
			{
				return _info is FieldInfo;
			}
			return false;
		}

		public bool PropertyExists()
		{
			if ((object)_info != null)
			{
				return _info is PropertyInfo;
			}
			return false;
		}

		public bool MethodExists()
		{
			return (object)_method != null;
		}

		public bool TypeExists()
		{
			return (object)_type != null;
		}

		public static void IterateFields(object source, Action<Traverse> action)
		{
			Traverse sourceTrv = Create(source);
			AccessTools.GetFieldNames(source).ForEach(delegate(string f)
			{
				action(sourceTrv.Field(f));
			});
		}

		public static void IterateFields(object source, object target, Action<Traverse, Traverse> action)
		{
			Traverse sourceTrv = Create(source);
			Traverse targetTrv = Create(target);
			AccessTools.GetFieldNames(source).ForEach(delegate(string f)
			{
				action(sourceTrv.Field(f), targetTrv.Field(f));
			});
		}

		public static void IterateFields(object source, object target, Action<string, Traverse, Traverse> action)
		{
			Traverse sourceTrv = Create(source);
			Traverse targetTrv = Create(target);
			AccessTools.GetFieldNames(source).ForEach(delegate(string f)
			{
				action(f, sourceTrv.Field(f), targetTrv.Field(f));
			});
		}

		public static void IterateProperties(object source, Action<Traverse> action)
		{
			Traverse sourceTrv = Create(source);
			AccessTools.GetPropertyNames(source).ForEach(delegate(string f)
			{
				action(sourceTrv.Property(f));
			});
		}

		public static void IterateProperties(object source, object target, Action<Traverse, Traverse> action)
		{
			Traverse sourceTrv = Create(source);
			Traverse targetTrv = Create(target);
			AccessTools.GetPropertyNames(source).ForEach(delegate(string f)
			{
				action(sourceTrv.Property(f), targetTrv.Property(f));
			});
		}

		public static void IterateProperties(object source, object target, Action<string, Traverse, Traverse> action)
		{
			Traverse sourceTrv = Create(source);
			Traverse targetTrv = Create(target);
			AccessTools.GetPropertyNames(source).ForEach(delegate(string f)
			{
				action(f, sourceTrv.Property(f), targetTrv.Property(f));
			});
		}

		public override string ToString()
		{
			return (_method ?? GetValue())?.ToString();
		}
	}
}
namespace HarmonyLib.Tools
{
	public static class HarmonyFileLog
	{
		private static bool enabled;

		private static TextWriter textWriter;

		public static bool Enabled
		{
			get
			{
				return enabled;
			}
			set
			{
				if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HARMONY_NO_LOG")))
				{
					enabled = value;
					ToggleDebug();
				}
			}
		}

		public static TextWriter Writer
		{
			get
			{
				return textWriter;
			}
			set
			{
				textWriter?.Flush();
				textWriter = value;
			}
		}

		public static string FileWriterPath { get; set; }

		static HarmonyFileLog()
		{
			string text = Environment.GetEnvironmentVariable("HARMONY_LOG_FILE");
			if (string.IsNullOrEmpty(text))
			{
				text = "HarmonyFileLog.log";
			}
			FileWriterPath = text;
		}

		private static void ToggleDebug()
		{
			if (Enabled)
			{
				if (Writer == null)
				{
					Writer = new StreamWriter(File.Create(Path.GetFullPath(FileWriterPath)));
				}
				Logger.MessageReceived += OnMessage;
			}
			else
			{
				Logger.MessageReceived -= OnMessage;
			}
		}

		private static void OnMessage(object sender, Logger.LogEventArgs e)
		{
			Writer.WriteLine($"[{e.LogChannel}] {e.Message}");
			Writer.Flush();
		}
	}
	public static class Logger
	{
		public class LogEventArgs : EventArgs
		{
			public LogChannel LogChannel { get; internal set; }

			public string Message { get; internal set; }
		}

		[Flags]
		public enum LogChannel
		{
			None = 0,
			Info = 2,
			IL = 4,
			Warn = 8,
			Error = 0x10,
			Debug = 0x20,
			All = 0x3E
		}

		public static LogChannel ChannelFilter { get; set; }

		public static event EventHandler<LogEventArgs> MessageReceived;

		internal static bool IsEnabledFor(LogChannel channel)
		{
			return (channel & ChannelFilter) != 0;
		}

		internal static void Log(LogChannel channel, Func<string> message, bool forcePropagation = false)
		{
			if (forcePropagation || IsEnabledFor(channel))
			{
				Logger.MessageReceived?.Invoke(null, new LogEventArgs
				{
					LogChannel = channel,
					Message = message()
				});
			}
		}

		internal static void LogText(LogChannel channel, string message, bool forcePropagation = false)
		{
			if (forcePropagation || IsEnabledFor(channel))
			{
				Logger.MessageReceived?.Invoke(null, new LogEventArgs
				{
					LogChannel = channel,
					Message = message
				});
			}
		}
	}
	internal static class TypeNameHelper
	{
		private static readonly Dictionary<Type, string> BuiltInTypeNames = new Dictionary<Type, string>
		{
			{
				typeof(void),
				"void"
			},
			{
				typeof(bool),
				"bool"
			},
			{
				typeof(byte),
				"byte"
			},
			{
				typeof(char),
				"char"
			},
			{
				typeof(decimal),
				"decimal"
			},
			{
				typeof(double),
				"double"
			},
			{
				typeof(float),
				"float"
			},
			{
				typeof(int),
				"int"
			},
			{
				typeof(long),
				"long"
			},
			{
				typeof(object),
				"object"
			},
			{
				typeof(sbyte),
				"sbyte"
			},
			{
				typeof(short),
				"short"
			},
			{
				typeof(string),
				"string"
			},
			{
				typeof(uint),
				"uint"
			},
			{
				typeof(ulong),
				"ulong"
			},
			{
				typeof(ushort),
				"ushort"
			}
		};

		private static readonly Dictionary<string, string> FSharpTypeNames = new Dictionary<string, string>
		{
			{ "Unit", "void" },
			{ "FSharpOption", "Option" },
			{ "FSharpAsync", "Async" },
			{ "FSharpOption`1", "Option" },
			{ "FSharpAsync`1", "Async" }
		};

		public static string GetTypeDisplayName(Type type)
		{
			StringBuilder stringBuilder = new StringBuilder();
			ProcessType(stringBuilder, type);
			return stringBuilder.ToString();
		}

		private static void ProcessType(StringBuilder builder, Type type)
		{
			string value;
			if (type.IsGenericType)
			{
				Type underlyingType = Nullable.GetUnderlyingType(type);
				if (underlyingType != null)
				{
					ProcessType(builder, underlyingType);
					builder.Append('?');
				}
				else
				{
					Type[] genericArguments = type.GetGenericArguments();
					ProcessGenericType(builder, type, genericArguments, genericArguments.Length);
				}
			}
			else if (type.IsArray)
			{
				ProcessArrayType(builder, type);
			}
			else if (BuiltInTypeNames.TryGetValue(type, out value))
			{
				builder.Append(value);
			}
			else if (type.Namespace == "System")
			{
				builder.Append(type.Name);
			}
			else if (type.Assembly.ManifestModule.Name == "FSharp.Core.dll" && FSharpTypeNames.TryGetValue(type.Name, out value))
			{
				builder.Append(value);
			}
			else if (type.IsGenericParameter)
			{
				builder.Append(type.Name);
			}
			else
			{
				builder.Append(type.FullName ?? type.Name);
			}
		}

		private static void ProcessArrayType(StringBuilder builder, Type type)
		{
			Type type2 = type;
			while (type2.IsArray)
			{
				type2 = type2.GetElementType();
			}
			ProcessType(builder, type2);
			while (type.IsArray)
			{
				builder.Append('[');
				builder.Append(',', type.GetArrayRank() - 1);
				builder.Append(']');
				type = type.GetElementType();
			}
		}

		private static void ProcessGenericType(StringBuilder builder, Type type, Type[] genericArguments, int length)
		{
			int num = 0;
			if (type.IsNested)
			{
				num = type.DeclaringType.GetGenericArguments().Length;
			}
			if (type.IsNested)
			{
				ProcessGenericType(builder, type.DeclaringType, genericArguments, num);
				builder.Append('+');
			}
			else if (!string.IsNullOrEmpty(type.Namespace))
			{
				builder.Append(type.Namespace);
				builder.Append('.');
			}
			int num2 = type.Name.IndexOf('`');
			if (num2 <= 0)
			{
				builder.Append(type.Name);
				return;
			}
			if (type.Assembly.ManifestModule.Name == "FSharp.Core.dll" && FSharpTypeNames.TryGetValue(type.Name, out var value))
			{
				builder.Append(value);
			}
			else
			{
				builder.Append(type.Name, 0, num2);
			}
			builder.Append('<');
			for (int i = num; i < length; i++)
			{
				ProcessType(builder, genericArguments[i]);
				if (i + 1 != length)
				{
					builder.Append(',');
					if (!genericArguments[i + 1].IsGenericParameter)
					{
						builder.Append(' ');
					}
				}
			}
			builder.Append('>');
		}
	}
}
namespace HarmonyLib.Public.Patching
{
	public class HarmonyManipulator
	{
		private class PatchContext
		{
			public bool hasArgsArrayArg;

			public MethodInfo method;

			public bool wrapTryCatch;
		}

		private class ArgumentBoxInfo
		{
			public int index;

			public bool isByRef;

			public VariableDefinition tmpVar;

			public Type type;
		}

		private static readonly MethodInfo GetMethodFromHandle1 = typeof(MethodBase).GetMethod("GetMethodFromHandle", new Type[1] { typeof(RuntimeMethodHandle) });

		private static readonly MethodInfo GetMethodFromHandle2 = typeof(MethodBase).GetMethod("GetMethodFromHandle", new Type[2]
		{
			typeof(RuntimeMethodHandle),
			typeof(RuntimeTypeHandle)
		});

		private static readonly string InstanceParam = "__instance";

		private static readonly string OriginalMethodParam = "__originalMethod";

		private static readonly string RunOriginalParam = "__runOriginal";

		private static readonly string ResultVar = "__result";

		private static readonly string ArgsArrayVar = "__args";

		private static readonly string StateVar = "__state";

		private static readonly string ExceptionVar = "__exception";

		private static readonly string ParamIndexPrefix = "__";

		private static readonly string InstanceFieldPrefix = "___";

		private static readonly MethodInfo LogPatchExceptionMethod = AccessTools.Method(typeof(HarmonyManipulator), "LogPatchException");

		private readonly bool debug;

		private readonly string[] dumpPaths;

		private readonly PatchInfo patchInfo;

		private readonly Dictionary<string, VariableDefinition> variables = new Dictionary<string, VariableDefinition>();

		private ILContext ctx;

		private List<PatchContext> finalizers;

		private ILEmitter il;

		private List<PatchContext> ilManipulators;

		private MethodBase original;

		private List<PatchContext> postfixes;

		private List<PatchContext> prefixes;

		private List<PatchContext> transpilers;

		public HarmonyManipulator(PatchInfo patchInfo)
		{
			this.patchInfo = patchInfo;
			debug = patchInfo.Debugging;
			dumpPaths = patchInfo.DebugEmitPaths;
		}

		public static void Manipulate(MethodBase original, PatchInfo patchInfo, ILContext ctx)
		{
			new HarmonyManipulator(patchInfo).Process(ctx, original);
		}

		public static void Manipulate(MethodBase original, ILContext ctx)
		{
			Manipulate(original, original.GetPatchInfo(), ctx);
		}

		private static void LogPatchException(object errorObject, string patch)
		{
			Logger.LogText(Logger.LogChannel.Error, $"Error while running {patch}. Error: {errorObject}");
		}

		public void Process(ILContext ilContext, MethodBase originalMethod)
		{
			ctx = ilContext;
			original = originalMethod;
			il = new ILEmitter(ctx.IL);
			SortPatches();
			Logger.Log(Logger.LogChannel.Info, delegate
			{
				StringBuilder sb = new StringBuilder();
				sb.AppendLine($"Patching {original.FullDescription()} with {prefixes.Count} prefixes, {postfixes.Count} postfixes, {transpilers.Count} transpilers, {finalizers.Count} finalizers");
				Print(prefixes, "prefixes");
				Print(postfixes, "postfixes");
				Print(transpilers, "transpilers");
				Print(finalizers, "finalizers");
				Print(ilManipulators, "ilmanipulators");
				return sb.ToString();
				void Print(ICollection<PatchContext> list, string type)
				{
					if (list.Count == 0)
					{
						return;
					}
					sb.AppendLine($"{list.Count} {type}:");
					foreach (PatchContext item in list)
					{
						sb.AppendLine("* " + item.method.FullDescription());
					}
				}
			}, debug);
			WriteImpl();
			if (dumpPaths.Length != 0)
			{
				CecilEmitter.Dump(ctx.Method, dumpPaths, original);
			}
		}

		private bool WritePrefixes(ILEmitter.Label returnLabel)
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			if (prefixes.Count == 0)
			{
				return false;
			}
			Logger.Log(Logger.LogChannel.Info, () => "Writing prefixes", debug);
			il.emitBefore = il.IL.Body.Instructions[0];
			VariableDefinition val2;
			if (!variables.TryGetValue(ResultVar, out var value))
			{
				Type returnedType = AccessTools.GetReturnedType(original);
				val2 = (variables[ResultVar] = ((returnedType == typeof(void)) ? null : il.DeclareVariable(returnedType)));
				value = val2;
			}
			bool flag = prefixes.Any((PatchContext p) => p.method.ReturnType == typeof(bool) || p.method.GetParameters().Any((ParameterInfo pp) => pp.Name == RunOriginalParam && pp.ParameterType.OpenRefType() == typeof(bool)));
			val2 = (variables[RunOriginalParam] = il.DeclareVariable(typeof(bool)));
			VariableDefinition varDef = val2;
			il.Emit(OpCodes.Ldc_I4_1);
			il.Emit(OpCodes.Stloc, varDef);
			ILEmitter.Label label = ((value != null) ? il.DeclareLabel() : returnLabel);
			foreach (PatchContext prefix in prefixes)
			{
				MethodInfo method = prefix.method;
				ILEmitter.Label label2 = il.DeclareLabel();
				il.MarkLabel(label2);
				EmitCallParameter(method, allowFirsParamPassthrough: false, out var tmpObjectVar, out var tmpBoxVars);
				il.Emit(OpCodes.Call, method);
				if (prefix.hasArgsArrayArg)
				{
					EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
				}
				EmitResultUnbox(tmpObjectVar, value);
				EmitArgUnbox(tmpBoxVars);
				if (!AccessTools.IsVoid(method.ReturnType))
				{
					if (method.ReturnType != typeof(bool))
					{
						throw new InvalidHarmonyPatchArgumentException($"Prefix patch {method.FullDescription()} has return type {method.ReturnType}, but only `bool` or `void` are permitted", original, method);
					}
					if (flag)
					{
						il.Emit(OpCodes.Ldloc, varDef);
						il.Emit(OpCodes.And);
						il.Emit(OpCodes.Stloc, varDef);
					}
				}
				if (prefix.wrapTryCatch)
				{
					EmitTryCatchWrapper(method, label2);
				}
			}
			if (!flag)
			{
				return false;
			}
			il.Emit(OpCodes.Ldloc, varDef);
			il.Emit(OpCodes.Brfalse, label);
			if (value == null)
			{
				return true;
			}
			il.emitBefore = il.IL.Body.Instructions[il.IL.Body.Instructions.Count - 1];
			il.MarkLabel(label);
			il.Emit(OpCodes.Ldloc, value);
			return true;
		}

		private void EmitTryCatchWrapper(MethodBase target, ILEmitter.Label start)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			ILEmitter.ExceptionBlock block = il.BeginExceptionBlock(start);
			il.BeginHandler(block, (ExceptionHandlerType)0, typeof(object));
			il.Emit(OpCodes.Ldstr, target.FullDescription());
			il.Emit(OpCodes.Call, LogPatchExceptionMethod);
			il.EndExceptionBlock(block);
			il.Emit(OpCodes.Nop);
		}

		private void EmitArgUnbox(List<ArgumentBoxInfo> boxInfo)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (boxInfo == null)
			{
				return;
			}
			foreach (ArgumentBoxInfo item in boxInfo)
			{
				if (item.isByRef)
				{
					il.Emit(OpCodes.Ldarg, item.index);
				}
				il.Emit(OpCodes.Ldloc, item.tmpVar);
				il.Emit(OpCodes.Unbox_Any, item.type);
				if (item.isByRef)
				{
					il.Emit(OpCodes.Stobj, item.type);
				}
				else
				{
					il.Emit(OpCodes.Starg, item.index);
				}
			}
		}

		private void EmitResultUnbox(VariableDefinition tmp, VariableDefinition result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (tmp != null)
			{
				il.Emit(OpCodes.Ldloc, tmp);
				il.Emit(OpCodes.Unbox_Any, AccessTools.GetReturnedType(original));
				il.Emit(OpCodes.Stloc, result);
			}
		}

		private void WriteTranspilers()
		{
			if (transpilers.Count == 0)
			{
				return;
			}
			Logger.Log(Logger.LogChannel.Info, () => "Transpiling " + original.FullDescription(), debug);
			ILManipulator iLManipulator = new ILManipulator(ctx.Body, debug);
			foreach (PatchContext transpiler in transpilers)
			{
				iLManipulator.AddTranspiler(transpiler.method);
			}
			iLManipulator.WriteTo(ctx.Body, original);
		}

		private (ILEmitter.Label, bool) MakeReturnLabel()
		{
			//IL_0022: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (ctx.IL.Body.Instructions.Count == 0)
			{
				il.Emit(OpCodes.Nop);
			}
			ILEmitter.Label label = il.DeclareLabel();
			label.emitted = false;
			bool item = false;
			foreach (Instruction item2 in ((IEnumerable<Instruction>)il.IL.Body.Instructions).Where((Instruction ins) => ILPatternMatchingExt.MatchRet(ins)))
			{
				item = true;
				item2.OpCode = OpCodes.Br;
				item2.Operand = label.instruction;
				label.targets.Add(item2);
			}
			label.instruction = Instruction.Create(OpCodes.Ret);
			il.IL.Append(label.instruction);
			return (label, item);
		}

		private void WriteImpl()
		{
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (original == null)
				{
					throw new ArgumentException("original");
				}
				Logger.Log(Logger.LogChannel.Info, () => "Running ILHook manipulator on " + original.FullDescription(), debug);
				WriteTranspilers();
				if (prefixes.Count + postfixes.Count + finalizers.Count + ilManipulators.Count == 0)
				{
					Logger.Log(Logger.LogChannel.IL, () => "Generated patch (" + ((MemberReference)ctx.Method).FullName + "):\n" + ctx.Body.ToILDasmString(), debug);
					return;
				}
				var (label, emitResultStore) = MakeReturnLabel();
				foreach (PatchContext item in prefixes.Union(postfixes).Union(finalizers))
				{
					ParameterInfo[] parameters = item.method.GetParameters();
					ParameterInfo parameterInfo = parameters.FirstOrDefault((ParameterInfo p) => p.Name == ArgsArrayVar);
					if (parameterInfo != null)
					{
						if (parameterInfo.ParameterType != typeof(object[]))
						{
							throw new InvalidHarmonyPatchArgumentException("Patch " + item.method.FullDescription() + " defines __args list, but only type `object[]` is permitted", original, item.method);
						}
						variables[ArgsArrayVar] = il.DeclareVariable(typeof(object[]));
					}
					if (item.method.DeclaringType?.FullName == null || variables.ContainsKey(item.method.DeclaringType.FullName))
					{
						continue;
					}
					foreach (ParameterInfo item2 in parameters.Where((ParameterInfo patchParam) => patchParam.Name == StateVar))
					{
						variables[item.method.DeclaringType.FullName] = il.DeclareVariable(item2.ParameterType.OpenRefType());
					}
				}
				WritePrefixes(label);
				WritePostfixes(label, emitResultStore);
				WriteFinalizers(label);
				il.MarkLabel(label);
				il.SetOpenLabelsTo(ctx.Instrs[ctx.Instrs.Count - 1]);
				if (variables.TryGetValue(ArgsArrayVar, out var value))
				{
					il.emitBefore = ctx.Instrs[0];
					EmitInitArgsArray();
					il.Emit(OpCodes.Stloc, value);
				}
				ApplyManipulators(ctx, original, ilManipulators.Select((PatchContext m) => m.method).ToList(), label);
				Logger.Log(Logger.LogChannel.IL, () => "Generated patch (" + ((MemberReference)ctx.Method).FullName + "):\n" + ctx.Body.ToILDasmString(), debug);
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Exception e = ex2;
				Logger.Log(Logger.LogChannel.Error, () => $"Failed to patch {original.FullDescription()}: {e}", debug);
				throw HarmonyException.Create(e, ctx.Body);
			}
		}

		internal static void ApplyManipulators(ILContext ctx, MethodBase original, List<MethodInfo> ilManipulators, ILEmitter.Label retLabel)
		{
			ILLabel item = ctx.DefineLabel(retLabel?.instruction) ?? ctx.DefineLabel(((IEnumerable<Instruction>)ctx.Body.Instructions).Last());
			foreach (MethodInfo ilManipulator in ilManipulators)
			{
				List<object> list = new List<object>();
				foreach (Type item2 in from p in ilManipulator.GetParameters()
					select p.ParameterType)
				{
					if (item2.IsAssignableFrom(typeof(ILContext)))
					{
						list.Add(ctx);
					}
					if (item2.IsAssignableFrom(typeof(MethodBase)))
					{
						list.Add(original);
					}
					if (item2.IsAssignableFrom(typeof(ILLabel)))
					{
						list.Add(item);
					}
				}
				ilManipulator.Invoke(null, list.ToArray());
			}
		}

		private void EmitOutParameter(int arg, Type t)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			t = t.OpenRefType();
			il.Emit(OpCodes.Ldarg, arg);
			if (AccessTools.IsStruct(t))
			{
				il.Emit(OpCodes.Initobj, t);
			}
			else if (AccessTools.IsValue(t))
			{
				var (num, opcode, opcode2) = ((t == typeof(float)) ? (0.0, OpCodes.Ldc_R4, OpCodes.Stind_R4) : ((t == typeof(double)) ? (0.0, OpCodes.Ldc_R8, OpCodes.Stind_R8) : ((!(t == typeof(long))) ? (0.0, OpCodes.Ldc_I4, t.GetCecilStoreOpCode()) : (0.0, OpCodes.Ldc_I8, OpCodes.Stind_I8))));
				il.EmitUnsafe(opcode, num);
				il.Emit(opcode2);
			}
			else
			{
				il.Emit(OpCodes.Ldnull);
				il.Emit(OpCodes.Stind_Ref);
			}
		}

		private void EmitInitArgsArray()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			ParameterInfo[] parameters = original.GetParameters();
			int num = ((!original.IsStatic) ? 1 : 0);
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo parameterInfo = parameters[i];
				if (parameterInfo.IsOut || parameterInfo.IsRetval)
				{
					EmitOutParameter(i + num, parameterInfo.ParameterType.OpenRefType());
				}
			}
			il.Emit(OpCodes.Ldc_I4, parameters.Length);
			il.Emit(OpCodes.Newarr, typeof(object));
			for (int j = 0; j < parameters.Length; j++)
			{
				Type parameterType = parameters[j].ParameterType;
				Type type = parameterType.OpenRefType();
				il.Emit(OpCodes.Dup);
				il.Emit(OpCodes.Ldc_I4, j);
				il.Emit(OpCodes.Ldarg, j + num);
				if (parameterType.IsByRef)
				{
					if (AccessTools.IsStruct(type))
					{
						il.Emit(OpCodes.Ldobj, type);
					}
					else
					{
						il.Emit(type.GetCecilLoadOpCode());
					}
				}
				if (type.IsValueType)
				{
					il.Emit(OpCodes.Box, type);
				}
				il.Emit(OpCodes.Stelem_Ref);
			}
		}

		private bool WriteFinalizers(ILEmitter.Label returnLabel)
		{
			//IL_00a9: 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_01d6: 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_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: 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_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: 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_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			if (finalizers.Count == 0)
			{
				return false;
			}
			Logger.Log(Logger.LogChannel.Info, () => "Writing finalizers", debug);
			variables[ExceptionVar] = il.DeclareVariable(typeof(Exception));
			VariableDefinition varDef = il.DeclareVariable(typeof(bool));
			il.emitBefore = il.IL.Body.Instructions[0];
			il.Emit(OpCodes.Ldc_I4_0);
			il.Emit(OpCodes.Stloc, varDef);
			il.emitBefore = il.IL.Body.Instructions[il.IL.Body.Instructions.Count - 1];
			il.MarkLabel(returnLabel);
			if (!variables.TryGetValue(ResultVar, out var returnValueVar))
			{
				Type returnedType = AccessTools.GetReturnedType(original);
				VariableDefinition val2 = (variables[ResultVar] = ((returnedType == typeof(void)) ? null : il.DeclareVariable(returnedType)));
				returnValueVar = val2;
			}
			ILEmitter.ExceptionBlock block = il.BeginExceptionBlock(il.DeclareLabelFor(il.IL.Body.Instructions[0]));
			if (returnValueVar != null)
			{
				il.Emit(OpCodes.Stloc, returnValueVar);
			}
			WriteFinalizerCalls(suppressExceptions: false);
			il.Emit(OpCodes.Ldc_I4_1);
			il.Emit(OpCodes.Stloc, varDef);
			ILEmitter.Label label = il.DeclareLabel();
			il.Emit(OpCodes.Ldloc, variables[ExceptionVar]);
			il.Emit(OpCodes.Brfalse, label);
			il.Emit(OpCodes.Ldloc, variables[ExceptionVar]);
			il.Emit(OpCodes.Throw);
			il.MarkLabel(label);
			il.BeginHandler(block, (ExceptionHandlerType)0, typeof(Exception));
			il.Emit(OpCodes.Stloc, variables[ExceptionVar]);
			il.Emit(OpCodes.Ldloc, varDef);
			ILEmitter.Label label2 = il.DeclareLabel();
			il.Emit(OpCodes.Brtrue, label2);
			bool num = WriteFinalizerCalls(suppressExceptions: true);
			il.MarkLabel(label2);
			label = il.DeclareLabel();
			il.Emit(OpCodes.Ldloc, variables[ExceptionVar]);
			il.Emit(OpCodes.Brfalse, label);
			if (num)
			{
				il.Emit(OpCodes.Rethrow);
			}
			else
			{
				il.Emit(OpCodes.Ldloc, variables[ExceptionVar]);
				il.Emit(OpCodes.Throw);
			}
			il.MarkLabel(label);
			il.EndExceptionBlock(block);
			if (returnValueVar != null)
			{
				il.Emit(OpCodes.Ldloc, returnValueVar);
			}
			return true;
			bool WriteFinalizerCalls(bool suppressExceptions)
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				bool result = true;
				foreach (PatchContext finalizer in finalizers)
				{
					MethodInfo method = finalizer.method;
					ILEmitter.Label label3 = il.DeclareLabel();
					il.MarkLabel(label3);
					EmitCallParameter(method, allowFirsParamPassthrough: false, out var tmpObjectVar, out var tmpBoxVars);
					il.Emit(OpCodes.Call, method);
					if (finalizer.hasArgsArrayArg)
					{
						EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
					}
					EmitResultUnbox(tmpObjectVar, returnValueVar);
					EmitArgUnbox(tmpBoxVars);
					if (method.ReturnType != typeof(void))
					{
						il.Emit(OpCodes.Stloc, variables[ExceptionVar]);
						result = false;
					}
					if (suppressExceptions || finalizer.wrapTryCatch)
					{
						EmitTryCatchWrapper(method, label3);
					}
				}
				return result;
			}
		}

		private void WritePostfixes(ILEmitter.Label returnLabel, bool emitResultStore)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			if (postfixes.Count == 0)
			{
				return;
			}
			Logger.Log(Logger.LogChannel.Info, () => "Writing postfixes", debug);
			il.emitBefore = il.IL.Body.Instructions[il.IL.Body.Instructions.Count - 1];
			il.MarkLabel(returnLabel);
			if (!variables.TryGetValue(ResultVar, out var value))
			{
				Type returnedType = AccessTools.GetReturnedType(original);
				VariableDefinition val2 = (variables[ResultVar] = ((returnedType == typeof(void)) ? null : il.DeclareVariable(returnedType)));
				value = val2;
			}
			if (value != null && emitResultStore)
			{
				il.Emit(OpCodes.Stloc, value);
			}
			if (!variables.ContainsKey(RunOriginalParam))
			{
				VariableDefinition val2 = (variables[RunOriginalParam] = il.DeclareVariable(typeof(bool)));
				VariableDefinition varDef = val2;
				il.Emit(OpCodes.Ldc_I4_1);
				il.Emit(OpCodes.Stloc, varDef);
			}
			foreach (PatchContext item in postfixes.Where((PatchContext p) => p.method.ReturnType == typeof(void)))
			{
				MethodInfo method = item.method;
				ILEmitter.Label label = il.DeclareLabel();
				il.MarkLabel(label);
				EmitCallParameter(method, allowFirsParamPassthrough: true, out var tmpObjectVar, out var tmpBoxVars);
				il.Emit(OpCodes.Call, method);
				if (item.hasArgsArrayArg)
				{
					EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
				}
				EmitResultUnbox(tmpObjectVar, value);
				EmitArgUnbox(tmpBoxVars);
				if (item.wrapTryCatch)
				{
					EmitTryCatchWrapper(method, label);
				}
			}
			if (value != null)
			{
				il.Emit(OpCodes.Ldloc, value);
			}
			foreach (PatchContext item2 in postfixes.Where((PatchContext p) => p.method.ReturnType != typeof(void)))
			{
				MethodInfo method2 = item2.method;
				if (item2.wrapTryCatch)
				{
					il.Emit(OpCodes.Stloc, value);
				}
				ILEmitter.Label label2 = il.DeclareLabel();
				il.MarkLabel(label2);
				if (item2.wrapTryCatch)
				{
					il.Emit(OpCodes.Ldloc, value);
				}
				EmitCallParameter(method2, allowFirsParamPassthrough: true, out var tmpObjectVar2, out var tmpBoxVars2);
				il.Emit(OpCodes.Call, method2);
				if (item2.hasArgsArrayArg)
				{
					EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
				}
				EmitResultUnbox(tmpObjectVar2, value);
				EmitArgUnbox(tmpBoxVars2);
				ParameterInfo parameterInfo = method2.GetParameters().FirstOrDefault();
				if (parameterInfo == null || method2.ReturnType != parameterInfo.ParameterType)
				{
					if (parameterInfo != null)
					{
						throw new InvalidHarmonyPatchArgumentException("Return type of pass through postfix " + method2.FullDescription() + " does not match type of its first parameter", original, method2);
					}
					throw new InvalidHarmonyPatchArgumentException("Postfix patch " + method2.FullDescription() + " must have `void` as return type", original, method2);
				}
				if (item2.wrapTryCatch)
				{
					il.Emit(OpCodes.Stloc, value);
					EmitTryCatchWrapper(method2, label2);
					il.Emit(OpCodes.Ldloc, value);
				}
			}
		}

		private void SortPatches()
		{
			Patch[] patches2;
			Patch[] patches3;
			Patch[] patches4;
			Patch[] patches5;
			Patch[] patches6;
			lock (patchInfo)
			{
				patches2 = patchInfo.prefixes.ToArray();
				patches3 = patchInfo.postfixes.ToArray();
				patches4 = patchInfo.transpilers.ToArray();
				patches5 = patchInfo.finalizers.ToArray();
				patches6 = patchInfo.ilmanipulators.ToArray();
			}
			prefixes = Sort(original, patches2, debug);
			postfixes = Sort(original, patches3, debug);
			transpilers = Sort(original, patches4, debug);
			finalizers = Sort(original, patches5, debug);
			ilManipulators = Sort(original, patches6, debug);
			static List<PatchContext> Sort(MethodBase original, Patch[] patches, bool debug)
			{
				return (from p in PatchFunctions.GetSortedPatchMethodsAsPatches(original, patches, debug)
					select new
					{
						method = p.GetMethod(original),
						origP = p
					} into p
					select new PatchContext
					{
						method = p.method,
						wrapTryCatch = p.origP.wrapTryCatch,
						hasArgsArrayArg = p.method.GetParameters().Any((ParameterInfo par) => par.Name == ArgsArrayVar)
					}).ToList();
			}
		}

		private bool EmitOriginalBaseMethod()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (original is MethodInfo mInfo)
			{
				il.Emit(OpCodes.Ldtoken, mInfo);
			}
			else
			{
				if (!(original is ConstructorInfo cInfo))
				{
					return false;
				}
				il.Emit(OpCodes.Ldtoken, cInfo);
			}
			Type reflectedType = original.ReflectedType;
			if (reflectedType == null)
			{
				return false;
			}
			if (reflectedType.IsGenericType)
			{
				il.Emit(OpCodes.Ldtoken, reflectedType);
			}
			il.Emit(OpCodes.Call, reflectedType.IsGenericType ? GetMethodFromHandle2 : GetMethodFromHandle1);
			return true;
		}

		private void EmitAssignRefsFromArgsArray(VariableDefinition argsArrayVariable)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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)
			ParameterInfo[] parameters = original.GetParameters();
			int num = ((!original.IsStatic) ? 1 : 0);
			for (int i = 0; i < parameters.Length; i++)
			{
				Type parameterType = parameters[i].ParameterType;
				if (!parameterType.IsByRef)
				{
					continue;
				}
				parameterType = parameterType.OpenRefType();
				il.Emit(OpCodes.Ldarg, i + num);
				il.Emit(OpCodes.Ldloc, argsArrayVariable);
				il.Emit(OpCodes.Ldc_I4, i);
				il.Emit(OpCodes.Ldelem_Ref);
				if (parameterType.IsValueType)
				{
					il.Emit(OpCodes.Unbox_Any, parameterType);
					if (AccessTools.IsStruct(parameterType))
					{
						il.Emit(OpCodes.Stobj, parameterType);
					}
					else
					{
						il.Emit(parameterType.GetCecilStoreOpCode());
					}
				}
				else
				{
					il.Emit(OpCodes.Castclass, parameterType);
					il.Emit(OpCodes.Stind_Ref);
				}
			}
		}

		private void EmitCallParameter(MethodInfo patch, bool allowFirsParamPassthrough, out VariableDefinition tmpObjectVar, out List<ArgumentBoxInfo> tmpBoxVars)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: 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_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: 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_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0721: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_073a: Unknown result type (might be due to invalid IL or missing references)
			//IL_074c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_0794: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0597: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0770: Unknown result type (might be due to invalid IL or missing references)
			//IL_0780: Unknown result type (might be due to invalid IL or missing references)
			//IL_0883: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a18: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a35: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0954: Unknown result type (might be due to invalid IL or missing references)
			//IL_0966: Unknown result type (might be due to invalid IL or missing references)
			//IL_0987: Unknown result type (might be due to invalid IL or missing references)
			//IL_0999: Unknown result type (might be due to invalid IL or missing references)
			tmpObjectVar = null;
			tmpBoxVars = new List<ArgumentBoxInfo>();
			bool flag = !original.IsStatic;
			ParameterInfo[] parameters = original.GetParameters();
			string[] originalParameterNames = parameters.Select((ParameterInfo p) => p.Name).ToArray();
			List<ParameterInfo> list = patch.GetParameters().ToList();
			if (allowFirsParamPassthrough && patch.ReturnType != typeof(void) && list.Count > 0 && list[0].ParameterType == patch.ReturnType)
			{
				list.RemoveRange(0, 1);
			}
			foreach (ParameterInfo item in list)
			{
				if (item.Name == OriginalMethodParam)
				{
					if (!EmitOriginalBaseMethod())
					{
						il.Emit(OpCodes.Ldnull);
					}
					continue;
				}
				if (item.Name == InstanceParam)
				{
					if (original.IsStatic)
					{
						il.Emit(OpCodes.Ldnull);
						continue;
					}
					bool num = original.DeclaringType != null && AccessTools.IsStruct(original.DeclaringType);
					bool isByRef = item.ParameterType.IsByRef;
					if (num == isByRef)
					{
						il.Emit(OpCodes.Ldarg_0);
					}
					if (num && !isByRef)
					{
						il.Emit(OpCodes.Ldarg_0);
						il.Emit(OpCodes.Ldobj, original.DeclaringType);
					}
					if (!num && isByRef)
					{
						il.Emit(OpCodes.Ldarga, 0);
					}
					continue;
				}
				if (item.Name == ArgsArrayVar)
				{
					if (variables.TryGetValue(ArgsArrayVar, out var value))
					{
						il.Emit(OpCodes.Ldloc, value);
					}
					else
					{
						il.Emit(OpCodes.Ldnull);
					}
					continue;
				}
				if (item.Name.StartsWith(InstanceFieldPrefix, StringComparison.Ordinal))
				{
					string text = item.Name.Substring(InstanceFieldPrefix.Length);
					FieldInfo fieldInfo;
					if (text.All(char.IsDigit))
					{
						fieldInfo = AccessTools.DeclaredField(original.DeclaringType, int.Parse(text));
						if ((object)fieldInfo == null)
						{
							throw new ArgumentException("No field found at given index in class " + original.DeclaringType.FullName, text);
						}
					}
					else
					{
						fieldInfo = AccessTools.Field(original.DeclaringType, text);
						if ((object)fieldInfo == null)
						{
							throw new ArgumentException("No such field defined in class " + original.DeclaringType.FullName, text);
						}
					}
					if (fieldInfo.IsStatic)
					{
						il.Emit(item.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld, fieldInfo);
						continue;
					}
					il.Emit(OpCodes.Ldarg_0);
					il.Emit(item.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld, fieldInfo);
					continue;
				}
				if (item.Name == StateVar)
				{
					OpCode opcode = (item.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc);
					if (variables.TryGetValue(patch.DeclaringType.FullName, out var value2))
					{
						il.Emit(opcode, value2);
					}
					else
					{
						il.Emit(OpCodes.Ldnull);
					}
					continue;
				}
				if (item.Name == ResultVar)
				{
					Type returnedType = AccessTools.GetReturnedType(original);
					if (returnedType == typeof(void))
					{
						throw new Exception("Cannot get result from void method " + original.FullDescription());
					}
					Type type = item.ParameterType;
					if (type.IsByRef && !returnedType.IsByRef)
					{
						type = type.GetElementType();
					}
					if (!type.IsAssignableFrom(returnedType))
					{
						throw new Exception("Cannot assign method return type " + returnedType.FullName + " to " + ResultVar + " type " + type.FullName + " for method " + original.FullDescription());
					}
					OpCode opcode2 = ((item.ParameterType.IsByRef && !returnedType.IsByRef) ? OpCodes.Ldloca : OpCodes.Ldloc);
					if (returnedType.IsValueType && item.ParameterType == typeof(object).MakeByRefType())
					{
						opcode2 = OpCodes.Ldloc;
					}
					il.Emit(opcode2, variables[ResultVar]);
					if (returnedType.IsValueType)
					{
						if (item.ParameterType == typeof(object))
						{
							il.Emit(OpCodes.Box, returnedType);
						}
						else if (item.ParameterType == typeof(object).MakeByRefType())
						{
							il.Emit(OpCodes.Box, returnedType);
							tmpObjectVar = il.DeclareVariable(typeof(object));
							il.Emit(OpCodes.Stloc, tmpObjectVar);
							il.Emit(OpCodes.Ldloca, tmpObjectVar);
						}
					}
					continue;
				}
				if (variables.TryGetValue(item.Name, out var value3))
				{
					OpCode opcode3 = (item.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc);
					il.Emit(opcode3, value3);
					continue;
				}
				int result;
				if (item.Name.StartsWith(ParamIndexPrefix, StringComparison.Ordinal))
				{
					if (!int.TryParse(item.Name.Substring(ParamIndexPrefix.Length), out result))
					{
						throw new Exception("Parameter " + item.Name + " does not contain a valid index");
					}
					if (result < 0 || result >= parameters.Length)
					{
						throw new Exception($"No parameter found at index {result}");
					}
				}
				else
				{
					result = patch.GetArgumentIndex(originalParameterNames, item);
					if (result == -1)
					{
						HarmonyMethod mergedFromType = HarmonyMethodExtensions.GetMergedFromType(item.ParameterType);
						MethodType? methodType = mergedFromType.methodType;
						if (!methodType.HasValue)
						{
							mergedFromType.methodType = MethodType.Normal;
						}
						if (mergedFromType.GetOriginalMethod() is MethodInfo methodInfo)
						{
							ConstructorInfo constructor = item.ParameterType.GetConstructor(new Type[2]
							{
								typeof(object),
								typeof(IntPtr)
							});
							if (constructor != null)
							{
								Type declaringType = original.DeclaringType;
								if (methodInfo.IsStatic)
								{
									il.Emit(OpCodes.Ldnull);
								}
								else
								{
									il.Emit(OpCodes.Ldarg_0);
									if (declaringType.IsValueType)
									{
										il.Emit(OpCodes.Ldobj, declaringType);
										il.Emit(OpCodes.Box, declaringType);
									}
								}
								if (!methodInfo.IsStatic && !mergedFromType.nonVirtualDelegate)
								{
									il.Emit(OpCodes.Dup);
									il.Emit(OpCodes.Ldvirtftn, methodInfo);
								}
								else
								{
									il.Emit(OpCodes.Ldftn, methodInfo);
								}
								il.Emit(OpCodes.Newobj, constructor);
								continue;
							}
						}
						throw new Exception("Parameter \"" + item.Name + "\" not found in method " + original.FullDescription());
					}
				}
				Type parameterType = parameters[result].ParameterType;
				Type type2 = (parameterType.IsByRef ? parameterType.GetElementType() : parameterType);
				Type parameterType2 = item.ParameterType;
				Type type3 = (parameterType2.IsByRef ? parameterType2.GetElementType() : parameterType2);
				bool flag2 = !parameters[result].IsOut && !parameterType.IsByRef;
				bool flag3 = !item.IsOut && !parameterType2.IsByRef;
				bool flag4 = type2.IsValueType && !type3.IsValueType;
				int num2 = result + (flag ? 1 : 0);
				if (flag2 == flag3)
				{
					il.Emit(OpCodes.Ldarg, num2);
					if (flag4)
					{
						if (flag3)
						{
							il.Emit(OpCodes.Box, type2);
							continue;
						}
						il.Emit(OpCodes.Ldobj, type2);
						il.Emit(OpCodes.Box, type2);
						VariableDefinition val = il.DeclareVariable(type3);
						il.Emit(OpCodes.Stloc, val);
						il.Emit(OpCodes.Ldloca_S, val);
						tmpBoxVars.Add(new ArgumentBoxInfo
						{
							index = num2,
							type = type2,
							tmpVar = val,
							isByRef = true
						});
					}
				}
				else if (flag2 && !flag3)
				{
					if (flag4)
					{
						il.Emit(OpCodes.Ldarg, num2);
						il.Emit(OpCodes.Box, type2);
						VariableDefinition val2 = il.DeclareVariable(type3);
						il.Emit(OpCodes.Stloc, val2);
						il.Emit(OpCodes.Ldloca_S, val2);
						tmpBoxVars.Add(new ArgumentBoxInfo
						{
							index = num2,
							type = type2,
							tmpVar = val2,
							isByRef = false
						});
					}
					else
					{
						il.Emit(OpCodes.Ldarga, num2);
					}
				}
				else
				{
					il.Emit(OpCodes.Ldarg, num2);
					if (flag4)
					{
						il.Emit(OpCodes.Ldobj, type2);
						il.Emit(OpCodes.Box, type2);
					}
					else if (type2.IsValueType)
					{
						il.Emit(OpCodes.Ldobj, type2);
					}
					else
					{
						il.Emit(parameters[result].ParameterType.GetCecilLoadOpCode());
					}
				}
			}
		}
	}
	public class ManagedMethodPatcher : MethodPatcher
	{
		private MethodBody hookBody;

		private ILHook ilHook;

		public ManagedMethodPatcher(MethodBase original)
			: base(original)
		{
		}

		public override DynamicMethodDefinition PrepareOriginal()
		{
			return null;
		}

		public override MethodBase DetourTo(MethodBase replacement)
		{
			//IL_0016: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			if (ilHook == null)
			{
				ilHook = new ILHook(base.Original, new Manipulator(Manipulator), new ILHookConfig
				{
					ManualApply = true
				});
			}
			ILHookExtensions.SetIsApplied(ilHook, arg2: false);
			try
			{
				ilHook.Apply();
			}
			catch (Exception ex)
			{
				throw HarmonyException.Create(ex, hookBody);
			}
			return ilHook.GetCurrentTarget();
		}

		public override DynamicMethodDefinition CopyOriginal()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return new DynamicMethodDefinition(base.Original);
		}

		private void Manipulator(ILContext ctx)
		{
			hookBody = ctx.Body;
			HarmonyManipulator.Manipulate(base.Original, ctx);
		}

		public static void TryResolve(object sender, PatchManager.PatcherResolverEventArgs args)
		{
			if (args.Original.GetMethodBody() != null)
			{
				args.MethodPatcher = new ManagedMethodPatcher(args.Original);
			}
		}
	}
	public abstract class MethodPatcher
	{
		public MethodBase Original { get; }

		protected MethodPatcher(MethodBase original)
		{
			Original = original;
		}

		public abstract DynamicMethodDefinition PrepareOriginal();

		public abstract MethodBase DetourTo(MethodBase replacement);

		public abstract DynamicMethodDefinition CopyOriginal();
	}
	public class NativeDetourMethodPatcher : MethodPatcher
	{
		private static readonly Dictionary<int, Delegate> TrampolineCache = new Dictionary<int, Delegate>();

		private static int counter;

		private static readonly object CounterLock = new object();

		private static readonly MethodInfo GetTrampolineMethod = AccessTools.Method(typeof(NativeDetourMethodPatcher), "GetTrampoline");

		private string[] argTypeNames;

		private Type[] argTypes;

		private int currentOriginal = -1;

		private int newOriginal;

		private MethodInfo invokeTrampolineMethod;

		private NativeDetour nativeDetour;

		private Type returnType;

		private Type trampolineDelegateType;

		public NativeDetourMethodPatcher(MethodBase original)
			: base(original)
		{
			Init();
		}

		private void Init()
		{
			if (AccessTools.IsNetCoreRuntime)
			{
				Logger.Log(Logger.LogChannel.Warn, () => "Patch target " + base.Original.FullDescription() + " is marked as extern. Extern methods may not be patched because of inlining behaviour of coreclr (refer to https://github.com/dotnet/coreclr/pull/8263).If you need to patch externs, consider using pure NativeDetour instead.");
			}
			MethodBase original = base.Original;
			ParameterInfo[] parameters = original.GetParameters();
			int num = ((!original.IsStatic) ? 1 : 0);
			argTypes = new Type[parameters.Length + num];
			argTypeNames = new string[parameters.Length + num];
			returnType = (original as MethodInfo)?.ReturnType;
			if (!original.IsStatic)
			{
				argTypes[0] = Extensions.GetThisParamType(original);
				argTypeNames[0] = "this";
			}
			for (int i = 0; i < parameters.Length; i++)
			{
				argTypes[i + num] = parameters[i].ParameterType;
				argTypeNames[i + num] = parameters[i].Name;
			}
			trampolineDelegateType = DelegateTypeFactory.instance.CreateDelegateType(returnType, argTypes);
			invokeTrampolineMethod = AccessTools.Method(trampolineDelegateType, "Invoke");
		}

		public override DynamicMethodDefinition PrepareOriginal()
		{
			return GenerateManagedOriginal();
		}

		public override MethodBase DetourTo(MethodBase replacement)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			NativeDetour obj = nativeDetour;
			if (obj != null)
			{
				obj.Dispose();
			}
			nativeDetour = new NativeDetour(base.Original, replacement, new NativeDetourConfig
			{
				ManualApply = true
			});
			lock (TrampolineCache)
			{
				if (currentOriginal >= 0)
				{
					TrampolineCache.Remove(currentOriginal);
				}
				currentOriginal = newOriginal;
				TrampolineCache[currentOriginal] = CreateDelegate(trampolineDelegateType, nativeDetour.GenerateTrampoline((MethodBase)invokeTrampolineMethod));
			}
			nativeDetour.Apply();
			return replacement;
		}

		public override DynamicMethodDefinition CopyOriginal()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!(base.Original is MethodInfo meth))
			{
				return null;
			}
			DynamicMethodDefinition val = new DynamicMethodDefinition("OrigWrapper", returnType, argTypes);
			ILGenerator iLGenerator = val.GetILGenerator();
			for (int i = 0; i < argTypes.Length; i++)
			{
				iLGenerator.Emit(OpCodes.Ldarg, i);
			}
			iLGenerator.Emit(OpCodes.Call, meth);
			iLGenerator.Emit(OpCodes.Ret);
			return val;
		}

		private Delegate CreateDelegate(Type delegateType, MethodBase mb)
		{
			if (mb is DynamicMethod dynamicMethod)
			{
				return dynamicMethod.CreateDelegate(delegateType);
			}
			return Delegate.CreateDelegate(delegateType, (mb as MethodInfo) ?? throw new InvalidCastException($"Unexpected method type: {mb.GetType()}"));
		}

		private static Delegate GetTrampoline(int hash)
		{
			lock (TrampolineCache)
			{
				return TrampolineCache[hash];
			}
		}

		private DynamicMethodDefinition GenerateManagedOriginal()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			MethodBase original = base.Original;
			lock (CounterLock)
			{
				newOriginal = counter;
				counter++;
			}
			DynamicMethodDefinition val = new DynamicMethodDefinition($"NativeDetour_Wrapper<{Extensions.GetID(original, (string)null, (string)null, true, false, true)}>?{newOriginal}", returnType, argTypes);
			MethodDefinition definition = val.Definition;
			for (int i = 0; i < argTypeNames.Length; i++)
			{
				((ParameterReference)((MethodReference)definition).Parameters[i]).Name = argTypeNames[i];
			}
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldc_I4, newOriginal);
			iLGenerator.Emit(OpCodes.Call, GetTrampolineMethod);
			for (int j = 0; j < argTypes.Length; j++)
			{
				iLGenerator.Emit(OpCodes.Ldarg, j);
			}
			iLGenerator.Emit(OpCodes.Call, invokeTrampolineMethod);
			iLGenerator.Emit(OpCodes.Ret);
			return val;
		}

		public static void TryResolve(object sender, PatchManager.PatcherResolverEventArgs args)
		{
			if (args.Original.GetMethodBody() == null)
			{
				args.MethodPatcher = new NativeDetourMethodPatcher(args.Original);
			}
		}
	}
	public static class PatchManager
	{
		public class PatcherResolverEventArgs : EventArgs
		{
			public MethodBase Original { get; internal set; }

			public MethodPatcher MethodPatcher { get; set; }
		}

		private static readonly Dictionary<MethodBase, PatchInfo> PatchInfos;

		private static readonly Dictionary<MethodBase, MethodPatcher> MethodPatchers;

		private static readonly List<KeyValuePair<WeakReference, MethodBase>> ReplacementToOriginals;

		private static FieldInfo methodAddress;

		public static event EventHandler<PatcherResolverEventArgs> ResolvePatcher;

		static PatchManager()
		{
			PatchInfos = new Dictionary<MethodBase, PatchInfo>();
			MethodPatchers = new Dictionary<MethodBase, MethodPatcher>();
			ReplacementToOriginals = new List<KeyValuePair<WeakReference, MethodBase>>();
			ResolvePatcher += ManagedMethodPatcher.TryResolve;
			ResolvePatcher += NativeDetourMethodPatcher.TryResolve;
		}

		public static MethodPatcher GetMethodPatcher(this MethodBase methodBase)
		{
			lock (MethodPatchers)
			{
				if (MethodPatchers.TryGetValue(methodBase, out var value))
				{
					return value;
				}
				PatcherResolverEventArgs patcherResolverEventArgs = new PatcherResolverEventArgs
				{
					Original = methodBase
				};
				PatchManager.ResolvePatcher?.Invoke(null, patcherResolverEventArgs);
				if (patcherResolverEventArgs.MethodPatcher == null)
				{
					throw new NullReferenceException("No suitable patcher found for " + methodBase.FullDescription());
				}
				return MethodPatchers[methodBase] = patcherResolverEventArgs.MethodPatcher;
			}
		}

		public static PatchInfo GetPatchInfo(this MethodBase methodBase)
		{
			lock (PatchInfos)
			{
				return PatchInfos.GetValueSafe(methodBase);
			}
		}

		public static PatchInfo ToPatchInfo(this MethodBase methodBase)
		{
			lock (PatchInfos)
			{
				if (PatchInfos.TryGetValue(methodBase, out var value))
				{
					return value;
				}
				return PatchInfos[methodBase] = new PatchInfo();
			}
		}

		public static IEnumerable<MethodBase> GetPatchedMethods()
		{
			lock (PatchInfos)
			{
				return PatchInfos.Keys.ToList();
			}
		}

		internal static MethodBase GetOriginal(MethodInfo replacement)
		{
			lock (ReplacementToOriginals)
			{
				ReplacementToOriginals.RemoveAll((KeyValuePair<WeakReference, MethodBase> kv) => !kv.Key.IsAlive);
				foreach (KeyValuePair<WeakReference, MethodBase> replacementToOriginal in ReplacementToOriginals)
				{
					if (replacementToOriginal.Key.Target as MethodInfo == replacement)
					{
						return replacementToOriginal.Value;
					}
				}
				return null;
			}
		}

		internal static MethodBase FindReplacement(StackFrame frame)
		{
			if ((object)methodAddress == null)
			{
				methodAddress = typeof(StackFrame).GetField("methodAddress", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			MethodBase method = frame.GetMethod();
			long methodStart = 0L;
			if ((object)method == null)
			{
				if (methodAddress == null)
				{
					return null;
				}
				methodStart = (long)methodAddress.GetValue(frame);
			}
			else
			{
				MethodBase identifiable = DetourHelper.Runtime.GetIdentifiable(method);
				methodStart = DetourHelper.GetNativeStart(identifiable).ToInt64();
			}
			if (methodStart == 0L)
			{
				return method;
			}
			lock (ReplacementToOriginals)
			{
				return ReplacementToOriginals.FirstOrDefault((KeyValuePair<WeakReference, MethodBase> kv) => kv.Key.IsAlive && DetourHelper.GetNativeStart((MethodBase)kv.Key.Target).ToInt64() == methodStart).Key.Target as MethodBase;
			}
		}

		internal static void AddReplacementOriginal(MethodBase original, MethodInfo replacement)
		{
			if (replacement == null)
			{
				return;
			}
			lock (ReplacementToOriginals)
			{
				ReplacementToOriginals.Add(new KeyValuePair<WeakReference, MethodBase>(new WeakReference(replacement), original));
			}
		}

		public static void ClearAllPatcherResolvers()
		{
			PatchManager.ResolvePatcher = null;
		}
	}
}
namespace HarmonyLib.Internal.RuntimeFixes
{
	internal static class StackTraceFixes
	{
		private static bool _applied;

		private static readonly Dictionary<MethodBase, MethodBase> RealMethodMap = new Dictionary<MethodBase, MethodBase>();

		private static Func<Assembly> _realGetAss;

		private static Func<StackFrame, MethodBase> _origGetMethod;

		private static Action<object> _origRefresh;

		public static void Install()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (!_applied)
			{
				try
				{
					_origRefresh = new Detour((MethodBase)AccessTools.Method(AccessTools.Inner(typeof(ILHook), "Context"), "Refresh"), (MethodBase)AccessTools.Method(typeof(StackTraceFixes), "OnILChainRefresh")).GenerateTrampoline<Action<object>>();
					_origGetMethod = new Detour((MethodBase)AccessTools.Method(typeof(StackFrame), "GetMethod"), (MethodBase)AccessTools.Method(typeof(StackTraceFixes), "GetMethodFix")).GenerateTrampoline<Func<StackFrame, MethodBase>>();
					_realGetAss = new NativeDetour((MethodBase)AccessTools.Method(typeof(Assembly), "GetExecutingAssembly"), (MethodBase)AccessTools.Method(typeof(StackTraceFixes), "GetAssemblyFix")).GenerateTrampoline<Func<Assembly>>();
				}
				catch (Exception ex)
				{
					Logger.LogText(Logger.LogChannel.Error, "Failed to apply stack trace fix: (" + ex.GetType().FullName + ") " + ex.Message);
				}
				_applied = true;
			}
		}

		private static MethodBase GetMethodFix(StackFrame self)
		{
			MethodBase methodBase = _origGetMethod(self);
			if (methodBase == null)
			{
				return null;
			}
			lock (RealMethodMap)
			{
				MethodBase value;
				return RealMethodMap.TryGetValue(methodBase, out value) ? value : methodBase;
			}
		}

		private static Assembly GetAssemblyFix()
		{
			return new StackFrame(1).GetMethod()?.Module.Assembly ?? _realGetAss();
		}

		private static void OnILChainRefresh(object self)
		{
			_origRefresh(self);
			object? value = AccessTools.Field(self.GetType(), "Detour").GetValue(self);
			Detour val = (Detour)((value is Detour) ? value : null);
			if (val == null)
			{
				return;
			}
			lock (RealMethodMap)
			{
				RealMethodMap[val.Target] = val.Method;
			}
		}
	}
}
namespace HarmonyLib.Internal.Util
{
	internal static class CecilEmitter
	{
		private static readonly ConstructorInfo UnverifiableCodeAttributeConstructor = typeof(UnverifiableCodeAttribute).GetConstructor(Type.EmptyTypes);

		public static void Dump(MethodDefinition md, IEnumerable<string> dumpPaths, MethodBase original = null)
		{
			//IL_0085: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Expected O, but got Unknown
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Expected O, but got Unknown
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Expected O, but got Unknown
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Expected O, but got Unknown
			string text = string.Format("HarmonyDump.{0}.{1:X8}", Extensions.GetID((MethodReference)(object)md, (string)null, (string)null, false, true).Replace(":", "_").Replace(" ", "_"), Guid.NewGuid().GetHashCode());
			string arg = (original?.Name ?? ((MemberReference)md).Name).Replace('.', '_');
			ModuleDefinition module = ModuleDefinition.CreateModule(text, new ModuleParameters
			{
				Kind = (ModuleKind)0,
				ReflectionImporterProvider = MMReflectionImporter.ProviderNoDefault
			});
			try
			{
				module.Assembly.CustomAttributes.Add(new CustomAttribute(module.ImportReference((MethodBase)UnverifiableCodeAttributeConstructor)));
				int hashCode = Guid.NewGuid().GetHashCode();
				TypeDefinition val = new TypeDefinition("", $"HarmonyDump<{arg}>?{hashCode}", (TypeAttributes)385)
				{
					BaseType = module.TypeSystem.Object
				};
				module.Types.Add(val);
				MethodDefinition clone = null;
				TypeReference val2 = new TypeReference("System.Runtime.CompilerServices", "IsVolatile", module, module.TypeSystem.CoreLibrary);
				Relinker val3 = (Relinker)((IMetadataTokenProvider mtp, IGenericParameterProvider _) => (IMetadataTokenProvider)((mtp != md) ? ((object)Extensions.ImportReference(module, mtp)) : ((object)clone)));
				clone = new MethodDefinition(original?.Name ?? ("_" + ((MemberReference)md).Name.Replace(".", "_")), md.Attributes, module.TypeSystem.Void)
				{
					MethodReturnType = ((MethodReference)md).MethodReturnType,
					Attributes = (MethodAttributes)150,
					ImplAttributes = (MethodImplAttributes)0,
					DeclaringType = val,
					HasThis = false
				};
				val.Methods.Add(clone);
				Enumerator<ParameterDefinition> enumerator = ((MethodReference)md).Parameters.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ParameterDefinition current = enumerator.Current;
						((MethodReference)clone).Parameters.Add(Extensions.Relink(Extensions.Clone(current), val3, (IGenericParameterProvider)(object)clone));
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				((MethodReference)clone).ReturnType = Extensions.Relink(((MethodReference)md).ReturnType, val3, (IGenericParameterProvider)(object)clone);
				MethodBody val5 = (clone.Body = Extensions.Clone(md.Body, clone));
				MethodBody val6 = val5;
				Enumerator<VariableDefinition> enumerator2 = clone.Body.Variables.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						VariableDefinition current2 = enumerator2.Current;
						((VariableReference)current2).VariableType = Extensions.Relink(((VariableReference)current2).VariableType, val3, (IGenericParameterProvider)(object)clone);
					}
				}
				finally
				{
					((IDisposable)enumerator2).Dispose();
				}
				foreach (ExceptionHandler item in ((IEnumerable<ExceptionHandler>)clone.Body.ExceptionHandlers).Where((ExceptionHandler handler) => handler.CatchType != null))
				{
					item.CatchType = Extensions.Relink(item.CatchType, val3, (IGenericParameterProvider)(object)clone);
				}
				Enumerator<Instruction> enumerator4 = val6.Instructions.GetEnumerator();
				try
				{
					while (enumerator4.MoveNext())
					{
						Instruction current4 = enumerator4.Current;
						object operand = current4.Operand;
						ParameterDefinition val7 = (ParameterDefinition)((operand is ParameterDefinition) ? operand : null);
						object obj;
						if (val7 == null)
						{
							ILLabel val8 = (ILLabel)((operand is ILLabel) ? operand : null);
							if (val8 == null)
							{
								IMetadataTokenProvider val9 = (IMetadataTokenProvider)((operand is IMetadataTokenProvider) ? operand : null);
								obj = ((val9 == null) ? operand : Extensions.Relink(val9, val3, (IGenericParameterProvider)(object)clone));
							}
							else
							{
								obj = val8.Target;
							}
						}
						else
						{
							obj = ((MethodReference)clone).Parameters[((ParameterReference)val7).Index];
						}
						operand = obj;
						Instruction previous = current4.Previous;
						OpCode? val10 = ((previous != null) ? new OpCode?(previous.OpCode) : null);
						OpCode @volatile = OpCodes.Volatile;
						if (val10.HasValue && (!val10.HasValue || val10.GetValueOrDefault() == @volatile))
						{
							FieldReference val11 = (FieldReference)((operand is FieldReference) ? operand : null);
							if (val11 != null)
							{
								TypeReference fieldType = val11.FieldType;
								TypeReference obj2 = ((fieldType is RequiredModifierType) ? fieldType : null);
								if (((obj2 != null) ? ((RequiredModifierType)obj2).ModifierType : null) != val2)
								{
									val11.FieldType = (TypeReference)new RequiredModifierType(val2, val11.FieldType);
								}
							}
						}
						current4.Operand = operand;
					}
				}
				finally
				{
					((IDisposable)enumerator4).Dispose();
				}
				if (((MethodReference)md).HasThis)
				{
					TypeReference val12 = (TypeReference)(object)md.DeclaringType;
					if (val12.IsValueType)
					{
						val12 = (TypeReference)new ByReferenceType(val12);
					}
					((MethodReference)clone).Parameters.Insert(0, new ParameterDefinition("<>_this", (ParameterAttributes)0, Extensions.Relink(val12, val3, (IGenericParameterProvider)(object)clone)));
				}
				foreach (string dumpPath in dumpPaths)
				{
					string fullPath = Path.GetFullPath(dumpPath);
					try
					{
						Directory.CreateDirectory(fullPath);
						using FileStream fileStream = File.OpenWrite(Path.Combine(fullPath, ((ModuleReference)module).Name + ".dll"));
						module.Write((Stream)fileStream);
					}
					catch (Exception ex)
					{
						Exception e = ex;
						Logger.Log(Logger.LogChannel.Error, () => $"Failed to dump {Extensions.GetID((MethodReference)(object)md, (string)null, (string)null, true, true)} to {fullPath}: {e}");
					}
				}
			}
			finally
			{
				if (module != null)
				{
					((IDisposable)module).Dispose();
				}
			}
		}
	}
	internal static class EmitterExtensions
	{
		private static DynamicMethodDefinition emitDMD;

		private static MethodInfo emitDMDMethod;

		private static Action<CecilILGenerator, OpCode, object> emitCodeDelegate;

		private static Dictionary<Type, OpCode> storeOpCodes;

		private static Dictionary<Type, OpCode> loadOpCodes;

		private static readonly ConstructorInfo c_LocalBuilder;

		private static readonly FieldInfo f_LocalBuilder_position;

		private static readonly FieldInfo f_LocalBuilder_is_pinned;

		private static int c_LocalBuilder_params;

		[MethodImpl(MethodImplOptions.Synchronized)]
		static EmitterExtensions()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: 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_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			storeOpCodes = new Dictionary<Type, OpCode>
			{
				[typeof(sbyte)] = OpCodes.Stind_I1,
				[typeof(byte)] = OpCodes.Stind_I1,
				[typeof(short)] = OpCodes.Stind_I2,
				[typeof(ushort)] = OpCodes.Stind_I2,
				[typeof(int)] = OpCodes.Stind_I4,
				[typeof(uint)] = OpCodes.Stind_I4,
				[typeof(long)] = OpCodes.Stind_I8,
				[typeof(ulong)] = OpCodes.Stind_I8,
				[typeof(float)] = OpCodes.Stind_R4,
				[typeof(double)] = OpCodes.Stind_R8
			};
			loadOpCodes = new Dictionary<Type, OpCode>
			{
				[typeof(sbyte)] = OpCodes.Ldind_I1,
				[typeof(byte)] = OpCodes.Ldind_I1,
				[typeof(short)] = OpCodes.Ldind_I2,
				[typeof(ushort)] = OpCodes.Ldind_I2,
				[typeof(int)] = OpCodes.Ldind_I4,
				[typeof(uint)] = OpCodes.Ldind_I4,
				[typeof(long)] = OpCodes.Ldind_I8,
				[typeof(ulong)] = OpCodes.Ldind_I8,
				[typeof(float)] = OpCodes.Ldind_R4,
				[typeof(double)] = OpCodes.Ldind_R8
			};
			c_LocalBuilder = (from c in typeof(LocalBuilder).GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				orderby c.GetParameters().Length descending
				select c).First();
			f_LocalBuilder_position = typeof(LocalBuilder).GetField("position", BindingFlags.Instance | BindingFlags.NonPublic);
			f_LocalBuilder_is_pinned = typeof(LocalBuilder).GetField("is_pinned", BindingFlags.Instance | BindingFlags.NonPublic);
			c_LocalBuilder_params = c_LocalBuilder.GetParameters().Length;
			if (emitDMD == null)
			{
				InitEmitterHelperDMD();
			}
		}

		public static OpCode GetCecilStoreOpCode(this Type t)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (t.IsEnum)
			{
				return OpCodes.Stind_I4;
			}
			if (!storeOpCodes.TryGetValue(t, out var value))
			{
				return OpCodes.Stind_Ref;
			}
			return value;
		}

		public static OpCode GetCecilLoadOpCode(this Type t)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (t.IsEnum)
			{
				return OpCodes.Ldind_I4;
			}
			if (!loadOpCodes.TryGetValue(t, out var value))
			{
				return OpCodes.Ldind_Ref;
			}
			return value;
		}

		public static Type OpenRefType(this Type t)
		{
			if (t.IsByRef)
			{
				return t.GetElementType();
			}
			return t;
		}

		private static void InitEmitterHelperDMD()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			emitDMD = new DynamicMethodDefinition("EmitOpcodeWithOperand", typeof(void), new Type[3]
			{
				typeof(CecilILGenerator),
				typeof(OpCode),
				typeof(object)
			});
			ILGenerator iLGenerator = emitDMD.GetILGenerator();
			Label label = iLGenerator.DefineLabel();
			iLGenerator.Emit(OpCodes.Ldarg_2);
			iLGenerator.Emit(OpCodes.Brtrue, label);
			iLGenerator.Emit(OpCodes.Ldstr, "Provided operand is null!");
			iLGenerator.Emit(OpCodes.Newobj, typeof(Exception).GetConstructor(new Type[1] { typeof(string) }));
			iLGenerator.Emit(OpCodes.Throw);
			foreach (MethodInfo item in from m in typeof(CecilILGenerator).GetMethods()
				where m.Name == "Emit"
				select m)
			{
				ParameterInfo[] parameters = item.GetParameters();
				if (parameters.Length != 2)
				{
					continue;
				}
				Type[] array = parameters.Select((ParameterInfo p) => p.ParameterType).ToArray();
				if (!(array[0] != typeof(OpCode)))
				{
					Type type = array[1];
					iLGenerator.MarkLabel(label);
					label = iLGenerator.DefineLabel();
					iLGenerator.Emit(OpCodes.Ldarg_2);
					iLGenerator.Emit(OpCodes.Isinst, type);
					iLGenerator.Emit(OpCodes.Brfalse, label);
					iLGenerator.Emit(OpCodes.Ldarg_2);
					if (type.IsValueType)
					{
						iLGenerator.Emit(OpCodes.Unbox_Any, type);
					}
					LocalBuilder local = iLGenerator.DeclareLocal(type);
					iLGenerator.Emit(OpCodes.Stloc, local);
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Ldarg_1);
					iLGenerator.Emit(OpCodes.Ldloc, local);
					iLGenerator.Emit(OpCodes.Callvirt, item);
					iLGenerator.Emit(OpCodes.Ret);
				}
			}
			iLGenerator.MarkLabel(label);
			iLGenerator.Emit(OpCodes.Ldstr, "The operand is none of the supported types!");
			iLGenerator.Emit(OpCodes.Newobj, typeof(Exception).GetConstructor(new Type[1] { typeof(string) }));
			iLGenerator.Emit(OpCodes.Throw);
			iLGenerator.Emit(OpCodes.Ret);
			emitDMDMethod = emitDMD.Generate();
			emitCodeDelegate = Extensions.CreateDelegate<Action<CecilILGenerator, OpCode, object>>((MethodBase)emitDMDMethod);
		}

		public static void Emit(this CecilILGenerator il, OpCode opcode, object operand)
		{
			emitCodeDelegate(il, opcode, operand);
		}

		public static void MarkBlockBefore(this CecilILGenerator il, ExceptionBlock block)
		{
			switch (block.blockType)
			{
			case ExceptionBlockType.BeginExceptionBlock:
				((ILGeneratorShim)il).BeginExceptionBlock();
				break;
			case ExceptionBlockType.BeginCatchBlock:
				((ILGeneratorShim)il).BeginCatchBlock(block.catchType);
				break;
			case ExceptionBlockType.BeginExceptFilterBlock:
				((ILGeneratorShim)il).BeginExceptFilterBlock();
				break;
			case ExceptionBlockType.BeginFaultBlock:
				((ILGeneratorShim)il).BeginFaultBlock();
				break;
			case ExceptionBlockType.BeginFinallyBlock:
				((ILGeneratorShim)il).BeginFinallyBlock();
				break;
			case ExceptionBlockType.EndExceptionBlock:
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
		}

		public static void MarkBlockAfter(this CecilILGenerator il, ExceptionBlock block)
		{
			if (block.blockType == ExceptionBlockType.EndExceptionBlock)
			{
				((ILGeneratorShim)il).EndExceptionBlock();
			}
		}

		public static LocalBuilder GetLocal(this CecilILGenerator il, VariableDefinition varDef)
		{
			Dictionary<LocalBuilder, VariableDefinition> dictionary = (Dictionary<LocalBuilder, VariableDefinition>)AccessTools.Field(typeof(CecilILGenerator), "_Variables").GetValue(il);
			LocalBuilder key = dictionary.FirstOrDefault((KeyValuePair<LocalBuilder, VariableDefinition> kv) => kv.Value == varDef).Key;
			if (key != null)
			{
				return key;
			}
			Type type = ReflectionHelper.ResolveReflection(((VariableReference)varDef).VariableType);
			bool isPinned = ((VariableReference)varDef).VariableType.IsPinned;
			int index = ((VariableReference)varDef).Index;
			object obj;
			if (c_LocalBuilder_params != 4)
			{
				if (c_LocalBuilder_params != 3)
				{
					if (c_LocalBuilder_params != 2)
					{
						if (c_LocalBuilder_params != 0)
						{
							throw new NotSupportedException();
						}
						obj = c_LocalBuilder.Invoke(new object[0]);
					}
					else
					{
						obj = c_LocalBuilder.Invoke(new object[2] { type, null });
					}
				}
				else
				{
					obj = c_LocalBuilder.Invoke(new object[3] { index, type, null });
				}
			}
			else
			{
				obj = c_LocalBuilder.Invoke(new object[4] { index, type, null, isPinned });
			}
			key = (LocalBuilder)obj;
			f_LocalBuilder_position?.SetValue(key, (ushort)index);
			f_LocalBuilder_is_pinned?.SetValue(key, isPinned);
			dictionary[key] = varDef;
			return key;
		}
	}
	internal class ILEmitter
	{
		public class Label
		{
			public bool emitted;

			public Instruction instruction = Instruction.Create(OpCodes.Nop);

			public List<Instruction> targets = new List<Instruction>();
		}

		public class ExceptionBlock
		{
			public LabelledExceptionHandler prev;

			public LabelledExceptionHandler cur;

			public Label start;

			public Label skip;
		}

		public class LabelledExceptionHandler
		{
			public TypeReference exceptionType;

			public ExceptionHandlerType handlerType;

			public Label tryStart;

			public Label tryEnd;

			public Label filterStart;

			public Label handlerStart;

			public Label handlerEnd;
		}

		public readonly ILProcessor IL;

		private readonly List<LabelledExceptionHandler> pendingExceptionHandlers = new List<LabelledExceptionHandler>();

		private readonly List<Label> pendingLabels = new List<Label>();

		public Instruction emitBefore;

		private Instruction Target => emitBefore ?? IL.Body.Instructions[IL.Body.Instructions.Count - 1];

		public ILEmitter(ILProcessor il)
		{
			IL = il;
		}

		public ExceptionBlock BeginExceptionBlock(Label start)
		{
			return new ExceptionBlock
			{
				start = start
			};
		}

		public void EndExceptionBlock(ExceptionBlock block)
		{
			EndHandler(block, block.cur);
		}

		public void BeginHandler(ExceptionBlock block, ExceptionHandlerType handlerType, Type exceptionType = null)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Invalid comparison between Unknown and I4
			LabelledExceptionHandler labelledExceptionHandler = (block.prev = block.cur);
			if (labelledExceptionHandler != null)
			{
				EndHandler(block, labelledExceptionHandler);
			}
			block.skip = DeclareLabel();
			Emit(OpCodes.Leave, block.skip);
			Label label = DeclareLabel();
			MarkLabel(label);
			block.cur = new LabelledExceptionHandler
			{
				tryStart = block.start,
				tryEnd = label,
				handlerType = handlerType,
				handlerEnd = block.skip,
				exceptionType = ((exceptionType != null) ? Extensions.Import(IL, exceptionType) : null)
			};
			if ((int)handlerType == 1)
			{
				block.cur.filterStart = label;
			}
			else
			{
				block.cur.handlerStart = label;
			}
		}

		public void EndHandler(ExceptionBlock block, LabelledExceptionHandler handler)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			ExceptionHandlerType handlerType = handler.handlerType;
			if ((int)handlerType != 1)
			{
				if ((int)handlerType == 2)
				{
					Emit(OpCodes.Endfinally);
				}
				else
				{
					Emit(OpCodes.Leave, block.skip);
				}
			}
			else
			{
				Emit(OpCodes.Endfilter);
			}
			MarkLabel(block.skip);
			pendingExceptionHandlers.Add(block.cur);
		}

		public VariableDefinition DeclareVariable(Type type)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			VariableDefinition val = new VariableDefinition(Extensions.Import(IL, type));
			IL.Body.Variables.Add(val);
			return val;
		}

		public Label DeclareLabel()
		{
			return new Label();
		}

		public Label DeclareLabelFor(Instruction ins)
		{
			return new Label
			{
				emitted = true,
				instruction = ins
			};
		}

		public void MarkLabel(Label label)
		{
			if (!label.emitted)
			{
				pendingLabels.Add(label);
			}
		}

		public Instruction SetOpenLabelsTo(Instruction ins)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			if (pendingLabels.Count != 0)
			{
				foreach (Label pendingLabel in pendingLabels)
				{
					foreach (Instruction target in pendingLabel.targets)
					{
						if (target.Operand is Instruction)
						{
							target.Operand = ins;
						}
						else
						{
							if (!(target.Operand is Instruction[] array))
							{
								continue;
							}
							for (int i = 0; i < array.Length; i++)
							{
								if (array[i] == pendingLabel.instruction)
								{
									array[i] = ins;
									break;
								}
							}
						}
					}
					pendingLabel.instruction = ins;
					pendingLabel.emitted = true;
				}
				pendingLabels.Clear();
			}
			if (pendingExceptionHandlers.Count != 0)
			{
				foreach (LabelledExceptionHandler pendingExceptionHandler in pendingExceptionHandlers)
				{
					IL.Body.ExceptionHandlers.Add(new ExceptionHandler(pendingExceptionHandler.handlerType)
					{
						TryStart = pendingExceptionHandler.tryStart?.instruction,
						TryEnd = pendingExceptionHandler.tryEnd?.instruction,
						FilterStart = pendingExceptionHandler.filterStart?.instruction,
						HandlerStart = pendingExceptionHandler.handlerStart?.instruction,
						HandlerEnd = pendingExceptionHandler.handlerEnd?.instruction,
						CatchType = pendingExceptionHandler.exceptionType
					});
				}
				pendingExceptionHandlers.Clear();
			}
			return ins;
		}

		public void Emit(OpCode opcode)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode)));
		}

		public void Emit(OpCode opcode, Label label)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Instruction val = SetOpenLabelsTo(IL.Create(opcode, label.instruction));
			label.targets.Add(val);
			IL.InsertBefore(Target, val);
		}

		public void Emit(OpCode opcode, ConstructorInfo cInfo)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, Extensions.Import(IL, (MethodBase)cInfo))));
		}

		public void Emit(OpCode opcode, MethodInfo mInfo)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, Extensions.Import(IL, (MethodBase)mInfo))));
		}

		public void Emit(OpCode opcode, Type cls)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, Extensions.Import(IL, cls))));
		}

		public void EmitUnsafe(OpCode opcode, object arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(Extensions.Create(IL, opcode, arg)));
		}

		public void Emit(OpCode opcode, int arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, arg)));
		}

		public void Emit(OpCode opcode, string arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, arg)));
		}

		public void Emit(OpCode opcode, FieldInfo fInfo)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, Extensions.Import(IL, fInfo))));
		}

		public void Emit(OpCode opcode, VariableDefinition varDef)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			IL.InsertBefore(Target, SetOpenLabelsTo(IL.Create(opcode, varDef)));
		}
	}
	internal class ILHookExt : ILHook
	{
		public string dumpPath;

		public ILHookExt(MethodBase from, Manipulator manipulator, ILHookConfig config)
			: base(from, manipulator, config)
		{
		}//IL_0003: Unknown result type (might be due to invalid IL or missing references)

	}
	internal static class ILHookExtensions
	{
		private static readonly MethodInfo IsAppliedSetter;

		public static readonly Action<ILHook, bool> SetIsApplied;

		private static Func<ILHook, Detour> GetAppliedDetour;

		static ILHookExtensions()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			IsAppliedSetter = AccessTools.PropertySetter(typeof(ILHook), "IsApplied");
			SetIsApplied = Extensions.CreateDelegate<Action<ILHook, bool>>((MethodBase)IsAppliedSetter);
			DynamicMethodDefinition val = new DynamicMethodDefinition("GetDetour", typeof(Detour), new Type[1] { typeof(ILHook) });
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Call, AccessTools.PropertyGetter(typeof(ILHook), "_Ctx"));
			iLGenerator.Emit(OpCodes.Ldfld, AccessTools.Field(AccessTools.Inner(typeof(ILHook), "Context"), "Detour"));
			iLGenerator.Emit(OpCodes.Ret);
			GetAppliedDetour = Extensions.CreateDelegate<Func<ILHook, Detour>>((MethodBase)val.Generate());
		}

		public static MethodBase GetCurrentTarget(this ILHook hook)
		{
			return GetAppliedDetour(hook).Target;
		}
	}
	internal static class MethodBodyLogExtensions
	{
		public static string ToILDasmString(this MethodBody mb)
		{
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected I4, but got Unknown
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder sb = new StringBuilder();
			Collection<Instruction> instructions = mb.Instructions;
			Instruction val = ((IEnumerable<Instruction>)instructions).First();
			val.Offset = 0;
			foreach (Instruction item in ((IEnumerable<Instruction>)instructions).Skip(1))
			{
				object operand = val.Operand;
				ILLabel val2 = (ILLabel)((operand is ILLabel) ? operand : null);
				if (val2 != null)
				{
					val.Operand = val2.Target;
				}
				else if (operand is ILLabel[] source)
				{
					val.Operand = source.Select((ILLabel l) => l.Target).ToArray();
				}
				item.Offset = val.Offset + val.GetSize();
				val.Operand = operand;
				val = item;
			}
			Dictionary<Instruction, List<ExceptionBlock>> exBlocks = new Dictionary<Instruction, List<ExceptionBlock>>();
			Enumerator<ExceptionHandler> enumerator2 = mb.ExceptionHandlers.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					ExceptionHandler current2 = enumerator2.Current;
					AddBlock(current2.TryStart, ExceptionBlockType.BeginExceptionBlock);
					AddBlock(current2.TryEnd, ExceptionBlockType.EndExceptionBlock);
					AddBlock(current2.HandlerEnd, ExceptionBlockType.EndExceptionBlock);
					ExceptionHandlerType handlerType = current2.HandlerType;
					switch ((int)handlerType)
					{
					case 0:
						AddBlock(current2.HandlerStart, ExceptionBlockType.BeginCatchBlock).catchType = ReflectionHelper.ResolveReflection(current2.CatchType);
						break;
					case 1:
						AddBlock(current2.FilterStart, ExceptionBlockType.BeginExceptFilterBlock);
						break;
					case 2:
						AddBlock(current2.HandlerStart, ExceptionBlockType.BeginFinallyBlock);
						break;
					case 4:
						AddBlock(current2.HandlerStart, ExceptionBlockType.BeginFaultBlock);
						break;
					default:
						throw new ArgumentOutOfRangeException();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator2).Dispose();
			}
			int indent = 0;
			WriteLine(".locals init (");
			indent += 4;
			for (int i = 0; i < mb.Variables.Count; i++)
			{
				VariableDefinition val3 = mb.Variables[i];
				WriteLine($"{((MemberReference)((VariableReference)val3).VariableType).FullName} V_{i}");
			}
			indent -= 4;
			WriteLine(")");
			Stack<string> stack = new Stack<string>();
			Enumerator<Instruction> enumerator3 = instructions.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					Instruction current3 = enumerator3.Current;
					List<ExceptionBlock> obj = exBlocks.GetValueSafe(current3) ?? new List<ExceptionBlock>();
					obj.Sort((ExceptionBlock a, ExceptionBlock b) => (a.blockType == ExceptionBlockType.EndExceptionBlock) ? (-1) : 0);
					foreach (ExceptionBlock item2 in obj)
					{
						switch (item2.blockType)
						{
						case ExceptionBlockType.BeginExceptionBlock:
							WriteLine(".try");
							WriteLine("{");
							indent += 2;
							stack.Push(".try");
							break;
						case ExceptionBlockType.BeginCatchBlock:
							WriteLine("catch " + item2.catchType.FullName);
							WriteLine("{");
							indent += 2;
							stack.Push("handler (catch)");
							break;
						case ExceptionBlockType.BeginExceptFilterBlock:
							WriteLine("filter");
							WriteLine("{");
							indent += 2;
							stack.Push("handler (filter)");
							break;
						case ExceptionBlockType.BeginFaultBlock:
							WriteLine("fault");
							WriteLine("{");
							indent += 2;
							stack.Push("handler (fault)");
							break;
						case ExceptionBlockType.BeginFinallyBlock:
							WriteLine("finally");
							WriteLine("{");
							indent += 2;
							stack.Push("handler (finally)");
							break;
						case ExceptionBlockType.EndExceptionBlock:
							indent -= 2;
							WriteLine("} // end " + stack.Pop());
							break;
						default:
							throw new ArgumentOutOfRangeException();
						}
					}
					object operand2 = current3.Operand;
					ILLabel val4 = (ILLabel)((operand2 is ILLabel) ? operand2 : null);
					if (val4 != null)
					{
						current3.Operand = val4.Target;
					}
					else if (operand2 is ILLabel[] source2)
					{
						current3.Operand = source2.Select((ILLabel l) => l.Target).ToArray();
					}
					WriteLine(((object)current3).ToString());
					current3.Operand = operand2;
				}
			}
			finally
			{
				((IDisposable)enumerator3).Dispose();
			}
			return sb.ToString();
			ExceptionBlock AddBlock(Instruction ins, ExceptionBlockType t)
			{
				if (ins == null)
				{
					return new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock);
				}
				if (!exBlocks.TryGetValue(ins, out var value))
				{
					value = (exBlocks[ins] = new List<ExceptionBlock>());
				}
				ExceptionBlock exceptionBlock = new ExceptionBlock(t);
				value.Add(exceptionBlock);
				return exceptionBlock;
			}
			void WriteLine(string text)
			{
				sb.Append(new string(' ', indent)).AppendLine(text);
			}
		}
	}
	internal class ReflectionTools
	{
		internal struct TypeAndName
		{
			internal Type type;

			internal string name;
		}

		internal static TypeAndName TypColonName(string typeColonName)
		{
			if (typeColonName == null)
			{
				throw new ArgumentNullException("typeColonName");
			}
			string[] array = typeColonName.Split(new char[1] { ':' });
			if (array.Length != 2)
			{
				throw new ArgumentException(" must be specified as 'Namespace.Type1.Type2:MemberName", "typeColonName");
			}
			TypeAndName result = default(TypeAndName);
			result.type = AccessTools.TypeByName(array[0]);
			result.name = array[1];
			return result;
		}

		internal static void ValidateFieldType<F>(FieldInfo fieldInfo)
		{
			Type typeFromHandle = typeof(F);
			Type fieldType = fieldInfo.FieldType;
			if (typeFromHandle == fieldType)
			{
				return;
			}
			if (fieldType.IsEnum)
			{
				Type underlyingType = Enum.GetUnderlyingType(fieldType);
				if (!(typeFromHandle != underlyingType))
				{
					return;
				}
				throw new ArgumentException("FieldRefAccess return type must be the same as FieldType or " + $"FieldType's underlying integral type ({underlyingType}) for enum types");
			}
			if (fieldType.IsValueType)
			{
				throw new ArgumentException("FieldRefAccess return type must be the same as FieldType for value types");
			}
			if (typeFromHandle.IsAssignableFrom(fieldType))
			{
				return;
			}
			throw new ArgumentException("FieldRefAccess return type must be assignable from FieldType for reference types");
		}

		internal static AccessTools.FieldRef<T, F> FieldRefAccess<T, F>(FieldInfo fieldInfo, bool needCastclass)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			ValidateFieldType<F>(fieldInfo);
			Type typeFromHandle = typeof(T);
			Type declaringType = fieldInfo.DeclaringType;
			DynamicMethodDefinition val = new DynamicMethodDefinition("__refget_" + typeFromHandle.Name + "_fi_" + fieldInfo.Name, typeof(F).MakeByRefType(), new Type[1] { typeFromHandle });
			ILGenerator iLGenerator = val.GetILGenerator();
			if (fieldInfo.IsStatic)
			{
				iLGenerator.Emit(OpCodes.Ldsflda, fieldInfo);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				if (needCastclass)
				{
					iLGenerator.Emit(OpCodes.Castclass, declaringType);
				}
				iLGenerator.Emit(OpCodes.Ldflda, fieldInfo);
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (AccessTools.FieldRef<T, F>)val.Generate().CreateDelegate(typeof(AccessTools.FieldRef<T, F>));
		}

		internal static AccessTools.StructFieldRef<T, F> StructFieldRefAccess<T, F>(FieldInfo fieldInfo) where T : struct
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			ValidateFieldType<F>(fieldInfo);
			DynamicMethodDefinition val = new DynamicMethodDefinition("__refget_" + typeof(T).Name + "_struct_fi_" + fieldInfo.Name, typeof(F).MakeByRefType(), new Type[1] { typeof(T).MakeByRefType() });
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldflda, fieldInfo);
			iLGenerator.Emit(OpCodes.Ret);
			return (AccessTools.StructFieldRef<T, F>)val.Generate().CreateDelegate(typeof(AccessTools.StructFieldRef<T, F>));
		}

		internal static AccessTools.FieldRef<F> StaticFieldRefAccess<F>(FieldInfo fieldInfo)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!fieldInfo.IsStatic)
			{
				throw new ArgumentException("Field must be static");
			}
			ValidateFieldType<F>(fieldInfo);
			DynamicMethodDefinition val = new DynamicMethodDefinition("__refget_" + (fieldInfo.DeclaringType?.Name ?? "null") + "_static_fi_" + fieldInfo.Name, typeof(F).MakeByRefType(), new Type[0]);
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldsflda, fieldInfo);
			iLGenerator.Emit(OpCodes.Ret);
			return (AccessTools.FieldRef<F>)val.Generate().CreateDelegate(typeof(AccessTools.FieldRef<F>));
		}

		internal static FieldInfo GetInstanceField(Type type, string fieldName)
		{
			FieldInfo obj = AccessTools.Field(type, fieldName) ?? throw new MissingFieldException(type.Name, fieldName);
			if (obj.IsStatic)
			{
				throw new ArgumentException("Field must not be static");
			}
			return obj;
		}

		internal static bool FieldRefNeedsClasscast(Type delegateInstanceType, Type declaringType)
		{
			bool flag = false;
			if (delegateInstanceType != declaringType)
			{
				flag = delegateInstanceType.IsAssignableFrom(declaringType);
				if (!flag && !declaringType.IsAssignableFrom(delegateInstanceType))
				{
					throw new ArgumentException("FieldDeclaringType must be assignable from or to T (FieldRefAccess instance type) - \"instanceOfT is FieldDeclaringType\" must be possible");
				}
			}
			return flag;
		}

		internal static void ValidateStructField<T, F>(FieldInfo fieldInfo) where T : struct
		{
			if (fieldInfo.IsStatic)
			{
				throw new ArgumentException("Field must not be static");
			}
			if (fieldInfo.DeclaringType != typeof(T))
			{
				throw new ArgumentException("FieldDeclaringType must be T (StructFieldRefAccess instance type)");
			}
		}
	}
}
namespace HarmonyLib.Internal.Patching
{
	internal class ILManipulator
	{
		private class RawInstruction
		{
			public CodeInstruction Instruction { get; set; }

			public object Operand { get; set; }

			public Instruction CILInstruction { get; set; }
		}

		private static readonly Dictionary<short, OpCode> SREOpCodes;

		private static readonly Dictionary<short, OpCode> CecilOpCodes;

		private static readonly Dictionary<OpCode, OpCode> ShortToLongMap;

		private readonly IEnumerable<RawInstruction> codeInstructions;

		private readonly bool debug;

		private readonly Dictionary<VariableDefinition, LocalBuilder> localsCache = new Dictionary<VariableDefinition, LocalBuilder>();

		private readonly List<MethodInfo> transpilers = new List<MethodInfo>();

		public MethodBody Body { get; }

		static ILManipulator()
		{
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			SREOpCodes = new Dictionary<short, OpCode>();
			CecilOpCodes = new Dictionary<short, OpCode>();
			ShortToLongMap = new Dictionary<OpCode, OpCode>
			{
				[OpCodes.Beq_S] = OpCodes.Beq,
				[OpCodes.Bge_S] = OpCodes.Bge,
				[OpCodes.Bge_Un_S] = OpCodes.Bge_Un,
				[OpCodes.Bgt_S] = OpCodes.Bgt,
				[OpCodes.Bgt_Un_S] = OpCodes.Bgt_Un,
				[OpCodes.Ble_S] = OpCodes.Ble,
				[OpCodes.Ble_Un_S] = OpCodes.Ble_Un,
				[OpCodes.Blt_S] = OpCodes.Blt,
				[OpCodes.Blt_Un_S] = OpCodes.Blt_Un,
				[OpCodes.Bne_Un_S] = OpCodes.Bne_Un,
				[OpCodes.Brfalse_S] = OpCodes.Brfalse,
				[OpCodes.Brtrue_S] = OpCodes.Brtrue,
				[OpCodes.Br_S] = OpCodes.Br,
				[OpCodes.Leave_S] = OpCodes.Leave
			};
			FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			for (int i = 0; i < fields.Length; i++)
			{
				OpCode value = (OpCode)fields[i].GetValue(null);
				SREOpCodes[value.Value] = value;
			}
			fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			for (int i = 0; i < fields.Length; i++)
			{
				OpCode value2 = (OpCode)fields[i].GetValue(null);
				CecilOpCodes[((OpCode)(ref value2)).Value] = value2;
			}
		}

		public ILManipulator(MethodBody body, bool debug)
		{
			Body = body;
			this.debug = debug;
			codeInstructions = ReadBody(Body);
		}

		private int GetTarget(MethodBody body, object insOp)
		{
			ILLabel val = (ILLabel)((insOp is ILLabel) ? insOp : null);
			if (val != null)
			{
				return body.Instructions.IndexOf(val.Target);
			}
			Instruction val2 = (Instruction)((insOp is Instruction) ? insOp : null);
			if (val2 != null)
			{
				return body.Instructions.IndexOf(val2);
			}
			return -1;
		}

		private int[] GetTargets(MethodBody body, object insOp)
		{
			if (insOp is ILLabel[] arr2)
			{
				return Result<ILLabel>(arr2, (ILLabel l) => l.Target);
			}
			if (insOp is Instruction[] arr3)
			{
				return Result<Instruction>(arr3, (Instruction i) => i);
			}
			return new int[0];
			int[] Result<T>(IEnumerable<T> arr, Func<T, Instruction> insGetter)
			{
				return arr.Select((T i) => body.Instructions.IndexOf(insGetter(i))).ToArray();
			}
		}

		private IEnumerable<RawInstruction> ReadBody(MethodBody body)
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Expected I4, but got Unknown
			List<RawInstruction> instructions = new List<RawInstruction>(body.Instructions.Count);
			instructions.AddRange(((IEnumerable<Instruction>)body.Instructions).Select(ReadInstruction));
			foreach (RawInstruction item in instructions)
			{
				RawInstruction rawInstruction = item;
				rawInstruction.Operand = item.Instruction.opcode.OperandType switch
				{
					OperandType.ShortInlineBrTarget => instructions[(int)item.Operand].Instruction, 
					OperandType.InlineBrTarget => instructions[(int)item.Operand].Instruction, 
					OperandType.InlineSwitch => ((int[])item.Operand).Select((int i) => instructions[i].Instruction).ToArray(), 
					_ => item.Operand, 
				};
			}
			Enumerator<ExceptionHandler> enumerator2 = body.ExceptionHandlers.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					ExceptionHandler current2 = enumerator2.Current;
					CodeInstruction instruction = instructions[body.Instructions.IndexOf(current2.TryStart)].Instruction;
					_ = instructions[body.Instructions.IndexOf(current2.TryEnd)].Instruction;
					CodeInstruction instruction2 = instructions[body.Instructions.IndexOf(current2.HandlerStart)].Instruction;
					int index = ((current2.HandlerEnd == null) ? (instructions.Count - 1) : body.Instructions.IndexOf(current2.HandlerEnd.Previous));
					CodeInstruction instruction3 = instructions[index].Instruction;
					instruction.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock));
					instruction3.blocks.Add(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));
					ExceptionHandlerType handlerType = current2.HandlerType;
					switch ((int)handlerType)
					{
					case 0:
						instruction2.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock, ReflectionHelper.ResolveReflection(current2.CatchType)));
						break;
					case 1:
						instructions[body.Instructions.IndexOf(current2.FilterStart)].Instruction.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptFilterBlock));
						break;
					case 2:
						instruction2.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFinallyBlock));
						break;
					case 4:
						instruction2.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFaultBlock));
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator2).Dispose();
			}
			return instructions;
			RawInstruction ReadInstruction(Instruction ins)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected I4, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Expected O, but got Unknown
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Expected O, but got Unknown
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Expected O, but got Unknown
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				RawInstruction rawInstruction2 = new RawInstruction();
				Dictionary<short, OpCode> sREOpCodes = SREOpCodes;
				OpCode opCode = ins.OpCode;
				rawInstruction2.Instruction = new CodeInstruction(sREOpCodes[((OpCode)(ref opCode)).Value]);
				RawInstruction rawInstruction3 = rawInstruction2;
				opCode = ins.OpCode;
				OperandType operandType = ((OpCode)(ref opCode)).OperandType;
				rawInstruction3.Operand = (int)operandType switch
				{
					1 => ReflectionHelper.ResolveReflection((MemberReference)ins.Operand), 
					4 => ReflectionHelper.ResolveReflection((MemberReference)ins.Operand), 
					12 => ReflectionHelper.ResolveReflection((MemberReference)ins.Operand), 
					11 => ReflectionHelper.ResolveReflection((MemberReference)ins.Operand), 
					13 => (object)(VariableDefinition)ins.Operand, 
					18 => (object)(VariableDefinition)ins.Operand, 
					14 => (short)((ParameterReference)(ParameterDefinition)ins.Operand).Index, 
					19 => (byte)((ParameterReference)(ParameterDefinition)ins.Operand).Index, 
					0 => GetTarget(body, ins.Operand), 
					15 => GetTarget(body, ins.Operand), 
					10 => GetTargets(body, ins.Operand), 
					_ => ins.Operand, 
				};
				rawInstruction2.CILInstruction = ins;
				return rawInstruction2;
			}
		}

		public void AddTranspiler(MethodInfo transpiler)
		{
			transpilers.Add(transpiler);
		}

		private object[] GetTranspilerArguments(ILGenerator il, MethodInfo transpiler, IEnumerable<CodeInstruction> instructions, MethodBase orignal = null)
		{
			List<object> list = new List<object>();
			foreach (Type item in from p in transpiler.GetParameters()
				select p.ParameterType)
			{
				if (item.IsAssignableFrom(typeof(ILGenerator)))
				{
					list.Add(il);
				}
				else if (item.IsAssignableFrom(typeof(MethodBase)) && orignal != null)
				{
					list.Add(orignal);
				}
				else if (item.IsAssignableFrom(typeof(IEnumerable<CodeInstruction>)))
				{
					list.Add(instructions);
				}
			}
			return list.ToArray();
		}

		public IEnumerable<KeyValuePair<OpCode, object>> GetRawInstructions()
		{
			return codeInstructions.Select((RawInstruction i) => new KeyValuePair<OpCode, object>(i.Instruction.opcode, i.Operand));
		}

		public List<CodeInstruction> GetInstructions(ILGenerator il, MethodBase original = null)
		{
			return NormalizeInstructions(ApplyTranspilers(il, original, (VariableDefinition vDef) => il.DeclareLocal(ReflectionHelper.ResolveReflection(((VariableReference)vDef).VariableType)), il.DefineLabel)).ToList();
		}

		private IEnumerable<CodeInstruction> ApplyTranspilers(ILGenerator il, MethodBase original, Func<VariableDefinition, LocalBuilder> getLocal, Func<Label> defineLabel)
		{
			List<CodeInstruction> list = (from i in Prepare(getLocal, defineLabel)
				select i.Instruction).ToList();
			if (transpilers.Count == 0)
			{
				return list;
			}
			IEnumerable<CodeInstruction> enumerable = NormalizeInstructions(list);
			foreach (MethodInfo transpiler in transpilers)
			{
				object[] transpilerArguments = GetTranspilerArguments(il, transpiler, enumerable, original);
				Logger.Log(Logger.LogChannel.Info, () => "Running transpiler " + transpiler.FullDescription(), debug);
				enumerable = NormalizeInstructions(transpiler.Invoke(null, transpilerArguments) as IEnumerable<CodeInstruction>).ToList();
			}
			return enumerable;
		}

		public Dictionary<int, CodeInstruction> GetIndexedInstructions(ILGenerator il)
		{
			int size = 0;
			return Prepare((VariableDefinition vDef) => il.DeclareLocal(ReflectionHelper.ResolveReflection(((VariableReference)vDef).VariableType)), il.DefineLabel).ToDictionary((RawInstruction i) => Grow(ref size, i.CILInstruction.GetSize()), (RawInstruction i) => i.Instruction);
			static int Grow(ref int i, int s)
			{
				int result = i;
				i += s;
				return result;
			}
		}

		private IEnumerable<RawInstruction> Prepare(Func<VariableDefinition, LocalBuilder> getLocal, Func<Label> defineLabel)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			localsCache.Clear();
			Enumerator<VariableDefinition> enumerator = Body.Variables.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					VariableDefinition current = enumerator.Current;
					localsCache[current] = getLocal(current);
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			foreach (RawInstruction codeInstruction2 in codeInstructions)
			{
				codeInstruction2.Instruction.operand = codeInstruction2.Operand;
				switch (codeInstruction2.Instruction.opcode.OperandType)
				{
				case OperandType.InlineVar:
				case OperandType.ShortInlineVar:
				{
					object operand = codeInstruction2.Operand;
					VariableDefinition val = (VariableDefinition)((operand is VariableDefinition) ? operand : null);
					if (val != null)
					{
						codeInstruction2.Instruction.operand = localsCache[val];
					}
					break;
				}
				case OperandType.InlineSwitch:
					if (codeInstruction2.Operand is CodeInstruction[] array)
					{
						List<Label> list = new List<Label>();
						CodeInstruction[] array2 = array;
						foreach (CodeInstruction obj in array2)
						{
							Label item = defineLabel();
							obj.labels.Add(item);
							list.Add(item);
						}
						codeInstruction2.Instruction.operand = list.ToArray();
					}
					break;
				case OperandType.InlineBrTarget:
				case OperandType.ShortInlineBrTarget:
					if (codeInstruction2.Instruction.operand is CodeInstruction codeInstruction)
					{
						Label label = defineLabel();
						codeInstruction.labels.Add(label);
						codeInstruction2.Instruction.operand = label;
					}
					break;
				}
			}
			return codeInstructions;
		}

		public void WriteTo(MethodBody body, MethodBase original = null)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			body.Instructions.Clear();
			body.ExceptionHandlers.Clear();
			CecilILGenerator il = new CecilILGenerator(body.GetILProcessor());
			ILGenerator proxy = ((ILGeneratorShim)il).GetProxy();
			((ILGeneratorShim)il).DefineLabel();
			foreach (var (codeInstruction, codeInstruction2) in ApplyTranspilers(proxy, original, (Func<VariableDefinition, LocalBuilder>)((VariableDefinition vDef) => il.GetLocal(vDef)), (Func<Label>)((ILGeneratorShim)il).DefineLabel).Pairwise())
			{
				codeInstruction.labels.ForEach(delegate(Label l)
				{
					((ILGeneratorShim)il).MarkLabel(l);
				});
				codeInstruction.blocks.ForEach(delegate(ExceptionBlock b)
				{
					il.MarkBlockBefore(b);
				});
				if (((!(codeInstruction.opcode == OpCodes.Leave) && !(codeInstruction.opcode == OpCodes.Leave_S)) || (codeInstruction.blocks.Count <= 0 && (codeInstruction2 == null || codeInstruction2.blocks.Count <= 0))) && ((!(codeInstruction.opcode == OpCodes.Endfilter) && !(codeInstruction.opcode == OpCodes.Endfinally)) || codeInstruction.blocks.Count <= 0))
				{
					switch (codeInstruction.opcode.OperandType)
					{
					case OperandType.InlineNone:
						((ILGeneratorShim)il).Emit(codeInstruction.opcode);
						break;
					case OperandType.InlineSig:
						throw new NotSupportedException("Emitting opcodes with CallSites is currently not fully implemented");
					default:
						if (codeInstruction.operand == null)
						{
							throw new ArgumentNullException("operand", $"Invalid argument for {codeInstruction}");
						}
						il.Emit(codeInstruction.opcode, codeInstruction.operand);
						break;
					}
				}
				codeInstruction.blocks.ForEach(delegate(ExceptionBlock b)
				{
					il.MarkBlockAfter(b);
				});
			}
			if (body.Instructions.Count == 0)
			{
				((ILGeneratorShim)il).Emit(OpCodes.Ret);
			}
		}

		private static IEnumerable<CodeInstruction> NormalizeInstructions(IEnumerable<CodeInstruction> instrs)
		{
			foreach (CodeInstruction instr in instrs)
			{
				CodeInstruction codeInstruction = instr;
				if (codeInstruction.labels == null)
				{
					codeInstruction.labels = new List<Label>();
				}
				codeInstruction = instr;
				if (codeInstruction.blocks == null)
				{
					codeInstruction.blocks = new List<ExceptionBlock>();
				}
				if (ShortToLongMap.TryGetValue(instr.opcode, out var value))
				{
					instr.opcode = value;
				}
				yield return instr;
			}
		}

		public static Dictionary<int, CodeInstruction> GetInstructions(MethodBody body)
		{
			if (body == null)
			{
				return null;
			}
			try
			{
				return new ILManipulator(body, debug: false).GetIndexedInstructions(PatchProcessor.CreateILGenerator());
			}
			catch (Exception ex)
			{
				Exception e = ex;
				Logger.Log(Logger.LogChannel.Warn, () => "Could not read instructions of " + Extensions.GetID((MethodReference)(object)body.Method, (string)null, (string)null, true, false) + ": " + e.Message);
				return null;
			}
		}
	}
}