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.Json;
using System.Text.Json.Serialization;
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 Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Mdb;
using Mono.Cecil.Pdb;
using Mono.Cecil.Rocks;
using Mono.Collections.Generic;
using Mono.CompilerServices.SymbolWriter;
using MonoMod.Cil;
using MonoMod.Core.Platforms;
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 = ".NET Standard 2.0")]
[assembly: AssemblyCompany("BepInEx")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © BepInEx 2022")]
[assembly: AssemblyDescription("A general non-destructive patch library for .NET and Mono modules")]
[assembly: AssemblyFileVersion("2.16.1.0")]
[assembly: AssemblyInformationalVersion("2.16.1+02a98f540fa12ac4656f189a3cf67b0c96cc68f7")]
[assembly: AssemblyProduct("HarmonyX")]
[assembly: AssemblyTitle("0Harmony")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/BepInEx/HarmonyX")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.16.1.0")]
[assembly: TypeForwardedTo(typeof(AssemblyAttributes))]
[assembly: TypeForwardedTo(typeof(AssemblyDefinition))]
[assembly: TypeForwardedTo(typeof(AssemblyHashAlgorithm))]
[assembly: TypeForwardedTo(typeof(AssemblyNameDefinition))]
[assembly: TypeForwardedTo(typeof(AssemblyNameReference))]
[assembly: TypeForwardedTo(typeof(AssemblyResolutionException))]
[assembly: TypeForwardedTo(typeof(ByReferenceType))]
[assembly: TypeForwardedTo(typeof(CallSite))]
[assembly: TypeForwardedTo(typeof(Code))]
[assembly: TypeForwardedTo(typeof(ConstantDebugInformation))]
[assembly: TypeForwardedTo(typeof(CustomDebugInformation))]
[assembly: TypeForwardedTo(typeof(CustomDebugInformationKind))]
[assembly: TypeForwardedTo(typeof(DebugInformation))]
[assembly: TypeForwardedTo(typeof(Document))]
[assembly: TypeForwardedTo(typeof(DocumentHashAlgorithm))]
[assembly: TypeForwardedTo(typeof(DocumentLanguage))]
[assembly: TypeForwardedTo(typeof(DocumentLanguageVendor))]
[assembly: TypeForwardedTo(typeof(DocumentType))]
[assembly: TypeForwardedTo(typeof(ExceptionHandler))]
[assembly: TypeForwardedTo(typeof(ExceptionHandlerType))]
[assembly: TypeForwardedTo(typeof(FlowControl))]
[assembly: TypeForwardedTo(typeof(ILProcessor))]
[assembly: TypeForwardedTo(typeof(ImageDebugDirectory))]
[assembly: TypeForwardedTo(typeof(ImageDebugHeader))]
[assembly: TypeForwardedTo(typeof(ImageDebugHeaderEntry))]
[assembly: TypeForwardedTo(typeof(ImageDebugType))]
[assembly: TypeForwardedTo(typeof(ImportDebugInformation))]
[assembly: TypeForwardedTo(typeof(ImportTarget))]
[assembly: TypeForwardedTo(typeof(ImportTargetKind))]
[assembly: TypeForwardedTo(typeof(Instruction))]
[assembly: TypeForwardedTo(typeof(InstructionOffset))]
[assembly: TypeForwardedTo(typeof(ISymbolReader))]
[assembly: TypeForwardedTo(typeof(ISymbolReaderProvider))]
[assembly: TypeForwardedTo(typeof(ISymbolWriter))]
[assembly: TypeForwardedTo(typeof(ISymbolWriterProvider))]
[assembly: TypeForwardedTo(typeof(MethodBody))]
[assembly: TypeForwardedTo(typeof(MethodDebugInformation))]
[assembly: TypeForwardedTo(typeof(OpCode))]
[assembly: TypeForwardedTo(typeof(OpCodes))]
[assembly: TypeForwardedTo(typeof(OpCodeType))]
[assembly: TypeForwardedTo(typeof(OperandType))]
[assembly: TypeForwardedTo(typeof(ScopeDebugInformation))]
[assembly: TypeForwardedTo(typeof(SequencePoint))]
[assembly: TypeForwardedTo(typeof(StackBehaviour))]
[assembly: TypeForwardedTo(typeof(SymbolsNotFoundException))]
[assembly: TypeForwardedTo(typeof(SymbolsNotMatchingException))]
[assembly: TypeForwardedTo(typeof(VariableAttributes))]
[assembly: TypeForwardedTo(typeof(VariableDebugInformation))]
[assembly: TypeForwardedTo(typeof(VariableDefinition))]
[assembly: TypeForwardedTo(typeof(VariableReference))]
[assembly: TypeForwardedTo(typeof(CustomAttribute))]
[assembly: TypeForwardedTo(typeof(CustomAttributeArgument))]
[assembly: TypeForwardedTo(typeof(CustomAttributeNamedArgument))]
[assembly: TypeForwardedTo(typeof(EventAttributes))]
[assembly: TypeForwardedTo(typeof(EventDefinition))]
[assembly: TypeForwardedTo(typeof(EventReference))]
[assembly: TypeForwardedTo(typeof(ExportedType))]
[assembly: TypeForwardedTo(typeof(FieldAttributes))]
[assembly: TypeForwardedTo(typeof(FieldDefinition))]
[assembly: TypeForwardedTo(typeof(FieldReference))]
[assembly: TypeForwardedTo(typeof(GenericInstanceMethod))]
[assembly: TypeForwardedTo(typeof(GenericInstanceType))]
[assembly: TypeForwardedTo(typeof(GenericParameter))]
[assembly: TypeForwardedTo(typeof(GenericParameterAttributes))]
[assembly: TypeForwardedTo(typeof(GenericParameterConstraint))]
[assembly: TypeForwardedTo(typeof(GenericParameterType))]
[assembly: TypeForwardedTo(typeof(IAssemblyResolver))]
[assembly: TypeForwardedTo(typeof(ICustomAttributeProvider))]
[assembly: TypeForwardedTo(typeof(IGenericParameterProvider))]
[assembly: TypeForwardedTo(typeof(IMemberDefinition))]
[assembly: TypeForwardedTo(typeof(IMetadataImporter))]
[assembly: TypeForwardedTo(typeof(IMetadataImporterProvider))]
[assembly: TypeForwardedTo(typeof(IMetadataResolver))]
[assembly: TypeForwardedTo(typeof(IMetadataScope))]
[assembly: TypeForwardedTo(typeof(IMetadataTokenProvider))]
[assembly: TypeForwardedTo(typeof(IMethodSignature))]
[assembly: TypeForwardedTo(typeof(InterfaceImplementation))]
[assembly: TypeForwardedTo(typeof(IReflectionImporter))]
[assembly: TypeForwardedTo(typeof(IReflectionImporterProvider))]
[assembly: TypeForwardedTo(typeof(ManifestResourceAttributes))]
[assembly: TypeForwardedTo(typeof(MarshalInfo))]
[assembly: TypeForwardedTo(typeof(MdbReader))]
[assembly: TypeForwardedTo(typeof(MemberReference))]
[assembly: TypeForwardedTo(typeof(MetadataKind))]
[assembly: TypeForwardedTo(typeof(MetadataScopeType))]
[assembly: TypeForwardedTo(typeof(MetadataToken))]
[assembly: TypeForwardedTo(typeof(MetadataType))]
[assembly: TypeForwardedTo(typeof(MethodAttributes))]
[assembly: TypeForwardedTo(typeof(MethodCallingConvention))]
[assembly: TypeForwardedTo(typeof(MethodDefinition))]
[assembly: TypeForwardedTo(typeof(MethodImplAttributes))]
[assembly: TypeForwardedTo(typeof(MethodReference))]
[assembly: TypeForwardedTo(typeof(MethodReturnType))]
[assembly: TypeForwardedTo(typeof(MethodSemanticsAttributes))]
[assembly: TypeForwardedTo(typeof(ModuleAttributes))]
[assembly: TypeForwardedTo(typeof(ModuleCharacteristics))]
[assembly: TypeForwardedTo(typeof(ModuleDefinition))]
[assembly: TypeForwardedTo(typeof(ModuleKind))]
[assembly: TypeForwardedTo(typeof(ModuleParameters))]
[assembly: TypeForwardedTo(typeof(ModuleReference))]
[assembly: TypeForwardedTo(typeof(NativeType))]
[assembly: TypeForwardedTo(typeof(ParameterAttributes))]
[assembly: TypeForwardedTo(typeof(ParameterDefinition))]
[assembly: TypeForwardedTo(typeof(ParameterReference))]
[assembly: TypeForwardedTo(typeof(NativePdbReader))]
[assembly: TypeForwardedTo(typeof(NativePdbWriter))]
[assembly: TypeForwardedTo(typeof(PInvokeAttributes))]
[assembly: TypeForwardedTo(typeof(PInvokeInfo))]
[assembly: TypeForwardedTo(typeof(PropertyAttributes))]
[assembly: TypeForwardedTo(typeof(PropertyDefinition))]
[assembly: TypeForwardedTo(typeof(PropertyReference))]
[assembly: TypeForwardedTo(typeof(ReaderParameters))]
[assembly: TypeForwardedTo(typeof(ReadingMode))]
[assembly: TypeForwardedTo(typeof(ResolutionException))]
[assembly: TypeForwardedTo(typeof(Resource))]
[assembly: TypeForwardedTo(typeof(ResourceType))]
[assembly: TypeForwardedTo(typeof(IILVisitor))]
[assembly: TypeForwardedTo(typeof(ILParser))]
[assembly: TypeForwardedTo(typeof(ModuleDefinitionRocks))]
[assembly: TypeForwardedTo(typeof(TypeDefinitionRocks))]
[assembly: TypeForwardedTo(typeof(SecurityAction))]
[assembly: TypeForwardedTo(typeof(SecurityAttribute))]
[assembly: TypeForwardedTo(typeof(SecurityDeclaration))]
[assembly: TypeForwardedTo(typeof(TargetArchitecture))]
[assembly: TypeForwardedTo(typeof(TargetRuntime))]
[assembly: TypeForwardedTo(typeof(TokenType))]
[assembly: TypeForwardedTo(typeof(TypeAttributes))]
[assembly: TypeForwardedTo(typeof(TypeDefinition))]
[assembly: TypeForwardedTo(typeof(TypeReference))]
[assembly: TypeForwardedTo(typeof(TypeSpecification))]
[assembly: TypeForwardedTo(typeof(TypeSystem))]
[assembly: TypeForwardedTo(typeof(WriterParameters))]
[assembly: TypeForwardedTo(typeof(Collection<>))]
[assembly: TypeForwardedTo(typeof(AnonymousScopeEntry))]
[assembly: TypeForwardedTo(typeof(CapturedScope))]
[assembly: TypeForwardedTo(typeof(CapturedVariable))]
[assembly: TypeForwardedTo(typeof(CodeBlockEntry))]
[assembly: TypeForwardedTo(typeof(CompileUnitEntry))]
[assembly: TypeForwardedTo(typeof(LineNumberEntry))]
[assembly: TypeForwardedTo(typeof(LineNumberTable))]
[assembly: TypeForwardedTo(typeof(LocalVariableEntry))]
[assembly: TypeForwardedTo(typeof(MethodEntry))]
[assembly: TypeForwardedTo(typeof(MonoSymbolFile))]
[assembly: TypeForwardedTo(typeof(NamespaceEntry))]
[assembly: TypeForwardedTo(typeof(OffsetTable))]
[assembly: TypeForwardedTo(typeof(ScopeVariable))]
[assembly: TypeForwardedTo(typeof(SourceFileEntry))]
[assembly: TypeForwardedTo(typeof(CecilILGenerator))]
[assembly: TypeForwardedTo(typeof(ILGeneratorShim))]
[assembly: TypeForwardedTo(typeof(DMDEmitDynamicMethodGenerator))]
[assembly: TypeForwardedTo(typeof(DMDGenerator<>))]
[assembly: TypeForwardedTo(typeof(DynamicMethodDefinition))]
[assembly: TypeForwardedTo(typeof(Extensions))]
[assembly: TypeForwardedTo(typeof(ICallSiteGenerator))]
[assembly: TypeForwardedTo(typeof(ReflectionHelper))]
[assembly: TypeForwardedTo(typeof(Relinker))]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_0135: 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);
			val2.BaseType = module.ImportReference(typeof(MulticastDelegate));
			TypeDefinition val3 = val2;
			module.Types.Add(val3);
			if (convention.HasValue)
			{
				CustomAttribute val4 = new CustomAttribute(module.ImportReference(CallingConvAttr));
				val4.ConstructorArguments.Add(new CustomAttributeArgument(module.ImportReference(typeof(CallingConvention)), (object)convention.Value));
				val3.CustomAttributes.Add(val4);
			}
			MethodDefinition val5 = new MethodDefinition(".ctor", (MethodAttributes)4230, module.ImportReference(typeof(void)))
			{
				ImplAttributes = (MethodImplAttributes)3
			};
			Extensions.AddRange<ParameterDefinition>(((MethodReference)val5).Parameters, (IEnumerable<ParameterDefinition>)(object)new ParameterDefinition[2]
			{
				new ParameterDefinition(module.ImportReference(typeof(object))),
				new ParameterDefinition(module.ImportReference(typeof(IntPtr)))
			});
			val3.Methods.Add(val5);
			MethodDefinition val6 = new MethodDefinition("Invoke", (MethodAttributes)198, module.ImportReference(returnType))
			{
				ImplAttributes = (MethodImplAttributes)3
			};
			Extensions.AddRange<ParameterDefinition>(((MethodReference)val6).Parameters, ((IEnumerable<Type>)argTypes).Select((Func<Type, ParameterDefinition>)((Type t) => new ParameterDefinition(module.ImportReference(t)))));
			val3.Methods.Add(val6);
			Assembly assembly = ReflectionHelper.Load(val.MainModule);
			return assembly.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")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	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")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			ConstructorInfo constructor = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), 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 Extensions.CreateDelegate<InstantiationHandler<T>>((MethodBase)val.Generate());
		}

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

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

		[Obsolete("Use AccessTools.FieldRefAccess<T, S>(name) for fields and AccessTools.MethodDelegate<Func<T, S>>(AccessTools.PropertyGetter(typeof(T), name)) for properties")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		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))")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static SetterHandler<T, S> CreateSetterHandler<T, S>(PropertyInfo propertyInfo)
		{
			MethodInfo setMethod = propertyInfo.GetSetMethod(nonPublic: true);
			DynamicMethodDefinition val = CreateSetDynamicMethod<T, S>(propertyInfo.DeclaringType);
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldarg_1);
			iLGenerator.Emit(OpCodes.Call, setMethod);
			iLGenerator.Emit(OpCodes.Ret);
			return Extensions.CreateDelegate<SetterHandler<T, S>>((MethodBase)val.Generate());
		}

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

		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 Extensions.CreateDelegate<FastInvokeHandler>((MethodBase)val.Generate());
		}

		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);
			}
		}
	}
	public delegate ref T RefResult<T>();
	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 IEnumerable<HarmonyArgument> AllHarmonyArguments(object[] attributes)
		{
			return attributes.Select((object attr) => (attr.GetType().Name != "HarmonyArgument") ? null : AccessTools.MakeDeepCopy<HarmonyArgument>(attr)).OfType<HarmonyArgument>();
		}

		internal static HarmonyArgument GetArgumentAttribute(this ParameterInfo parameter)
		{
			object[] customAttributes = parameter.GetCustomAttributes(inherit: true);
			return AllHarmonyArguments(customAttributes).FirstOrDefault();
		}

		internal static IEnumerable<HarmonyArgument> GetArgumentAttributes(this MethodInfo method)
		{
			object[] customAttributes = method.GetCustomAttributes(inherit: true);
			return AllHarmonyArguments(customAttributes);
		}

		internal static IEnumerable<HarmonyArgument> GetArgumentAttributes(this Type type)
		{
			object[] customAttributes = type.GetCustomAttributes(inherit: true);
			return AllHarmonyArguments(customAttributes);
		}

		internal static string GetRealName(this IEnumerable<HarmonyArgument> attributes, string name, string[] originalParameterNames)
		{
			HarmonyArgument harmonyArgument = attributes.FirstOrDefault((HarmonyArgument p) => p.OriginalName == name);
			if (harmonyArgument == null)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(harmonyArgument.NewName))
			{
				return harmonyArgument.NewName;
			}
			if (originalParameterNames != null && harmonyArgument.Index >= 0 && harmonyArgument.Index < originalParameterNames.Length)
			{
				return originalParameterNames[harmonyArgument.Index];
			}
			return null;
		}

		private static string GetRealParameterName(this MethodInfo method, string[] originalParameterNames, string name)
		{
			if ((object)method == null || method is DynamicMethod)
			{
				return name;
			}
			string realName = method.GetArgumentAttributes().GetRealName(name, originalParameterNames);
			if (realName != null)
			{
				return realName;
			}
			Type declaringType = method.DeclaringType;
			if ((object)declaringType != null)
			{
				realName = declaringType.GetArgumentAttributes().GetRealName(name, originalParameterNames);
				if (realName != null)
				{
					return realName;
				}
			}
			return name;
		}

		private static string GetRealParameterName(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;
		}

		internal static int GetArgumentIndex(this MethodInfo patch, string[] originalParameterNames, ParameterInfo patchParam)
		{
			if (patch is DynamicMethod)
			{
				return Array.IndexOf<string>(originalParameterNames, patchParam.Name);
			}
			string realParameterName = patchParam.GetRealParameterName(originalParameterNames);
			if (realParameterName != null)
			{
				return Array.IndexOf(originalParameterNames, realParameterName);
			}
			realParameterName = patch.GetRealParameterName(originalParameterNames, patchParam.Name);
			if (realParameterName != null)
			{
				return Array.IndexOf(originalParameterNames, realParameterName);
			}
			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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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 == true;
			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_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Expected O, but got Unknown
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: 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> enumerator = iLManipulator.Body.Variables.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							VariableDefinition current = enumerator.Current;
							ctx.Body.Variables.Add(new VariableDefinition(ctx.Module.ImportReference(((VariableReference)current).VariableType)));
						}
					}
					finally
					{
						((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
					foreach (MethodInfo item in transpilers)
					{
						iLManipulator.AddTranspiler(item);
					}
					iLManipulator.WriteTo(ctx.Body, standin.method);
					HarmonyManipulator.ApplyManipulators(ctx, original, ilmanipulators, null);
					StackTraceFixes.FixStackTrace(ctx);
					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);
				}
			}, false);
			try
			{
				val.Apply();
			}
			catch (Exception ex)
			{
				throw HarmonyException.Create(ex, patchBody);
			}
			MethodInfo methodInfo = val.Method as MethodInfo;
			PatchTools.RememberObject(standin.method, (methodInfo, val));
			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)
		{
			List<MethodBase> list = PatchProcessor.GetAllPatchedMethods().ToList();
			foreach (MethodBase item in list)
			{
				Patches patchInfo = PatchProcessor.GetPatchInfo(item);
				PatchProcessor patchProcessor = new PatchProcessor(null, item);
				patchInfo.Postfixes.DoIf(executionCondition, delegate(Patch patch)
				{
					patchProcessor.Unpatch(patch.PatchMethod);
				});
				patchInfo.Prefixes.DoIf(executionCondition, delegate(Patch patch)
				{
					patchProcessor.Unpatch(patch.PatchMethod);
				});
				patchInfo.ILManipulators.DoIf(executionCondition, delegate(Patch patch)
				{
					patchProcessor.Unpatch(patch.PatchMethod);
				});
				patchInfo.Transpilers.DoIf(executionCondition, delegate(Patch patch)
				{
					patchProcessor.Unpatch(patch.PatchMethod);
				});
				patchInfo.Finalizers.DoIf(executionCondition, delegate(Patch patch)
				{
					patchProcessor.Unpatch(patch.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;

		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 = customAttributes.Where((object attr) => attr.GetType().BaseType.FullName == PatchTools.harmonyAttributeFullName).Select(delegate(object attr)
			{
				FieldInfo fieldInfo = AccessTools.Field(attr.GetType(), "info");
				return fieldInfo.GetValue(attr);
			}).Select(AccessTools.MakeDeepCopy<HarmonyMethod>)
				.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 flag)
			{
				if (flag || m.declaringType != null)
				{
					return m.methodName != null;
				}
				return false;
			}
			static bool Same(HarmonyMethod m1, HarmonyMethod m2)
			{
				if (m1.declaringType == m2.declaringType && 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 num = 0; num < array.Length; num++)
			{
				HarmonyPatchType value = array[num];
				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 is PatchSortingWrapper patchSortingWrapper) ? patchSortingWrapper.innerPatch : null, 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
	{
		internal static readonly string harmonyMethodFullName = typeof(HarmonyMethod).FullName;

		internal static readonly string harmonyAttributeFullName = typeof(HarmonyAttribute).FullName;

		internal static readonly string harmonyPatchAllFullName = typeof(HarmonyPatchAll).FullName;

		private static readonly Dictionary<object, object> objectReferences = new Dictionary<object, object>();

		internal static void RememberObject(object key, object value)
		{
			lock (objectReferences)
			{
				objectReferences[key] = value;
			}
		}

		public static MethodInfo CreateMethod(string name, Type returnType, List<KeyValuePair<string, Type>> parameters, Action<ILGenerator> generator)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			Type[] array = parameters.Select((KeyValuePair<string, Type> p) => p.Value).ToArray();
			if (AccessTools.IsMonoRuntime && !ReflectionTools.isWindows)
			{
				AssemblyName name2 = new AssemblyName("TempAssembly");
				AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(name2, AssemblyBuilderAccess.Run);
				ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("TempModule");
				TypeBuilder typeBuilder = moduleBuilder.DefineType("TempType", TypeAttributes.Public);
				MethodBuilder methodBuilder = typeBuilder.DefineMethod(name, MethodAttributes.Public | MethodAttributes.Static, returnType, array);
				for (int num = 0; num < parameters.Count; num++)
				{
					methodBuilder.DefineParameter(num + 1, ParameterAttributes.None, parameters[num].Key);
				}
				generator(methodBuilder.GetILGenerator());
				Type type = typeBuilder.CreateTypeInfo().AsType();
				return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public);
			}
			DynamicMethodDefinition val = new DynamicMethodDefinition(name, returnType, array);
			for (int num2 = 0; num2 < parameters.Count; num2++)
			{
				((ParameterReference)((MethodReference)val.Definition).Parameters[num2]).Name = parameters[num2].Key;
			}
			generator(val.GetILGenerator());
			return val.Generate();
		}

		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)
		{
			AssemblyName name2 = new AssemblyName(name);
			return AssemblyBuilder.DefineDynamicAssembly(name2, AssemblyBuilderAccess.Run);
		}

		internal static List<AttributePatch> GetPatchMethods(Type type, bool collectIncomplete = false)
		{
			return (from attributePatch in AccessTools.GetDeclaredMethods(type).SelectMany((MethodInfo method) => AttributePatch.Create(method, 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 (string.IsNullOrEmpty(attr.methodName))
						{
							return null;
						}
						return AccessTools.DeclaredMethod(attr.declaringType, attr.methodName, attr.argumentTypes);
					case MethodType.Getter:
						if (string.IsNullOrEmpty(attr.methodName))
						{
							return AccessTools.DeclaredIndexerGetter(attr.declaringType, attr.argumentTypes);
						}
						return AccessTools.DeclaredPropertyGetter(attr.declaringType, attr.methodName);
					case MethodType.Setter:
						if (string.IsNullOrEmpty(attr.methodName))
						{
							return AccessTools.DeclaredIndexerSetter(attr.declaringType, attr.argumentTypes);
						}
						return AccessTools.DeclaredPropertySetter(attr.declaringType, attr.methodName);
					case MethodType.Constructor:
						return AccessTools.DeclaredConstructor(attr.declaringType, attr.argumentTypes);
					case MethodType.StaticConstructor:
						return AccessTools.GetDeclaredConstructors(attr.declaringType).FirstOrDefault((ConstructorInfo c) => c.IsStatic);
					case MethodType.Enumerator:
						if (string.IsNullOrEmpty(attr.methodName))
						{
							return null;
						}
						return AccessTools.EnumeratorMoveNext(AccessTools.DeclaredMethod(attr.declaringType, attr.methodName, attr.argumentTypes));
					case MethodType.Async:
						if (string.IsNullOrEmpty(attr.methodName))
						{
							return null;
						}
						return AccessTools.AsyncMoveNext(AccessTools.DeclaredMethod(attr.declaringType, 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,
		Async
	}
	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, AllowMultiple = false)]
	public class HarmonyPatchCategory : HarmonyAttribute
	{
		public HarmonyPatchCategory(string category)
		{
			info.category = category;
		}
	}
	[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;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class HarmonyOptional : HarmonyAttribute
	{
		public HarmonyOptional()
		{
			info.optional = true;
		}
	}
	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 static CodeInstruction LoadLocal(int index, bool useAddress = false)
		{
			if (useAddress)
			{
				if (index < 256)
				{
					return new CodeInstruction(OpCodes.Ldloca_S, Convert.ToByte(index));
				}
				return new CodeInstruction(OpCodes.Ldloca, index);
			}
			if (index == 0)
			{
				return new CodeInstruction(OpCodes.Ldloc_0);
			}
			if (index == 1)
			{
				return new CodeInstruction(OpCodes.Ldloc_1);
			}
			if (index == 2)
			{
				return new CodeInstruction(OpCodes.Ldloc_2);
			}
			if (index == 3)
			{
				return new CodeInstruction(OpCodes.Ldloc_3);
			}
			if (index < 256)
			{
				return new CodeInstruction(OpCodes.Ldloc_S, Convert.ToByte(index));
			}
			return new CodeInstruction(OpCodes.Ldloc, index);
		}

		public static CodeInstruction StoreLocal(int index)
		{
			if (index == 0)
			{
				return new CodeInstruction(OpCodes.Stloc_0);
			}
			if (index == 1)
			{
				return new CodeInstruction(OpCodes.Stloc_1);
			}
			if (index == 2)
			{
				return new CodeInstruction(OpCodes.Stloc_2);
			}
			if (index == 3)
			{
				return new CodeInstruction(OpCodes.Stloc_3);
			}
			if (index < 256)
			{
				return new CodeInstruction(OpCodes.Stloc_S, Convert.ToByte(index));
			}
			return new CodeInstruction(OpCodes.Stloc, index);
		}

		public static CodeInstruction LoadArgument(int index, bool useAddress = false)
		{
			if (useAddress)
			{
				if (index < 256)
				{
					return new CodeInstruction(OpCodes.Ldarga_S, Convert.ToByte(index));
				}
				return new CodeInstruction(OpCodes.Ldarga, index);
			}
			if (index == 0)
			{
				return new CodeInstruction(OpCodes.Ldarg_0);
			}
			if (index == 1)
			{
				return new CodeInstruction(OpCodes.Ldarg_1);
			}
			if (index == 2)
			{
				return new CodeInstruction(OpCodes.Ldarg_2);
			}
			if (index == 3)
			{
				return new CodeInstruction(OpCodes.Ldarg_3);
			}
			if (index < 256)
			{
				return new CodeInstruction(OpCodes.Ldarg_S, Convert.ToByte(index));
			}
			return new CodeInstruction(OpCodes.Ldarg, index);
		}

		public static CodeInstruction StoreArgument(int index)
		{
			if (index < 256)
			{
				return new CodeInstruction(OpCodes.Starg_S, Convert.ToByte(index));
			}
			return new CodeInstruction(OpCodes.Starg, index);
		}

		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/*cast due to .constrained prefix*/).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);
			base..ctor();
		}
	}
	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;

		private static int _autoGuidCounter;

		public string Id { get; }

		static Harmony()
		{
			_autoGuidCounter = 100;
			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
			{
				StringBuilder stringBuilder = new StringBuilder();
				Assembly assembly = typeof(Harmony).Assembly;
				Version version = assembly.GetName().Version;
				string location = assembly.Location;
				string value = Environment.Version.ToString();
				string value2 = Environment.OSVersion.Platform.ToString();
				int size = IntPtr.Size;
				stringBuilder.AppendLine($"### Harmony id={id}, version={version}, location={location}, env/clr={value}, platform={value2}, ptrsize:runtime={size}");
				if ((object)callingMethod?.DeclaringType != null)
				{
					Assembly assembly2 = callingMethod.DeclaringType.Assembly;
					location = assembly2.Location;
					stringBuilder.AppendLine("### Started from " + callingMethod.FullDescription() + ", location " + location);
					stringBuilder.Append($"### At {DateTime.Now:yyyy-MM-dd hh.mm.ss}");
				}
				return stringBuilder.ToString();
			});
			Id = id;
		}

		public void PatchAll()
		{
			MethodBase method = new StackTrace().GetFrame(1).GetMethod();
			Assembly assembly = method.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 void PatchAllUncategorized()
		{
			MethodBase method = new StackTrace().GetFrame(1).GetMethod();
			Assembly assembly = method.ReflectedType.Assembly;
			PatchAllUncategorized(assembly);
		}

		public void PatchAllUncategorized(Assembly assembly)
		{
			PatchClassProcessor[] sequence = AccessTools.GetTypesFromAssembly(assembly).Select(CreateClassProcessor).ToArray();
			sequence.DoIf((PatchClassProcessor patchClass) => string.IsNullOrEmpty(patchClass.Category), delegate(PatchClassProcessor patchClass)
			{
				patchClass.Patch();
			});
		}

		public void PatchCategory(string category)
		{
			MethodBase method = new StackTrace().GetFrame(1).GetMethod();
			Assembly assembly = method.ReflectedType.Assembly;
			PatchCategory(assembly, category);
		}

		public void PatchCategory(Assembly assembly, string category)
		{
			AccessTools.GetTypesFromAssembly(assembly).Where(delegate(Type type)
			{
				List<HarmonyMethod> fromType = HarmonyMethodExtensions.GetFromType(type);
				HarmonyMethod harmonyMethod = HarmonyMethod.Merge(fromType);
				return harmonyMethod.category == category;
			}).Do(delegate(Type type)
			{
				CreateClassProcessor(type).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 = "*")
		{
			PatchProcessor patchProcessor = CreateProcessor(original);
			patchProcessor.Unpatch(type, harmonyID);
		}

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

		public void UnpatchCategory(string category)
		{
			MethodBase method = new StackTrace().GetFrame(1).GetMethod();
			Assembly assembly = method.ReflectedType.Assembly;
			UnpatchCategory(assembly, category);
		}

		public void UnpatchCategory(Assembly assembly, string category)
		{
			AccessTools.GetTypesFromAssembly(assembly).Where(delegate(Type type)
			{
				List<HarmonyMethod> fromType = HarmonyMethodExtensions.GetFromType(type);
				HarmonyMethod harmonyMethod = HarmonyMethod.Merge(fromType);
				return harmonyMethod.category == category;
			}).Do(delegate(Type type)
			{
				CreateClassProcessor(type).Unpatch();
			});
		}

		public static bool HasAnyPatches(string harmonyID)
		{
			return GetAllPatchedMethods().Select(GetPatchInfo).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.GetRealMethod(replacement, useReplacement: false);
		}

		public static MethodBase GetMethodFromStackframe(StackFrame frame)
		{
			if (frame == null)
			{
				throw new ArgumentNullException("frame");
			}
			return PatchManager.GetStackFrameMethod(frame, useReplacement: true);
		}

		public static MethodBase GetOriginalMethodFromStackframe(StackFrame frame)
		{
			if (frame == null)
			{
				throw new ArgumentNullException("frame");
			}
			return PatchManager.GetStackFrameMethod(frame, useReplacement: false);
		}

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

		public static Harmony CreateAndPatchAll(Type type, string harmonyInstanceId = null)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			Harmony harmony = new Harmony(harmonyInstanceId ?? $"harmony-auto-{Interlocked.Increment(ref _autoGuidCounter)}-{type.Assembly.GetName().Name}-{type.FullName}");
			harmony.PatchAll(type);
			return harmony;
		}

		public static Harmony CreateAndPatchAll(Assembly assembly, string harmonyInstanceId = null)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			Harmony harmony = new Harmony(harmonyInstanceId ?? $"harmony-auto-{Interlocked.Increment(ref _autoGuidCounter)}-{assembly.GetName().Name}");
			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 { instructions: { Count: >0 }, 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 string category;

		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 bool? optional;

		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(Delegate @delegate)
			: this(@delegate.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(Delegate @delegate, int priority = -1, string[] before = null, string[] after = null, bool? debug = null)
			: this(@delegate.Method, priority, before, after, 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)
		{
			if (attributes == null || attributes.Count == 0)
			{
				return new HarmonyMethod();
			}
			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 value = (((object)declaringType != null) ? declaringType.FullDescription() : "undefined");
			string value2 = methodName ?? "undefined";
			string value3 = (methodType.HasValue ? methodType.Value.ToString() : "undefined");
			string value4 = ((argumentTypes != null) ? argumentTypes.Description() : "undefined");
			return $"(class={value}, methodname={value2}, type={value3}, args={value4})";
		}

		internal Type[] GetArgumentList()
		{
			return argumentTypes ?? Type.EmptyTypes;
		}

		public static implicit operator HarmonyMethod(MethodInfo method)
		{
			return new HarmonyMethod(method);
		}

		public static implicit operator HarmonyMethod(Delegate @delegate)
		{
			return new HarmonyMethod(@delegate);
		}
	}
	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")
				{
					Type underlyingType = Nullable.GetUnderlyingType(traverse.GetValueType());
					val = Enum.ToObject(underlyingType, (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")
				{
					SetValue(resultTrv, f, value2 ?? value);
				}
				else
				{
					int num = (int)value;
					int num2 = (int)value2;
					int num3 = Math.Max(num, num2);
					if (num == -1 && num2 != -1)
					{
						num3 = num2;
					}
					if (num != -1 && num2 == -1)
					{
						num3 = num;
					}
					SetValue(resultTrv, f, num3);
				}
			});
			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 != PatchTools.harmonyMethodFullName)
			{
				return null;
			}
			object value = field.GetValue(attribute);
			return AccessTools.MakeDeepCopy<HarmonyMethod>(value);
		}

		public static List<HarmonyMethod> GetFromType(Type type)
		{
			return (from info in type.GetCustomAttributes(inherit: true).Select(GetHarmonyMethodInfo)
				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 info in method.GetCustomAttributes(inherit: true).Select(GetHarmonyMethodInfo)
				where info != null
				select info).ToList();
		}

		public static HarmonyMethod GetMergedFromMethod(MethodBase method)
		{
			return HarmonyMethod.Merge(GetFromMethod(method));
		}
	}
	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)
				};
				Type[] array2 = array;
				foreach (Type type in array2)
				{
					if (typeName == type.FullName)
					{
						return type;
					}
				}
				return Type.GetType($"{typeName}, {assemblyName}");
			}
		}

		private static readonly JsonSerializerOptions serializerOptions = new JsonSerializerOptions
		{
			IncludeFields = true
		};

		internal static bool? useBinaryFormatter = null;

		internal static readonly BinaryFormatter binaryFormatter = new BinaryFormatter
		{
			Binder = new Binder()
		};

		internal static bool UseBinaryFormatter
		{
			get
			{
				if (!useBinaryFormatter.HasValue)
				{
					if (AppContext.TryGetSwitch("System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization", out var isEnabled))
					{
						useBinaryFormatter = isEnabled;
					}
					else
					{
						useBinaryFormatter = true;
					}
				}
				return useBinaryFormatter.Value;
			}
		}

		internal static byte[] Serialize(this PatchInfo patchInfo)
		{
			if (UseBinaryFormatter)
			{
				using (MemoryStream memoryStream = new MemoryStream())
				{
					binaryFormatter.Serialize(memoryStream, patchInfo);
					return memoryStream.GetBuffer();
				}
			}
			return JsonSerializer.SerializeToUtf8Bytes(patchInfo);
		}

		internal static PatchInfo Deserialize(byte[] bytes)
		{
			if (UseBinaryFormatter)
			{
				using (MemoryStream serializationStream = new MemoryStream(bytes))
				{
					return (PatchInfo)binaryFormatter.Deserialize(serializationStream);
				}
			}
			return JsonSerializer.Deserialize<PatchInfo>(bytes, serializerOptions);
		}

		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
	{
		[JsonInclude]
		public Patch[] prefixes = Array.Empty<Patch>();

		[JsonInclude]
		public Patch[] postfixes = Array.Empty<Patch>();

		[JsonInclude]
		public Patch[] transpilers = Array.Empty<Patch>();

		[JsonInclude]
		public Patch[] finalizers = Array.Empty<Patch>();

		[JsonInclude]
		public Patch[] ilmanipulators = Array.Empty<Patch>();

		[JsonIgnore]
		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;
			}
		}

		[JsonIgnore]
		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.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		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.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		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.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		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.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		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;
			List<Patch> list = new List<Patch>();
			list.AddRange(current);
			list.AddRange(add.Where((HarmonyMethod method) => method != null).Select((HarmonyMethod method, int i) => new Patch(method, i + initialIndex, owner)));
			return list.ToArray();
		}

		private static Patch[] Remove(string owner, Patch[] current)
		{
			if (!(owner == "*"))
			{
				return current.Where((Patch patch) => patch.owner != owner).ToArray();
			}
			return Array.Empty<Patch>();
		}
	}
	[Serializable]
	[JsonConverter(typeof(PatchJsonConverter))]
	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;

		[JsonIgnore]
		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 ?? Array.Empty<string>();
			this.after = after ?? Array.Empty<string>();
			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 ?? Array.Empty<string>();
			this.after = after ?? Array.Empty<string>();
			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 ?? Array.Empty<string>();
			this.after = after ?? Array.Empty<string>();
			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 == true, method.wrapTryCatch == true, method.debugEmitPath)
		{
		}

		internal Patch(int index, string owner, int priority, string[] before, string[] after, bool debug, int methodToken, string moduleGUID)
		{
			this.index = index;
			this.owner = owner;
			this.priority = ((priority == -1) ? 400 : priority);
			this.before = before ?? Array.Empty<string>();
			this.after = after ?? Array.Empty<string>();
			this.debug = debug;
			this.methodToken = methodToken;
			this.moduleGUID = moduleGUID;
		}

		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>(4)
		{
			typeof(HarmonyPrepare),
			typeof(HarmonyCleanup),
			typeof(HarmonyTargetMethod),
			typeof(HarmonyTargetMethods)
		};

		public string Category { get; set; }

		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);
			HarmonyMethod harmonyMethod = containerAttributes;
			MethodType valueOrDefault = harmonyMethod.methodType.GetValueOrDefault();
			if (!harmonyMethod.methodType.HasValue)
			{
				valueOrDefault = MethodType.Normal;
				harmonyMethod.methodType = valueOrDefault;
			}
			Category = containerAttributes.category;
			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.declaringType != 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, unpatch: false) : PatchWithAttributes(ref lastOriginal, unpatch: false));
			}
			catch (Exception ex)
			{
				exception = ex;
			}
			RunMethod<HarmonyCleanup>(ref exception, new object[1] { exception });
			ReportException(exception, lastOriginal);
			return result;
		}

		public void Unpatch()
		{
			if (containerAttributes != null)
			{
				List<MethodBase> bulkMethods = GetBulkMethods();
				MethodBase lastOriginal = null;
				if (bulkMethods.Count > 0)
				{
					BulkPatch(bulkMethods, ref lastOriginal, unpatch: true);
				}
				else
				{
					PatchWithAttributes(ref lastOriginal, unpatch: true);
				}
			}
		}

		private void ReversePatch(ref MethodBase lastOriginal)
		{
			for (int i = 0; i < patchMethods.Count; i++)
			{
				AttributePatch patchMethod = patchMethods[i];
				if (patchMethod.type != HarmonyPatchType.ReversePatch)
				{
					continue;
				}
				MethodBase originalMethod = patchMethod.info.GetOriginalMethod();
				if ((object)originalMethod != null)
				{
					lastOriginal = originalMethod;
				}
				if ((object)lastOriginal == null)
				{
					if (patchMethod.info.optional != true)
					{
						throw new ArgumentException("Undefined target method for reverse patch method " + patchMethod.info.method.FullDescription());
					}
					Logger.Log(Logger.LogChannel.Warn, () => "Skipping optional reverse patch " + patchMethod.info.method.FullDescription() + " - target method not found");
				}
				else
				{
					ReversePatcher reversePatcher = instance.CreateReversePatcher(lastOriginal, patchMethod.info);
					lock (PatchProcessor.locker)
					{
						reversePatcher.Patch();
					}
				}
			}
		}

		private List<MethodInfo> BulkPatch(List<MethodBase> originals, ref MethodBase lastOriginal, bool unpatch)
		{
			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 != MethodType.Normal)
					{
						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;
				if (unpatch)
				{
					ProcessUnpatchJob(job2);
				}
				else
				{
					ProcessPatchJob(job2);
				}
			}
			return patchJobs.GetReplacements();
		}

		private List<MethodInfo> PatchWithAttributes(ref MethodBase lastOriginal, bool unpatch)
		{
			PatchJobs<MethodInfo> patchJobs = new PatchJobs<MethodInfo>();
			foreach (AttributePatch patchMethod in patchMethods)
			{
				lastOriginal = patchMethod.info.GetOriginalMethod();
				if ((object)lastOriginal == null)
				{
					if (patchMethod.info.optional != true)
					{
						throw new ArgumentException("Undefined target method for patch method " + patchMethod.info.method.FullDescription());
					}
					Logger.Log(Logger.LogChannel.Warn, () => "Skipping optional patch " + patchMethod.info.method.FullDescription() + " - target method not found");
				}
				else
				{
					PatchJobs<MethodInfo>.Job job = patchJobs.GetJob(lastOriginal);
					job.AddPatch(patchMethod);
				}
			}
			foreach (PatchJobs<MethodInfo>.Job job2 in patchJobs.GetJobs())
			{
				lastOriginal = job2.original;
				if (unpatch)
				{
					ProcessUnpatchJob(job2);
				}
				else
				{
					ProcessPatchJob(job2);
				}
			}
			return patchJobs.GetReplacements();
		}

		private void ProcessPatchJob(PatchJobs<MethodInfo>.Job job)
		{
			MethodInfo replacement = null;
			bool flag = RunMethod<HarmonyPrepare, bool>(defaultIfNotExisting: true, defaultIfFailing: false, null, new object[1] { job.original });
			Exception exception = null;
			if (flag)
			{
				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 void ProcessUnpatchJob(PatchJobs<MethodInfo>.Job job)
		{
			PatchInfo patchInfo = job.original.GetPatchInfo() ?? new PatchInfo();
			bool flag = job.original.HasMethodBody();
			if (flag)
			{
				job.postfixes.Do(delegate(HarmonyMethod patch)
				{
					patchInfo.RemovePatch(patch.method);
				});
				job.prefixes.Do(delegate(HarmonyMethod patch)
				{
					patchInfo.RemovePatch(patch.method);
				});
			}
			job.transpilers.Do(delegate(HarmonyMethod patch)
			{
				patchInfo.RemovePatch(patch.method);
			});
			if (flag)
			{
				job.finalizers.Do(delegate(HarmonyMethod patch)
				{
					patchInfo.RemovePatch(patch.method);
				});
			}
			MethodInfo replacement = PatchFunctions.UpdateWrapper(job.original, patchInfo);
			PatchManager.AddReplacementOriginal(job.original, replacement);
		}

		private List<MethodBase> GetBulkMethods()
		{
			if (containerType.GetCustomAttributes(inherit: true).Any((object a) => a.GetType().FullName == PatchTools.harmonyPatchAllFullName))
			{
				Type declaringType = containerAttributes.declaringType;
				if ((object)declaringType == null)
				{
					throw new ArgumentException("Using " + PatchTools.harmonyPatchAllFullName + " 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;
			}
			List<MethodBase> list2 = new List<MethodBase>();
			IEnumerable<MethodBase> enumerable = RunMethod<HarmonyTargetMethods, IEnumerable<MethodBase>>(null, null, null, Array.Empty<object>());
			if (enumerable != null)
			{
				string text = null;
				list2 = enumerable.ToList();
				if (list2 == null)
				{
					text = "null";
				}
				else if (list2.Any((MethodBase m) => (object)m == null))
				{
					text = "some element was null";
				}
				if (text != null)
				{
					if (auxilaryMethods.TryGetValue(typeof(HarmonyTargetMethods), out var value))
					{
						throw new Exception("Method " + value.FullDescription() + " returned an unexpected result: " + text);
					}
					throw new Exception("Some method returned an unexpected result: " + text);
				}
				return list2;
			}
			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;
		}

		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 ?? Array.Empty<object>()).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 ?? Array.Empty<object>()).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 = Array.Empty<Patch>();
			}
			if (postfixes == null)
			{
				postfixes = Array.Empty<Patch>();
			}
			if (transpilers == null)
			{
				transpilers = Array.Empty<Patch>();
			}
			if (finalizers == null)
			{
				finalizers = Array.Empty<Patch>();
			}
			if (ilmanipulators == null)
			{
				ilmanipulators = Array.Empty<Patch>();
			}
			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)
		{
		}
	}
	internal class PatchJsonConverter : JsonConverter<Patch>
	{
		public override Patch Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			reader.Read();
			reader.Read();
			int @int = reader.GetInt32();
			reader.Read();
			reader.Read();
			bool boolean = reader.GetBoolean();
			reader.Read();
			reader.Read();
			string owner = reader.GetString();
			reader.Read();
			reader.Read();
			int int2 = reader.GetInt32();
			reader.Read();
			reader.Read();
			int int3 = reader.GetInt32();
			reader.Read();
			reader.Read();
			string moduleGUID = reader.GetString();
			reader.Read();
			reader.Read();
			List<string> list = new List<string>();
			while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
			{
				list.Add(reader.GetString());
			}
			reader.Read();
			reader.Read();
			List<string> list2 = new List<string>();
			while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
			{
				list2.Add(reader.GetString());
			}
			reader.Read();
			return new Patch(@int, owner, int2, list2.ToArray(), list.ToArray(), boolean, int3, moduleGUID);
		}

		public override void Write(Utf8JsonWriter writer, Patch patchValue, JsonSerializerOptions options)
		{
			writer.WriteStartObject();
			writer.WriteNumber("index", patchValue.index);
			writer.WriteBoolean("debug", patchValue.debug);
			writer.WriteString("owner", patchValue.owner);
			writer.WriteNumber("priority", patchValue.priority);
			writer.WriteNumber("methodToken", patchValue.PatchMethod.MetadataToken);
			writer.WriteString("moduleGUID", patchValue.PatchMethod.Module.ModuleVersionId.ToString());
			WriteStringArray(writer, "after", patchValue.after);
			WriteStringArray(writer, "before", patchValue.before);
			writer.WriteEndObject();
		}

		private static void WriteStringArray(Utf8JsonWriter writer, string propertyName, IEnumerable<string> strings)
		{
			writer.WriteStartArray(propertyName);
			foreach (string @string in strings)
			{
				writer.WriteStringValue(@string);
			}
			writer.WriteEndArray();
		}
	}
	public class PatchProcessor(Harmony instance, MethodBase original)
	{
		private readonly Harmony instance = instance;

		private readonly MethodBase original = 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 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())
			{
				MethodBase declaredMember = original.GetDeclaredMember();
				throw new ArgumentException("You can only patch implemented methods/constructors. Patch the declared method " + declaredMember.FullDescription() + " instead.");
			}
			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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			DynamicMethodDefinition val = new DynamicMethodDefinition($"ILGenerator_{Guid.NewGuid()}", typeof(void), Array.Empty<Type>());
			return val.GetILGenerator();
		}

		public static ILGenerator CreateILGenerator(MethodBase original)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			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);
			}
			DynamicMethodDefinition val = new DynamicMethodDefinition("ILGenerator_" + original.Name, type, list.ToArray());
			return val.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(Harmony instance, MethodBase original, HarmonyMethod standin)
	{
		private readonly Harmony instance = instance;

		private readonly MethodBase original = original;

		private readonly HarmonyMethod 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;
			Type declaringType = method.DeclaringType;
			List<MethodInfo> declaredMethods = AccessTools.GetDeclaredMethods(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;
			Type declaringType = method.DeclaringType;
			List<MethodInfo> declaredMethods = AccessTools.GetDeclaredMethods(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
	{
		internal static readonly Dictionary<int, Delegate> DelegateCache = new Dictionary<int, Delegate>();

		internal 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 num2 = 0; num2 < array.Length; num2++)
			{
				iLGenerator.Emit(OpCodes.Ldarg_S, (short)num2);
			}
			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)
			{
				MethodBase methodBase = instruction.operand as MethodBase;
				if (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)
		{
			MethodBody methodBody = replacement.GetMethodBody();
			if (methodBody == null)
			{
				throw new ArgumentException("Replacement method must be a managed method", "replacement");
			}
			CecilILGenerator value = Traverse.Create(ilGenerator).Field("Target").GetValue<CecilILGenerator>();
			value.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>();

		private static Type[] allTypesCached = null;

		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)
			{
				return type;
			}
			foreach (Assembly item in AllAssemblies())
			{
				Type type2 = item.GetType(name, throwOnError: false);
				if ((object)type2 != null)
				{
					return type2;
				}
			}
			Type[] source = AllTypes().ToArray();
			Type type3 = source.FirstOrDefault((Type t) => t.FullName == name);
			if ((object)type3 != null)
			{
				return type3;
			}
			Type type4 = source.FirstOrDefault((Type t) => t.Name == name);
			if ((object)type4 != null)
			{
				return type4;
			}
			Logger.Log(Logger.LogChannel.Warn, () => "AccessTools.TypeByName: Could not find type named " + name);
			return null;
		}

		public static Type TypeSearch(Regex search, bool invalidateCache = false)
		{
			if (allTypesCached == null || invalidateCache)
			{
				allTypesCached = AllTypes().ToArray();
			}
			Type type = allTypesCached.FirstOrDefault((Type t) => search.IsMatch(t.FullName));
			if ((object)type != null)
			{
				return type;
			}
			Type type2 = allTypesCached.FirstOrDefault((Type t) => search.IsMatch(t.Name));
			if ((object)type2 != null)
			{
				return type2;
			}
			Logger.Log(Logger.LogChannel.Warn, () => $"AccessTools.TypeSearch: Could not find type with regular expression {search}");
			return null;
		}

		public static void ClearTypeSearchCache()
		{
			allTypesCached = Array.Empty<Type>();
		}

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

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

		public static IEnumerable<Type> InnerTypes(Type type)
		{
			return type.GetNestedTypes(all);
		}

		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);
			foreach (Type type2 in nestedTypes)
			{
				val = FindIncludingInnerTypes(type2, func);
				if (val != null)
				{
					break;
				}
			}
			return val;
		}

		public static MethodInfo Identifiable(this MethodInfo method)
		{
			return (PlatformTriple.Current.GetIdentifiable((MethodBase)method) as MethodInfo) ?? method;
		}

		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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredField: name is null/empty");
				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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Field: name is null/empty");
				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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredProperty: name is null/empty");
				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 PropertyInfo DeclaredIndexer(Type type, Type[] parameters = null)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Debug, "AccessTools.DeclaredIndexer: type is null");
				return null;
			}
			try
			{
				PropertyInfo propertyInfo = ((parameters == null) ? type.GetProperties(allDeclared).SingleOrDefault((PropertyInfo property) => property.GetIndexParameters().Length != 0) : type.GetProperties(allDeclared).FirstOrDefault((PropertyInfo property) => (from param in property.GetIndexParameters()
					select param.ParameterType).SequenceEqual(parameters)));
				if ((object)propertyInfo == null)
				{
					Logger.Log(Logger.LogChannel.Debug, () => $"AccessTools.DeclaredIndexer: Could not find indexer for type {type} and parameters {parameters?.Description()}");
				}
				return propertyInfo;
			}
			catch (InvalidOperationException inner)
			{
				throw new AmbiguousMatchException("Multiple possible indexers were found.", inner);
			}
		}

		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 DeclaredIndexerGetter(Type type, Type[] parameters = null)
		{
			return DeclaredIndexer(type, parameters)?.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 MethodInfo DeclaredIndexerSetter(Type type, Type[] parameters)
		{
			return DeclaredIndexer(type, parameters)?.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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Property: name is null/empty");
				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 PropertyInfo Indexer(Type type, Type[] parameters = null)
		{
			if ((object)type == null)
			{
				Logger.LogText(Logger.LogChannel.Debug, "AccessTools.Indexer: type is null");
				return null;
			}
			Func<Type, PropertyInfo> func = ((parameters == null) ? ((Func<Type, PropertyInfo>)((Type t) => t.GetProperties(all).SingleOrDefault((PropertyInfo property) => property.GetIndexParameters().Length != 0))) : ((Func<Type, PropertyInfo>)((Type t) => t.GetProperties(all).FirstOrDefault((PropertyInfo property) => (from param in property.GetIndexParameters()
				select param.ParameterType).SequenceEqual(parameters)))));
			try
			{
				PropertyInfo propertyInfo = FindIncludingBaseTypes(type, func);
				if ((object)propertyInfo == null)
				{
					Logger.Log(Logger.LogChannel.Debug, () => $"AccessTools.Indexer: Could not find indexer for type {type} and parameters {parameters?.Description()}");
				}
				return propertyInfo;
			}
			catch (InvalidOperationException inner)
			{
				throw new AmbiguousMatchException("Multiple possible indexers were found.", inner);
			}
		}

		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 IndexerGetter(Type type, Type[] parameters = null)
		{
			return Indexer(type, parameters)?.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 IndexerSetter(Type type, Type[] parameters = null)
		{
			return Indexer(type, parameters)?.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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.DeclaredMethod: name is null/empty");
				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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Method: name is null/empty");
				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, Array.Empty<Type>(), 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 method)
		{
			//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)method == null)
			{
				Logger.LogText(Logger.LogChannel.Warn, "EnumeratorMoveNext.Method: enumerator is null");
				return null;
			}
			ILContext val = new ILContext(new DynamicMethodDefinition(method).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(method.Name))
				{
					Logger.Log(Logger.LogChannel.Warn, () => "EnumeratorMoveNext.Method: Unexpected type name " + ((MemberReference)firstVar).Name + ", should contain " + method.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: " + method.FullDescription() + " does not create enumerators");
					return null;
				}
				if (((MemberReference)enumeratorCtor).Name != ".ctor")
				{
					Logger.Log(Logger.LogChannel.Warn, () => $"EnumeratorMoveNext.Method: {method.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: {method.FullDescription()} creates an object {enumeratorType.FullDescription()} but it doesn't have MoveNext");
				return null;
			}
			return methodInfo;
		}

		public static MethodInfo AsyncMoveNext(MethodBase method)
		{
			if ((object)method == null)
			{
				Logger.LogText(Logger.LogChannel.Debug, "AccessTools.AsyncMoveNext: method is null");
				return null;
			}
			AsyncStateMachineAttribute customAttribute = method.GetCustomAttribute<AsyncStateMachineAttribute>();
			if (customAttribute == null)
			{
				Logger.Log(Logger.LogChannel.Debug, () => "AccessTools.AsyncMoveNext: Could not find AsyncStateMachine for " + method.FullDescription());
				return null;
			}
			Type stateMachineType = customAttribute.StateMachineType;
			MethodInfo methodInfo = DeclaredMethod(stateMachineType, "MoveNext");
			if ((object)methodInfo == null)
			{
				Logger.Log(Logger.LogChannel.Debug, () => "AccessTools.AsyncMoveNext: Could not find async method body for " + method.FullDescription());
				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) ?? Array.Empty<MemberInfo>();
			MemberInfo[] array2 = array;
			foreach (MemberInfo memberInfo in array2)
			{
				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 = Array.Empty<Type>();
			}
			BindingFlags bindingAttr = (searchForStatic ? (allDeclared & ~BindingFlags.Instance) : (allDeclared & ~BindingFlags.Static));
			return type.GetConstructor(bindingAttr, null, parameters, Array.Empty<ParameterModifier>());
		}

		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 = Array.Empty<Type>();
			}
			BindingFlags flags = (searchForStatic ? (all & ~BindingFlags.Instance) : (all & ~BindingFlags.Static));
			return FindIncludingBaseTypes(type, (Type t) => t.GetConstructor(flags, null, parameters, Array.Empty<ParameterModifier>()));
		}

		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 (string.IsNullOrEmpty(name))
			{
				Logger.LogText(Logger.LogChannel.Warn, "AccessTools.Inner: name is null/empty");
				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 Array.Empty<Type>();
			}
			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
			{
				FieldInfo fieldInfo = Field(type, fieldName);
				if ((object)fieldInfo == null)
				{
					throw new MissingFieldException(type.Name, fieldName);
				}
				return ref ReflectionTools.StaticFieldRefAccess<F>(fieldInfo)();
			}
			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);
			}
		}

		[Obsolete("This overload only exists for runtime backwards compatibility and will be removed in Harmony 3. Use MethodDelegate(MethodInfo, object, bool, Type[]) instead")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static DelegateType MethodDelegate<DelegateType>(MethodInfo method, object instance, bool virtualCall) where DelegateType : Delegate
		{
			return MethodDelegate<DelegateType>(method, instance, virtualCall, null);
		}

		public static DelegateType MethodDelegate<DelegateType>(MethodInfo method, object instance = null, bool virtualCall = true, Type[] delegateArgs = null) where DelegateType : Delegate
		{
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: 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;
				}
				Type[] array2 = delegateArgs ?? typeFromHandle.GetGenericArguments();
				Type[] array3 = ((array2.Length < array.Length) ? array : array2);
				DynamicMethodDefinition val = new DynamicMethodDefinition("OpenInstanceDelegate_" + method.Name, method.ReturnType, array3);
				ILGenerator iLGenerator = val.GetILGenerator();
				if (type != null && type.IsValueType && array2.Length != 0 && !array2[0].IsByRef)
				{
					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);
					if (array[j].IsValueType && j < array2.Length && !array2[j].IsValueType)
					{
						iLGenerator.Emit(OpCodes.Unbox_Any, array[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) });
				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());
		}

		[Obsolete("This overload only exists for runtime backwards compatibility and will be removed in Harmony 3. Use MethodDelegate(string, object, bool, Type[]) instead")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static DelegateType MethodDelegate<DelegateType>(string typeColonName, object instance, bool virtualCall) where DelegateType : Delegate
		{
			return MethodDelegate<DelegateType>(typeColonName, instance, virtualCall, null);
		}

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

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

		public static MethodBase GetOutsideCaller()
		{
			StackTrace stackTrace = new StackTrace(fNeedFileInfo: true);
			StackFrame[] frames = stackTrace.GetFrames();
			foreach (StackFrame stackFrame in frames)
			{
				MethodBase method = stackFrame.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 value = string.Join(",", GetFieldNames(type).ToArray());
			string value2 = string.Join(",", GetPropertyNames(type).ToArray());
			throw new MissingMemberException($"{string.Join(",", names)}; available fields: {value}; available properties: {value2}");
		}

		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, Array.Empty<Type>(), 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();
							string pathRoot2 = ((pathRoot.Length > 0) ? (pathRoot + "." + text) : text);
							object obj2 = MakeDeepCopy(item, resultType2, processor, pathRoot2);
							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 num2 = 0; num2 < length; num2++)
				{
					string text2 = num2.ToString();
					string pathRoot3 = ((pathRoot.Length > 0) ? (pathRoot + "." + text2) : text2);
					array[num2] = MakeDeepCopy(array2[num2], elementType, processor, pathRoot3);
				}
				return array;
			}
			string text3 = type.Namespace;
			if (text3 == "System" || (text3 != null && text3.StartsWith("System.")))
			{
				return source;
			}
			object obj3 = CreateInstance((resultType == typeof(object)) ? type : resultType);
			Traverse.IterateFields(source, obj3, delegate(string name, Traverse src, Traverse dst)
			{
				string text4 = ((pathRoot.Length > 0) ? (pathRoot + "." + name) : name);
				object source2 = ((processor != null) ? processor(text4, src, dst) : src.GetValue());
				if (dst.IsWriteable)
				{
					dst.SetValue(MakeDeepCopy(source2, dst.GetValueType(), processor, text4));
				}
			});
			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 AccessToolsExtensions
	{
		public static IEnumerable<Type> InnerTypes(this Type type)
		{
			return AccessTools.InnerTypes(type);
		}

		public static T FindIncludingBaseTypes<T>(this Type type, Func<Type, T> func) where T : class
		{
			return AccessTools.FindIncludingBaseTypes(type, func);
		}

		public static T FindIncludingInnerTypes<T>(this Type type, Func<Type, T> func) where T : class
		{
			return AccessTools.FindIncludingInnerTypes(type, func);
		}

		public static FieldInfo DeclaredField(this Type type, string name)
		{
			return AccessTools.DeclaredField(type, name);
		}

		public static FieldInfo Field(this Type type, string name)
		{
			return AccessTools.Field(type, name);
		}

		public static FieldInfo DeclaredField(this Type type, int idx)
		{
			return AccessTools.DeclaredField(type, idx);
		}

		public static PropertyInfo DeclaredProperty(this Type type, string name)
		{
			return AccessTools.DeclaredProperty(type, name);
		}

		public static PropertyInfo DeclaredIndexer(this Type type, Type[] parameters = null)
		{
			return AccessTools.DeclaredIndexer(type, parameters);
		}

		public static MethodInfo DeclaredPropertyGetter(this Type type, string name)
		{
			return AccessTools.DeclaredPropertyGetter(type, name);
		}

		public static MethodInfo DeclaredIndexerGetter(this Type type, Type[] parameters = null)
		{
			return AccessTools.DeclaredIndexerGetter(type, parameters);
		}

		public static MethodInfo DeclaredPropertySetter(this Type type, string name)
		{
			return AccessTools.DeclaredPropertySetter(type, name);
		}

		public static MethodInfo DeclaredIndexerSetter(this Type type, Type[] parameters)
		{
			return AccessTools.DeclaredIndexerSetter(type, parameters);
		}

		public static PropertyInfo Property(this Type type, string name)
		{
			return AccessTools.Property(type, name);
		}

		public static PropertyInfo Indexer(this Type type, Type[] parameters = null)
		{
			return AccessTools.Indexer(type, parameters);
		}

		public static MethodInfo PropertyGetter(this Type type, string name)
		{
			return AccessTools.PropertyGetter(type, name);
		}

		public static MethodInfo IndexerGetter(this Type type, Type[] parameters = null)
		{
			return AccessTools.IndexerGetter(type, parameters);
		}

		public static MethodInfo PropertySetter(this Type type, string name)
		{
			return AccessTools.PropertySetter(type, name);
		}

		public static MethodInfo IndexerSetter(this Type type, Type[] parameters = null)
		{
			return AccessTools.IndexerSetter(type, parameters);
		}

		public static MethodInfo DeclaredMethod(this Type type, string name, Type[] parameters = null, Type[] generics = null)
		{
			return AccessTools.DeclaredMethod(type, name, parameters, generics);
		}

		public static MethodInfo Method(this Type type, string name, Type[] parameters = null, Type[] generics = null)
		{
			return AccessTools.Method(type, name, parameters, generics);
		}

		public static List<string> GetMethodNames(this Type type)
		{
			return AccessTools.GetMethodNames(type);
		}

		public static List<string> GetFieldNames(this Type type)
		{
			return AccessTools.GetFieldNames(type);
		}

		public static List<string> GetPropertyNames(this Type type)
		{
			return AccessTools.GetPropertyNames(type);
		}

		public static ConstructorInfo DeclaredConstructor(this Type type, Type[] parameters = null, bool searchForStatic = false)
		{
			return AccessTools.DeclaredConstructor(type, parameters, searchForStatic);
		}

		public static ConstructorInfo Constructor(this Type type, Type[] parameters = null, bool searchForStatic = false)
		{
			return AccessTools.Constructor(type, parameters, searchForStatic);
		}

		public static List<ConstructorInfo> GetDeclaredConstructors(this Type type, bool? searchForStatic = null)
		{
			return AccessTools.GetDeclaredConstructors(type, searchForStatic);
		}

		public static List<MethodInfo> GetDeclaredMethods(this Type type)
		{
			return AccessTools.GetDeclaredMethods(type);
		}

		public static List<PropertyInfo> GetDeclaredProperties(this Type type)
		{
			return AccessTools.GetDeclaredProperties(type);
		}

		public static List<FieldInfo> GetDeclaredFields(this Type type)
		{
			return AccessTools.GetDeclaredFields(type);
		}

		public static Type Inner(this Type type, string name)
		{
			return AccessTools.Inner(type, name);
		}

		public static Type FirstInner(this Type type, Func<Type, bool> predicate)
		{
			return AccessTools.FirstInner(type, predicate);
		}

		public static MethodInfo FirstMethod(this Type type, Func<MethodInfo, bool> predicate)
		{
			return AccessTools.FirstMethod(type, predicate);
		}

		public static ConstructorInfo FirstConstructor(this Type type, Func<ConstructorInfo, bool> predicate)
		{
			return AccessTools.FirstConstructor(type, predicate);
		}

		public static PropertyInfo FirstProperty(this Type type, Func<PropertyInfo, bool> predicate)
		{
			return AccessTools.FirstProperty(type, predicate);
		}

		public static AccessTools.FieldRef<object, F> FieldRefAccess<F>(this Type type, string fieldName)
		{
			return AccessTools.FieldRefAccess<F>(type, fieldName);
		}

		public static ref F StaticFieldRefAccess<F>(this Type type, string fieldName)
		{
			return ref AccessTools.StaticFieldRefAccess<F>(type, fieldName);
		}

		public static void ThrowMissingMemberException(this Type type, params string[] names)
		{
			AccessTools.ThrowMissingMemberException(type, names);
		}

		public static object GetDefaultValue(this Type type)
		{
			return AccessTools.GetDefaultValue(type);
		}

		public static object CreateInstance(this Type type)
		{
			return AccessTools.CreateInstance(type);
		}

		public static bool IsStruct(this Type type)
		{
			return AccessTools.IsStruct(type);
		}

		public static bool IsClass(this Type type)
		{
			return AccessTools.IsClass(type);
		}

		public static bool IsValue(this Type type)
		{
			return AccessTools.IsValue(type);
		}

		public static bool IsInteger(this Type type)
		{
			return AccessTools.IsInteger(type);
		}

		public static bool IsFloatingPoint(this Type type)
		{
			return AccessTools.IsFloatingPoint(type);
		}

		public static bool IsNumber(this Type type)
		{
			return AccessTools.IsNumber(type);
		}

		public static bool IsVoid(this Type type)
		{
			return AccessTools.IsVoid(type);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool IsStatic(this Type type)
		{
			return AccessTools.IsStatic(type);
		}
	}
	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(OpCodes.Nop, operand, name);

			public Nop_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Break_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarg_0_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarg_1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarg_2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarg_3_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloc_0_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloc_1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloc_2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloc_3_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stloc_0_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stloc_1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stloc_2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stloc_3_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarg_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarga_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Starg_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloc_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloca_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stloc_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldnull_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_M1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_0_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_3_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_5_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_6_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_7_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_R4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldc_R8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Dup_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Pop_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Jmp_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Call_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Calli_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ret_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Br_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Brfalse_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Brtrue_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Beq_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bge_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bgt_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ble_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Blt_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bne_Un_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bge_Un_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bgt_Un_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ble_Un_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Blt_Un_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Br_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Brfalse_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Brtrue_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Beq_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bge_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bgt_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ble_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Blt_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bne_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bge_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Bgt_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ble_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Blt_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Switch_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_I1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_U1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_I2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_U2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_U4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_I_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_R4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_R8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldind_Ref_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_Ref_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_I1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_I2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_R4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_R8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Add_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Sub_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Mul_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Div_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Div_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Rem_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Rem_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public And_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Or_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Xor_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Shl_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Shr_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Shr_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Neg_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Not_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_I1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_I2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_R4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_R8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_U4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_U8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Callvirt_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Cpobj_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldobj_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldstr_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Newobj_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Castclass_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Isinst_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_R_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Unbox_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Throw_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldfld_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldflda_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stfld_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldsfld_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldsflda_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stsfld_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stobj_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_I1_Un, operand, name);

			public Conv_Ovf_I1_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_I2_Un, operand, name);

			public Conv_Ovf_I2_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_I4_Un, operand, name);

			public Conv_Ovf_I4_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_I8_Un, operand, name);

			public Conv_Ovf_I8_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_U1_Un, operand, name);

			public Conv_Ovf_U1_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_U2_Un, operand, name);

			public Conv_Ovf_U2_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_U4_Un, operand, name);

			public Conv_Ovf_U4_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_U8_Un, operand, name);

			public Conv_Ovf_U8_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_I_Un, operand, name);

			public Conv_Ovf_I_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		[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(OpCodes.Conv_Ovf_U_Un, operand, name);

			public Conv_Ovf_U_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Box_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Newarr_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldlen_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelema_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_I1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_U1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_I2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_U2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_U4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_I_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_R4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_R8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_Ref_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_I_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_I1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_I2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_R4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_R8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_Ref_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldelem_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stelem_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Unbox_Any_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_I1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_U1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_I2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_U2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_I4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_U4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_I8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_U8_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Refanyval_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ckfinite_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Mkrefany_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldtoken_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_U2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_U1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_I_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_I_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_Ovf_U_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Add_Ovf_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Add_Ovf_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Mul_Ovf_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Mul_Ovf_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Sub_Ovf_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Sub_Ovf_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Endfinally_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Leave_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Leave_S_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stind_I_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Conv_U_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix7_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix6_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix5_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix4_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix3_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix2_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefix1_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Prefixref_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Arglist_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ceq_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Cgt_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Cgt_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Clt_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Clt_Un_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldftn_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldvirtftn_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarg_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldarga_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Starg_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloc_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Ldloca_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Stloc_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Localloc_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Endfilter_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Unaligned_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Volatile_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Tailcall_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Initobj_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Constrained_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Cpblk_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Initblk_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Rethrow_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Sizeof_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Refanytype_(OpCode opcode)
				: base(opcode)
			{
			}
		}

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

			public Readonly_(OpCode opcode)
				: base(opcode)
			{
			}
		}

		public static Operand_ Operand => new Operand_();

		public static Nop_ Nop => new Nop_(OpCodes.Nop);

		public static Break_ Break => new Break_(OpCodes.Break);

		public static Ldarg_0_ Ldarg_0 => new Ldarg_0_(OpCodes.Ldarg_0);

		public static Ldarg_1_ Ldarg_1 => new Ldarg_1_(OpCodes.Ldarg_1);

		public static Ldarg_2_ Ldarg_2 => new Ldarg_2_(OpCodes.Ldarg_2);

		public static Ldarg_3_ Ldarg_3 => new Ldarg_3_(OpCodes.Ldarg_3);

		public static Ldloc_0_ Ldloc_0 => new Ldloc_0_(OpCodes.Ldloc_0);

		public static Ldloc_1_ Ldloc_1 => new Ldloc_1_(OpCodes.Ldloc_1);

		public static Ldloc_2_ Ldloc_2 => new Ldloc_2_(OpCodes.Ldloc_2);

		public static Ldloc_3_ Ldloc_3 => new Ldloc_3_(OpCodes.Ldloc_3);

		public static Stloc_0_ Stloc_0 => new Stloc_0_(OpCodes.Stloc_0);

		public static Stloc_1_ Stloc_1 => new Stloc_1_(OpCodes.Stloc_1);

		public static Stloc_2_ Stloc_2 => new Stloc_2_(OpCodes.Stloc_2);

		public static Stloc_3_ Stloc_3 => new Stloc_3_(OpCodes.Stloc_3);

		public static Ldarg_S_ Ldarg_S => new Ldarg_S_(OpCodes.Ldarg_S);

		public static Ldarga_S_ Ldarga_S => new Ldarga_S_(OpCodes.Ldarga_S);

		public static Starg_S_ Starg_S => new Starg_S_(OpCodes.Starg_S);

		public static Ldloc_S_ Ldloc_S => new Ldloc_S_(OpCodes.Ldloc_S);

		public static Ldloca_S_ Ldloca_S => new Ldloca_S_(OpCodes.Ldloca_S);

		public static Stloc_S_ Stloc_S => new Stloc_S_(OpCodes.Stloc_S);

		public static Ldnull_ Ldnull => new Ldnull_(OpCodes.Ldnull);

		public static Ldc_I4_M1_ Ldc_I4_M1 => new Ldc_I4_M1_(OpCodes.Ldc_I4_M1);

		public static Ldc_I4_0_ Ldc_I4_0 => new Ldc_I4_0_(OpCodes.Ldc_I4_0);

		public static Ldc_I4_1_ Ldc_I4_1 => new Ldc_I4_1_(OpCodes.Ldc_I4_1);

		public static Ldc_I4_2_ Ldc_I4_2 => new Ldc_I4_2_(OpCodes.Ldc_I4_2);

		public static Ldc_I4_3_ Ldc_I4_3 => new Ldc_I4_3_(OpCodes.Ldc_I4_3);

		public static Ldc_I4_4_ Ldc_I4_4 => new Ldc_I4_4_(OpCodes.Ldc_I4_4);

		public static Ldc_I4_5_ Ldc_I4_5 => new Ldc_I4_5_(OpCodes.Ldc_I4_5);

		public static Ldc_I4_6_ Ldc_I4_6 => new Ldc_I4_6_(OpCodes.Ldc_I4_6);

		public static Ldc_I4_7_ Ldc_I4_7 => new Ldc_I4_7_(OpCodes.Ldc_I4_7);

		public static Ldc_I4_8_ Ldc_I4_8 => new Ldc_I4_8_(OpCodes.Ldc_I4_8);

		public static Ldc_I4_S_ Ldc_I4_S => new Ldc_I4_S_(OpCodes.Ldc_I4_S);

		public static Ldc_I4_ Ldc_I4 => new Ldc_I4_(OpCodes.Ldc_I4);

		public static Ldc_I8_ Ldc_I8 => new Ldc_I8_(OpCodes.Ldc_I8);

		public static Ldc_R4_ Ldc_R4 => new Ldc_R4_(OpCodes.Ldc_R4);

		public static Ldc_R8_ Ldc_R8 => new Ldc_R8_(OpCodes.Ldc_R8);

		public static Dup_ Dup => new Dup_(OpCodes.Dup);

		public static Pop_ Pop => new Pop_(OpCodes.Pop);

		public static Jmp_ Jmp => new Jmp_(OpCodes.Jmp);

		public static Call_ Call => new Call_(OpCodes.Call);

		public static Calli_ Calli => new Calli_(OpCodes.Calli);

		public static Ret_ Ret => new Ret_(OpCodes.Ret);

		public static Br_S_ Br_S => new Br_S_(OpCodes.Br_S);

		public static Brfalse_S_ Brfalse_S => new Brfalse_S_(OpCodes.Brfalse_S);

		public static Brtrue_S_ Brtrue_S => new Brtrue_S_(OpCodes.Brtrue_S);

		public static Beq_S_ Beq_S => new Beq_S_(OpCodes.Beq_S);

		public static Bge_S_ Bge_S => new Bge_S_(OpCodes.Bge_S);

		public static Bgt_S_ Bgt_S => new Bgt_S_(OpCodes.Bgt_S);

		public static Ble_S_ Ble_S => new Ble_S_(OpCodes.Ble_S);

		public static Blt_S_ Blt_S => new Blt_S_(OpCodes.Blt_S);

		public static Bne_Un_S_ Bne_Un_S => new Bne_Un_S_(OpCodes.Bne_Un_S);

		public static Bge_Un_S_ Bge_Un_S => new Bge_Un_S_(OpCodes.Bge_Un_S);

		public static Bgt_Un_S_ Bgt_Un_S => new Bgt_Un_S_(OpCodes.Bgt_Un_S);

		public static Ble_Un_S_ Ble_Un_S => new Ble_Un_S_(OpCodes.Ble_Un_S);

		public static Blt_Un_S_ Blt_Un_S => new Blt_Un_S_(OpCodes.Blt_Un_S);

		public static Br_ Br => new Br_(OpCodes.Br);

		public static Brfalse_ Brfalse => new Brfalse_(OpCodes.Brfalse);

		public static Brtrue_ Brtrue => new Brtrue_(OpCodes.Brtrue);

		public static Beq_ Beq => new Beq_(OpCodes.Beq);

		public static Bge_ Bge => new Bge_(OpCodes.Bge);

		public static Bgt_ Bgt => new Bgt_(OpCodes.Bgt);

		public static Ble_ Ble => new Ble_(OpCodes.Ble);

		public static Blt_ Blt => new Blt_(OpCodes.Blt);

		public static Bne_Un_ Bne_Un => new Bne_Un_(OpCodes.Bne_Un);

		public static Bge_Un_ Bge_Un => new Bge_Un_(OpCodes.Bge_Un);

		public static Bgt_Un_ Bgt_Un => new Bgt_Un_(OpCodes.Bgt_Un);

		public static Ble_Un_ Ble_Un => new Ble_Un_(OpCodes.Ble_Un);

		public static Blt_Un_ Blt_Un => new Blt_Un_(OpCodes.Blt_Un);

		public static Switch_ Switch => new Switch_(OpCodes.Switch);

		public static Ldind_I1_ Ldind_I1 => new Ldind_I1_(OpCodes.Ldind_I1);

		public static Ldind_U1_ Ldind_U1 => new Ldind_U1_(OpCodes.Ldind_U1);

		public static Ldind_I2_ Ldind_I2 => new Ldind_I2_(OpCodes.Ldind_I2);

		public static Ldind_U2_ Ldind_U2 => new Ldind_U2_(OpCodes.Ldind_U2);

		public static Ldind_I4_ Ldind_I4 => new Ldind_I4_(OpCodes.Ldind_I4);

		public static Ldind_U4_ Ldind_U4 => new Ldind_U4_(OpCodes.Ldind_U4);

		public static Ldind_I8_ Ldind_I8 => new Ldind_I8_(OpCodes.Ldind_I8);

		public static Ldind_I_ Ldind_I => new Ldind_I_(OpCodes.Ldind_I);

		public static Ldind_R4_ Ldind_R4 => new Ldind_R4_(OpCodes.Ldind_R4);

		public static Ldind_R8_ Ldind_R8 => new Ldind_R8_(OpCodes.Ldind_R8);

		public static Ldind_Ref_ Ldind_Ref => new Ldind_Ref_(OpCodes.Ldind_Ref);

		public static Stind_Ref_ Stind_Ref => new Stind_Ref_(OpCodes.Stind_Ref);

		public static Stind_I1_ Stind_I1 => new Stind_I1_(OpCodes.Stind_I1);

		public static Stind_I2_ Stind_I2 => new Stind_I2_(OpCodes.Stind_I2);

		public static Stind_I4_ Stind_I4 => new Stind_I4_(OpCodes.Stind_I4);

		public static Stind_I8_ Stind_I8 => new Stind_I8_(OpCodes.Stind_I8);

		public static Stind_R4_ Stind_R4 => new Stind_R4_(OpCodes.Stind_R4);

		public static Stind_R8_ Stind_R8 => new Stind_R8_(OpCodes.Stind_R8);

		public static Add_ Add => new Add_(OpCodes.Add);

		public static Sub_ Sub => new Sub_(OpCodes.Sub);

		public static Mul_ Mul => new Mul_(OpCodes.Mul);

		public static Div_ Div => new Div_(OpCodes.Div);

		public static Div_Un_ Div_Un => new Div_Un_(OpCodes.Div_Un);

		public static Rem_ Rem => new Rem_(OpCodes.Rem);

		public static Rem_Un_ Rem_Un => new Rem_Un_(OpCodes.Rem_Un);

		public static And_ And => new And_(OpCodes.And);

		public static Or_ Or => new Or_(OpCodes.Or);

		public static Xor_ Xor => new Xor_(OpCodes.Xor);

		public static Shl_ Shl => new Shl_(OpCodes.Shl);

		public static Shr_ Shr => new Shr_(OpCodes.Shr);

		public static Shr_Un_ Shr_Un => new Shr_Un_(OpCodes.Shr_Un);

		public static Neg_ Neg => new Neg_(OpCodes.Neg);

		public static Not_ Not => new Not_(OpCodes.Not);

		public static Conv_I1_ Conv_I1 => new Conv_I1_(OpCodes.Conv_I1);

		public static Conv_I2_ Conv_I2 => new Conv_I2_(OpCodes.Conv_I2);

		public static Conv_I4_ Conv_I4 => new Conv_I4_(OpCodes.Conv_I4);

		public static Conv_I8_ Conv_I8 => new Conv_I8_(OpCodes.Conv_I8);

		public static Conv_R4_ Conv_R4 => new Conv_R4_(OpCodes.Conv_R4);

		public static Conv_R8_ Conv_R8 => new Conv_R8_(OpCodes.Conv_R8);

		public static Conv_U4_ Conv_U4 => new Conv_U4_(OpCodes.Conv_U4);

		public static Conv_U8_ Conv_U8 => new Conv_U8_(OpCodes.Conv_U8);

		public static Callvirt_ Callvirt => new Callvirt_(OpCodes.Callvirt);

		public static Cpobj_ Cpobj => new Cpobj_(OpCodes.Cpobj);

		public static Ldobj_ Ldobj => new Ldobj_(OpCodes.Ldobj);

		public static Ldstr_ Ldstr => new Ldstr_(OpCodes.Ldstr);

		public static Newobj_ Newobj => new Newobj_(OpCodes.Newobj);

		public static Castclass_ Castclass => new Castclass_(OpCodes.Castclass);

		public static Isinst_ Isinst => new Isinst_(OpCodes.Isinst);

		public static Conv_R_Un_ Conv_R_Un => new Conv_R_Un_(OpCodes.Conv_R_Un);

		public static Unbox_ Unbox => new Unbox_(OpCodes.Unbox);

		public static Throw_ Throw => new Throw_(OpCodes.Throw);

		public static Ldfld_ Ldfld => new Ldfld_(OpCodes.Ldfld);

		public static Ldflda_ Ldflda => new Ldflda_(OpCodes.Ldflda);

		public static Stfld_ Stfld => new Stfld_(OpCodes.Stfld);

		public static Ldsfld_ Ldsfld => new Ldsfld_(OpCodes.Ldsfld);

		public static Ldsflda_ Ldsflda => new Ldsflda_(OpCodes.Ldsflda);

		public static Stsfld_ Stsfld => new Stsfld_(OpCodes.Stsfld);

		public static Stobj_ Stobj => new Stobj_(OpCodes.Stobj);

		public static Conv_Ovf_I1_Un_ Conv_Ovf_I1_Un => new Conv_Ovf_I1_Un_(OpCodes.Conv_Ovf_I1_Un);

		public static Conv_Ovf_I2_Un_ Conv_Ovf_I2_Un => new Conv_Ovf_I2_Un_(OpCodes.Conv_Ovf_I2_Un);

		public static Conv_Ovf_I4_Un_ Conv_Ovf_I4_Un => new Conv_Ovf_I4_Un_(OpCodes.Conv_Ovf_I4_Un);

		public static Conv_Ovf_I8_Un_ Conv_Ovf_I8_Un => new Conv_Ovf_I8_Un_(OpCodes.Conv_Ovf_I8_Un);

		public static Conv_Ovf_U1_Un_ Conv_Ovf_U1_Un => new Conv_Ovf_U1_Un_(OpCodes.Conv_Ovf_U1_Un);

		public static Conv_Ovf_U2_Un_ Conv_Ovf_U2_Un => new Conv_Ovf_U2_Un_(OpCodes.Conv_Ovf_U2_Un);

		public static Conv_Ovf_U4_Un_ Conv_Ovf_U4_Un => new Conv_Ovf_U4_Un_(OpCodes.Conv_Ovf_U4_Un);

		public static Conv_Ovf_U8_Un_ Conv_Ovf_U8_Un => new Conv_Ovf_U8_Un_(OpCodes.Conv_Ovf_U8_Un);

		public static Conv_Ovf_I_Un_ Conv_Ovf_I_Un => new Conv_Ovf_I_Un_(OpCodes.Conv_Ovf_I_Un);

		public static Conv_Ovf_U_Un_ Conv_Ovf_U_Un => new Conv_Ovf_U_Un_(OpCodes.Conv_Ovf_U_Un);

		public static Box_ Box => new Box_(OpCodes.Box);

		public static Newarr_ Newarr => new Newarr_(OpCodes.Newarr);

		public static Ldlen_ Ldlen => new Ldlen_(OpCodes.Ldlen);

		public static Ldelema_ Ldelema => new Ldelema_(OpCodes.Ldelema);

		public static Ldelem_I1_ Ldelem_I1 => new Ldelem_I1_(OpCodes.Ldelem_I1);

		public static Ldelem_U1_ Ldelem_U1 => new Ldelem_U1_(OpCodes.Ldelem_U1);

		public static Ldelem_I2_ Ldelem_I2 => new Ldelem_I2_(OpCodes.Ldelem_I2);

		public static Ldelem_U2_ Ldelem_U2 => new Ldelem_U2_(OpCodes.Ldelem_U2);

		public static Ldelem_I4_ Ldelem_I4 => new Ldelem_I4_(OpCodes.Ldelem_I4);

		public static Ldelem_U4_ Ldelem_U4 => new Ldelem_U4_(OpCodes.Ldelem_U4);

		public static Ldelem_I8_ Ldelem_I8 => new Ldelem_I8_(OpCodes.Ldelem_I8);

		public static Ldelem_I_ Ldelem_I => new Ldelem_I_(OpCodes.Ldelem_I);

		public static Ldelem_R4_ Ldelem_R4 => new Ldelem_R4_(OpCodes.Ldelem_R4);

		public static Ldelem_R8_ Ldelem_R8 => new Ldelem_R8_(OpCodes.Ldelem_R8);

		public static Ldelem_Ref_ Ldelem_Ref => new Ldelem_Ref_(OpCodes.Ldelem_Ref);

		public static Stelem_I_ Stelem_I => new Stelem_I_(OpCodes.Stelem_I);

		public static Stelem_I1_ Stelem_I1 => new Stelem_I1_(OpCodes.Stelem_I1);

		public static Stelem_I2_ Stelem_I2 => new Stelem_I2_(OpCodes.Stelem_I2);

		public static Stelem_I4_ Stelem_I4 => new Stelem_I4_(OpCodes.Stelem_I4);

		public static Stelem_I8_ Stelem_I8 => new Stelem_I8_(OpCodes.Stelem_I8);

		public static Stelem_R4_ Stelem_R4 => new Stelem_R4_(OpCodes.Stelem_R4);

		public static Stelem_R8_ Stelem_R8 => new Stelem_R8_(OpCodes.Stelem_R8);

		public static Stelem_Ref_ Stelem_Ref => new Stelem_Ref_(OpCodes.Stelem_Ref);

		public static Ldelem_ Ldelem => new Ldelem_(OpCodes.Ldelem);

		public static Stelem_ Stelem => new Stelem_(OpCodes.Stelem);

		public static Unbox_Any_ Unbox_Any => new Unbox_Any_(OpCodes.Unbox_Any);

		public static Conv_Ovf_I1_ Conv_Ovf_I1 => new Conv_Ovf_I1_(OpCodes.Conv_Ovf_I1);

		public static Conv_Ovf_U1_ Conv_Ovf_U1 => new Conv_Ovf_U1_(OpCodes.Conv_Ovf_U1);

		public static Conv_Ovf_I2_ Conv_Ovf_I2 => new Conv_Ovf_I2_(OpCodes.Conv_Ovf_I2);

		public static Conv_Ovf_U2_ Conv_Ovf_U2 => new Conv_Ovf_U2_(OpCodes.Conv_Ovf_U2);

		public static Conv_Ovf_I4_ Conv_Ovf_I4 => new Conv_Ovf_I4_(OpCodes.Conv_Ovf_I4);

		public static Conv_Ovf_U4_ Conv_Ovf_U4 => new Conv_Ovf_U4_(OpCodes.Conv_Ovf_U4);

		public static Conv_Ovf_I8_ Conv_Ovf_I8 => new Conv_Ovf_I8_(OpCodes.Conv_Ovf_I8);

		public static Conv_Ovf_U8_ Conv_Ovf_U8 => new Conv_Ovf_U8_(OpCodes.Conv_Ovf_U8);

		public static Refanyval_ Refanyval => new Refanyval_(OpCodes.Refanyval);

		public static Ckfinite_ Ckfinite => new Ckfinite_(OpCodes.Ckfinite);

		public static Mkrefany_ Mkrefany => new Mkrefany_(OpCodes.Mkrefany);

		public static Ldtoken_ Ldtoken => new Ldtoken_(OpCodes.Ldtoken);

		public static Conv_U2_ Conv_U2 => new Conv_U2_(OpCodes.Conv_U2);

		public static Conv_U1_ Conv_U1 => new Conv_U1_(OpCodes.Conv_U1);

		public static Conv_I_ Conv_I => new Conv_I_(OpCodes.Conv_I);

		public static Conv_Ovf_I_ Conv_Ovf_I => new Conv_Ovf_I_(OpCodes.Conv_Ovf_I);

		public static Conv_Ovf_U_ Conv_Ovf_U => new Conv_Ovf_U_(OpCodes.Conv_Ovf_U);

		public static Add_Ovf_ Add_Ovf => new Add_Ovf_(OpCodes.Add_Ovf);

		public static Add_Ovf_Un_ Add_Ovf_Un => new Add_Ovf_Un_(OpCodes.Add_Ovf_Un);

		public static Mul_Ovf_ Mul_Ovf => new Mul_Ovf_(OpCodes.Mul_Ovf);

		public static Mul_Ovf_Un_ Mul_Ovf_Un => new Mul_Ovf_Un_(OpCodes.Mul_Ovf_Un);

		public static Sub_Ovf_ Sub_Ovf => new Sub_Ovf_(OpCodes.Sub_Ovf);

		public static Sub_Ovf_Un_ Sub_Ovf_Un => new Sub_Ovf_Un_(OpCodes.Sub_Ovf_Un);

		public static Endfinally_ Endfinally => new Endfinally_(OpCodes.Endfinally);

		public static Leave_ Leave => new Leave_(OpCodes.Leave);

		public static Leave_S_ Leave_S => new Leave_S_(OpCodes.Leave_S);

		public static Stind_I_ Stind_I => new Stind_I_(OpCodes.Stind_I);

		public static Conv_U_ Conv_U => new Conv_U_(OpCodes.Conv_U);

		public static Prefix7_ Prefix7 => new Prefix7_(OpCodes.Prefix7);

		public static Prefix6_ Prefix6 => new Prefix6_(OpCodes.Prefix6);

		public static Prefix5_ Prefix5 => new Prefix5_(OpCodes.Prefix5);

		public static Prefix4_ Prefix4 => new Prefix4_(OpCodes.Prefix4);

		public static Prefix3_ Prefix3 => new Prefix3_(OpCodes.Prefix3);

		public static Prefix2_ Prefix2 => new Prefix2_(OpCodes.Prefix2);

		public static Prefix1_ Prefix1 => new Prefix1_(OpCodes.Prefix1);

		public static Prefixref_ Prefixref => new Prefixref_(OpCodes.Prefixref);

		public static Arglist_ Arglist => new Arglist_(OpCodes.Arglist);

		public static Ceq_ Ceq => new Ceq_(OpCodes.Ceq);

		public static Cgt_ Cgt => new Cgt_(OpCodes.Cgt);

		public static Cgt_Un_ Cgt_Un => new Cgt_Un_(OpCodes.Cgt_Un);

		public static Clt_ Clt => new Clt_(OpCodes.Clt);

		public static Clt_Un_ Clt_Un => new Clt_Un_(OpCodes.Clt_Un);

		public static Ldftn_ Ldftn => new Ldftn_(OpCodes.Ldftn);

		public static Ldvirtftn_ Ldvirtftn => new Ldvirtftn_(OpCodes.Ldvirtftn);

		public static Ldarg_ Ldarg => new Ldarg_(OpCodes.Ldarg);

		public static Ldarga_ Ldarga => new Ldarga_(OpCodes.Ldarga);

		public static Starg_ Starg => new Starg_(OpCodes.Starg);

		public static Ldloc_ Ldloc => new Ldloc_(OpCodes.Ldloc);

		public static Ldloca_ Ldloca => new Ldloca_(OpCodes.Ldloca);

		public static Stloc_ Stloc => new Stloc_(OpCodes.Stloc);

		public static Localloc_ Localloc => new Localloc_(OpCodes.Localloc);

		public static Endfilter_ Endfilter => new Endfilter_(OpCodes.Endfilter);

		public static Unaligned_ Unaligned => new Unaligned_(OpCodes.Unaligned);

		public static Volatile_ Volatile => new Volatile_(OpCodes.Volatile);

		public static Tailcall_ Tailcall => new Tailcall_(OpCodes.Tailcall);

		public static Initobj_ Initobj => new Initobj_(OpCodes.Initobj);

		public static Constrained_ Constrained => new Constrained_(OpCodes.Constrained);

		public static Cpblk_ Cpblk => new Cpblk_(OpCodes.Cpblk);

		public static Initblk_ Initblk => new Initblk_(OpCodes.Initblk);

		public static Rethrow_ Rethrow => new Rethrow_(OpCodes.Rethrow);

		public static Sizeof_ Sizeof => new Sizeof_(OpCodes.Sizeof);

		public static Refanytype_ Refanytype => new Refanytype_(OpCodes.Refanytype);

		public static Readonly_ Readonly => new Readonly_(OpCodes.Readonly);
	}
	public class CodeMatch : CodeInstruction
	{
		public string name;

		public HashSet<OpCode> opcodeSet = new HashSet<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;

		[Obsolete("Use opcodeSet instead")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public List<OpCode> opcodes
		{
			get
			{
				return opcodeSet.ToList();
			}
			set
			{
				HashSet<OpCode> hashSet = new HashSet<OpCode>();
				foreach (OpCode item in value)
				{
					hashSet.Add(item);
				}
				opcodeSet = hashSet;
			}
		}

		internal CodeMatch Set(object operand, string name)
		{
			if (base.operand == null)
			{
				base.operand = operand;
			}
			if (operand != null)
			{
				operands.Add(operand);
			}
			if (this.name == null)
			{
				this.name = name;
			}
			return this;
		}

		internal CodeMatch Set(OpCode opcode, object operand, string name)
		{
			base.opcode = opcode;
			opcodeSet.Add(opcode);
			if (base.operand == null)
			{
				base.operand = operand;
			}
			if (operand != null)
			{
				operands.Add(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());
				opcodeSet.Add(item);
			}
			if (operand != null)
			{
				operands.Add(operand);
			}
			base.operand = operand;
			this.name = name;
		}

		public static CodeMatch WithOpcodes(HashSet<OpCode> opcodes, object operand = null, string name = null)
		{
			return new CodeMatch(null, operand, name)
			{
				opcodeSet = opcodes
			};
		}

		public CodeMatch(Expression<Action> expression, string name = null)
		{
			opcodeSet.UnionWith(CodeInstructionExtensions.opcodesCalling);
			operand = SymbolExtensions.GetMethodInfo(expression);
			if (operand != null)
			{
				operands.Add(operand);
			}
			this.name = name;
		}

		public CodeMatch(LambdaExpression expression, string name = null)
		{
			opcodeSet.UnionWith(CodeInstructionExtensions.opcodesCalling);
			operand = SymbolExtensions.GetMethodInfo(expression);
			if (operand != null)
			{
				operands.Add(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 (opcodeSet.Count > 0 && !opcodeSet.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 static CodeMatch IsLdarg(int? n = null)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.IsLdarg(n));
		}

		public static CodeMatch IsLdarga(int? n = null)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.IsLdarga(n));
		}

		public static CodeMatch IsStarg(int? n = null)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.IsStarg(n));
		}

		public static CodeMatch IsLdloc(LocalBuilder variable = null)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.IsLdloc(variable));
		}

		public static CodeMatch IsStloc(LocalBuilder variable = null)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.IsStloc(variable));
		}

		public static CodeMatch Calls(MethodInfo method)
		{
			return WithOpcodes(CodeInstructionExtensions.opcodesCalling, method);
		}

		public static CodeMatch LoadsConstant()
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.LoadsConstant());
		}

		public static CodeMatch LoadsConstant(long number)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.LoadsConstant(number));
		}

		public static CodeMatch LoadsConstant(double number)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.LoadsConstant(number));
		}

		public static CodeMatch LoadsConstant(Enum e)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.LoadsConstant(e));
		}

		public static CodeMatch LoadsConstant(string str)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.LoadsConstant(str));
		}

		public static CodeMatch LoadsField(FieldInfo field, bool byAddress = false)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.LoadsField(field, byAddress));
		}

		public static CodeMatch StoresField(FieldInfo field)
		{
			return new CodeMatch((CodeInstruction instruction) => instruction.StoresField(field));
		}

		public static CodeMatch Calls(Expression<Action> expression)
		{
			return new CodeMatch(expression);
		}

		public static CodeMatch Calls(LambdaExpression expression)
		{
			return new CodeMatch(expression);
		}

		public static CodeMatch LoadsLocal(bool useAddress = false, string name = null)
		{
			return WithOpcodes(useAddress ? CodeInstructionExtensions.opcodesLoadingLocalByAddress : CodeInstructionExtensions.opcodesLoadingLocalNormal, null, name);
		}

		public static CodeMatch StoresLocal(string name = null)
		{
			return WithOpcodes(CodeInstructionExtensions.opcodesStoringLocal, null, name);
		}

		public static CodeMatch LoadsArgument(bool useAddress = false, string name = null)
		{
			return WithOpcodes(useAddress ? CodeInstructionExtensions.opcodesLoadingArgumentByAddress : CodeInstructionExtensions.opcodesLoadingArgumentNormal, null, name);
		}

		public static CodeMatch StoresArgument(string name = null)
		{
			return WithOpcodes(CodeInstructionExtensions.opcodesStoringArgument, null, name);
		}

		public static CodeMatch Branches(string name = null)
		{
			return WithOpcodes(CodeInstructionExtensions.opcodesBranching, null, name);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (name != null)
			{
				stringBuilder.Append(name + ": ");
			}
			if (opcodeSet.Count > 0)
			{
				stringBuilder.Append("opcodes=" + opcodeSet.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 - PosOrThrow();

		public ref OpCode Opcode => ref codes[PosOrThrow()].opcode;

		public ref object Operand => ref codes[PosOrThrow()].operand;

		public ref List<Label> Labels => ref codes[PosOrThrow()].labels;

		public ref List<ExceptionBlock> Blocks => ref codes[PosOrThrow()].blocks;

		public CodeInstruction Instruction => codes[PosOrThrow()];

		private void FixStart()
		{
			Pos = Math.Max(0, Pos);
		}

		private void SetOutOfBounds(int direction)
		{
			Pos = ((direction > 0) ? Length : (-1));
		}

		private int PosOrThrow()
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Current position is out of bounds");
			}
			return Pos;
		}

		public CodeMatcher()
		{
		}

		public CodeMatcher(IEnumerable<CodeInstruction> instructions, ILGenerator generator = null)
		{
			if (instructions == null)
			{
				throw new ArgumentNullException("instructions");
			}
			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)
		{
			int num = PosOrThrow();
			int num2 = num + offset;
			if (num2 < 0 || num2 >= Length)
			{
				throw new ArgumentOutOfRangeException("offset", "offset causes position to go out of bounds");
			}
			return codes[num2];
		}

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

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

		public List<CodeInstruction> Instructions(int count)
		{
			if (Pos < 0 || Pos + count > Length)
			{
				throw new InvalidOperationException("Cannot retrieve instructions: range is out-of-bounds.");
			}
			return (from c in codes.GetRange(PosOrThrow(), count)
				select new CodeInstruction(c)).ToList();
		}

		public List<CodeInstruction> InstructionsInRange(int start, int end)
		{
			List<CodeInstruction> list = codes;
			if (start > end)
			{
				int num = start;
				start = end;
				end = num;
			}
			if (start < 0 || end >= Length)
			{
				throw new InvalidOperationException("Cannot retrieve instructions: range is out-of-bounds.");
			}
			list = list.GetRange(start, end - start + 1);
			return list.Select((CodeInstruction c) => new CodeInstruction(c)).ToList();
		}

		public List<CodeInstruction> InstructionsWithOffsets(int startOffset, int endOffset)
		{
			int num = PosOrThrow();
			int num2 = num + startOffset;
			if (num2 < 0 || num2 >= Length)
			{
				throw new ArgumentOutOfRangeException("startOffset", "startOffset causes position to go out of bounds");
			}
			int num3 = num + endOffset;
			if (num3 < 0 || num3 >= Length)
			{
				throw new ArgumentOutOfRangeException("endOffset", "endOffset causes position to go out of bounds");
			}
			return InstructionsInRange(num2, num3);
		}

		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 value = lastError ?? "Unexpected code";
			logger($"{value} 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, prepareOnly: 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)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot set instruction/opcode at invalid position.");
			}
			codes[PosOrThrow()] = instruction;
			return this;
		}

		public CodeMatcher SetInstructionAndAdvance(CodeInstruction instruction)
		{
			SetInstruction(instruction);
			Pos++;
			return this;
		}

		public CodeMatcher Set(OpCode opcode, object operand)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot set values at invalid position.");
			}
			Opcode = opcode;
			Operand = operand;
			return this;
		}

		public CodeMatcher SetAndAdvance(OpCode opcode, object operand)
		{
			Set(opcode, operand);
			Pos++;
			return this;
		}

		public CodeMatcher SetOpcodeAndAdvance(OpCode opcode)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot set values at invalid position.");
			}
			Opcode = opcode;
			Pos++;
			return this;
		}

		public CodeMatcher SetOperandAndAdvance(object operand)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot set values at invalid position.");
			}
			Operand = operand;
			Pos++;
			return this;
		}

		public CodeMatcher DeclareLocal(Type variableType, out LocalBuilder localVariable)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("Generator must be provided to use this method");
			}
			localVariable = generator.DeclareLocal(variableType);
			return this;
		}

		public CodeMatcher DefineLabel(out Label label)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("Generator must be provided to use this method");
			}
			label = generator.DefineLabel();
			return this;
		}

		public CodeMatcher CreateLabel(out Label label)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("Generator must be provided to use this method");
			}
			label = generator.DefineLabel();
			Labels.Add(label);
			return this;
		}

		public CodeMatcher CreateLabelAt(int position, out Label label)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("Generator must be provided to use this method");
			}
			label = generator.DefineLabel();
			AddLabelsAt(position, new Label[1] { label });
			return this;
		}

		public CodeMatcher CreateLabelWithOffsets(int offset, out Label label)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("Generator must be provided to use this method");
			}
			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)
		{
			if (position < 0 || position >= Length)
			{
				throw new ArgumentOutOfRangeException("position", "position is out of bounds");
			}
			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)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot insert instructions at invalid position.");
			}
			if (Pos == Length)
			{
				codes.AddRange(instructions);
			}
			else
			{
				codes.InsertRange(PosOrThrow(), instructions);
			}
			return this;
		}

		public CodeMatcher Insert(IEnumerable<CodeInstruction> instructions)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot insert instructions at invalid position.");
			}
			if (Pos == Length)
			{
				codes.AddRange(instructions);
			}
			else
			{
				codes.InsertRange(PosOrThrow(), instructions);
			}
			return this;
		}

		public CodeMatcher InsertBranch(OpCode opcode, int destination)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot insert instructions at invalid position.");
			}
			int index = PosOrThrow();
			CreateLabelAt(destination, out var label);
			codes.Insert(index, 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 InsertAfter(params CodeInstruction[] instructions)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot insert instructions at invalid position.");
			}
			codes.InsertRange(Pos + 1, instructions);
			return this;
		}

		public CodeMatcher InsertAfter(IEnumerable<CodeInstruction> instructions)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot insert instructions at invalid position.");
			}
			codes.InsertRange(Pos + 1, instructions);
			return this;
		}

		public CodeMatcher InsertBranchAfter(OpCode opcode, int destination)
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot insert instructions at invalid position.");
			}
			CreateLabelAt(destination, out var label);
			codes.Insert(Pos + 1, new CodeInstruction(opcode, label));
			return this;
		}

		public CodeMatcher InsertAfterAndAdvance(params CodeInstruction[] instructions)
		{
			InsertAfter(instructions);
			Pos += instructions.Length;
			return this;
		}

		public CodeMatcher InsertAfterAndAdvance(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = instructions.ToList();
			InsertAfter(list);
			Pos += list.Count;
			return this;
		}

		public CodeMatcher InsertBranchAfterAndAdvance(OpCode opcode, int destination)
		{
			InsertBranchAfter(opcode, destination);
			Pos++;
			return this;
		}

		public CodeMatcher RemoveInstruction()
		{
			if (IsInvalid)
			{
				throw new InvalidOperationException("Cannot remove instructions from an invalid position.");
			}
			codes.RemoveAt(PosOrThrow());
			return this;
		}

		public CodeMatcher RemoveInstructions(int count)
		{
			if (IsInvalid || Pos + count > Length)
			{
				throw new InvalidOperationException("Cannot remove instructions from an invalid or out-of-range position.");
			}
			codes.RemoveRange(PosOrThrow(), count);
			return this;
		}

		public CodeMatcher RemoveInstructionsInRange(int start, int end)
		{
			if (start < 0 || start >= Length)
			{
				throw new ArgumentOutOfRangeException("start", "start is out of bounds");
			}
			if (end < 0 || end >= Length)
			{
				throw new ArgumentOutOfRangeException("end", "end is out of bounds");
			}
			if (start > end)
			{
				int num = start;
				start = end;
				end = num;
			}
			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, prepareOnly: false);
		}

		public CodeMatcher MatchBack(bool useEnd, params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd, prepareOnly: false);
		}

		public CodeMatcher MatchStartForward(params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd: false, prepareOnly: false);
		}

		public CodeMatcher PrepareMatchStartForward(params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd: false, prepareOnly: true);
		}

		public CodeMatcher MatchEndForward(params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd: true, prepareOnly: false);
		}

		public CodeMatcher PrepareMatchEndForward(params CodeMatch[] matches)
		{
			return Match(matches, 1, useEnd: true, prepareOnly: true);
		}

		public CodeMatcher MatchStartBackwards(params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd: false, prepareOnly: false);
		}

		public CodeMatcher PrepareMatchStartBackwards(params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd: false, prepareOnly: true);
		}

		public CodeMatcher MatchEndBackwards(params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd: true, prepareOnly: false);
		}

		public CodeMatcher PrepareMatchEndBackwards(params CodeMatch[] matches)
		{
			return Match(matches, -1, useEnd: true, prepareOnly: true);
		}

		private CodeMatcher Match(CodeMatch[] matches, int direction, bool useEnd, bool prepareOnly)
		{
			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;
			};
			if (prepareOnly)
			{
				return this;
			}
			FixStart();
			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
	{
		internal static readonly HashSet<OpCode> opcodesCalling = new HashSet<OpCode>
		{
			OpCodes.Call,
			OpCodes.Callvirt
		};

		internal static readonly HashSet<OpCode> opcodesLoadingLocalByAddress = new HashSet<OpCode>
		{
			OpCodes.Ldloca_S,
			OpCodes.Ldloca
		};

		internal static readonly HashSet<OpCode> opcodesLoadingLocalNormal = new HashSet<OpCode>
		{
			OpCodes.Ldloc_0,
			OpCodes.Ldloc_1,
			OpCodes.Ldloc_2,
			OpCodes.Ldloc_3,
			OpCodes.Ldloc_S,
			OpCodes.Ldloc
		};

		internal static readonly HashSet<OpCode> opcodesStoringLocal = new HashSet<OpCode>
		{
			OpCodes.Stloc_0,
			OpCodes.Stloc_1,
			OpCodes.Stloc_2,
			OpCodes.Stloc_3,
			OpCodes.Stloc_S,
			OpCodes.Stloc
		};

		internal static readonly HashSet<OpCode> opcodesLoadingArgumentByAddress = new HashSet<OpCode>
		{
			OpCodes.Ldarga_S,
			OpCodes.Ldarga
		};

		internal static readonly HashSet<OpCode> opcodesLoadingArgumentNormal = new HashSet<OpCode>
		{
			OpCodes.Ldarg_0,
			OpCodes.Ldarg_1,
			OpCodes.Ldarg_2,
			OpCodes.Ldarg_3,
			OpCodes.Ldarg_S,
			OpCodes.Ldarg
		};

		internal static readonly HashSet<OpCode> opcodesStoringArgument = new HashSet<OpCode>
		{
			OpCodes.Starg_S,
			OpCodes.Starg
		};

		internal static readonly HashSet<OpCode> opcodesBranching = 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,
			OpCodes.Ldstr
		};

		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 (!opcodesLoadingLocalNormal.Contains(code.opcode) && !opcodesLoadingLocalByAddress.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 (!opcodesStoringLocal.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 (opcodesBranching.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;
			}
			double num = Convert.ToDouble(code.operand);
			return num == number;
		}

		public static bool LoadsConstant(this CodeInstruction code, Enum e)
		{
			return code.LoadsConstant(Convert.ToInt64(e));
		}

		public static bool LoadsConstant(this CodeInstruction code, string str)
		{
			if (code.opcode != OpCodes.Ldstr)
			{
				return false;
			}
			string text = Convert.ToString(code.operand);
			return text == str;
		}

		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 int LocalIndex(this CodeInstruction code)
		{
			if (code.opcode == OpCodes.Ldloc_0 || code.opcode == OpCodes.Stloc_0)
			{
				return 0;
			}
			if (code.opcode == OpCodes.Ldloc_1 || code.opcode == OpCodes.Stloc_1)
			{
				return 1;
			}
			if (code.opcode == OpCodes.Ldloc_2 || code.opcode == OpCodes.Stloc_2)
			{
				return 2;
			}
			if (code.opcode == OpCodes.Ldloc_3 || code.opcode == OpCodes.Stloc_3)
			{
				return 3;
			}
			if (code.opcode == OpCodes.Ldloc_S || code.opcode == OpCodes.Ldloc)
			{
				if (!(code.operand is LocalBuilder localBuilder))
				{
					return Convert.ToInt32(code.operand);
				}
				return localBuilder.LocalIndex;
			}
			if (code.opcode == OpCodes.Stloc_S || code.opcode == OpCodes.Stloc)
			{
				if (!(code.operand is LocalBuilder localBuilder2))
				{
					return Convert.ToInt32(code.operand);
				}
				return localBuilder2.LocalIndex;
			}
			if (code.opcode == OpCodes.Ldloca_S || code.opcode == OpCodes.Ldloca)
			{
				if (!(code.operand is LocalBuilder localBuilder3))
				{
					return Convert.ToInt32(code.operand);
				}
				return localBuilder3.LocalIndex;
			}
			throw new ArgumentException("Instruction is not a load or store", "code");
		}

		public static int ArgumentIndex(this CodeInstruction code)
		{
			if (code.opcode == OpCodes.Ldarg_0)
			{
				return 0;
			}
			if (code.opcode == OpCodes.Ldarg_1)
			{
				return 1;
			}
			if (code.opcode == OpCodes.Ldarg_2)
			{
				return 2;
			}
			if (code.opcode == OpCodes.Ldarg_3)
			{
				return 3;
			}
			if (code.opcode == OpCodes.Ldarg_S || code.opcode == OpCodes.Ldarg)
			{
				return Convert.ToInt32(code.operand);
			}
			if (code.opcode == OpCodes.Starg_S || code.opcode == OpCodes.Starg)
			{
				return Convert.ToInt32(code.operand);
			}
			if (code.opcode == OpCodes.Ldarga_S || code.opcode == OpCodes.Ldarga)
			{
				return Convert.ToInt32(code.operand);
			}
			throw new ArgumentException("Instruction is not a load or store", "code");
		}

		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 CodeInstructionsExtensions
	{
		public static bool Matches(this IEnumerable<CodeInstruction> instructions, CodeMatch[] matches)
		{
			return new CodeMatcher(instructions).MatchStartForward(matches).IsValid;
		}
	}
	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 ?? Array.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)
		{
			List<T> list = new List<T>();
			list.AddRange(sequence ?? Enumerable.Empty<T>());
			list.AddRange(items);
			return list.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;
			}
			foreach (IEnumerable<KeyValuePair<K, V>> enumerable in otherDicts)
			{
				foreach (KeyValuePair<K, V> item2 in enumerable)
				{
					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;
		}
	}
	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;
						string environmentVariable = Environment.GetEnvironmentVariable("HARMONY_NO_LOG");
						if (!string.IsNullOrEmpty(environmentVariable))
						{
							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");
						}
						else
						{
							_logPath += ".obsolete";
						}
					}
					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)
			{
				string path = $"{Environment.GetFolderPath(Environment.SpecialFolder.Desktop)}{Path.DirectorySeparatorChar}harmony.log.txt";
				File.Delete(path);
			}
		}

		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);
				MD5 mD = MD5.Create();
				byte[] array = mD.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)
		{
			if (!(expression.Body is MethodCallExpression methodCallExpression))
			{
				if (expression.Body is UnaryExpression { Operand: MethodCallExpression { Object: ConstantExpression { Value: MethodInfo value } } })
				{
					return value;
				}
				throw new ArgumentException("Invalid Expression. Expression should consist of a Method call only.");
			}
			MethodInfo method = methodCallExpression.Method;
			if ((object)method == null)
			{
				throw new Exception($"Cannot find method for expression {expression}");
			}
			return method;
		}
	}
	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;

		public bool IsField => _info is FieldInfo;

		public bool IsProperty => _info is PropertyInfo;

		public bool IsWriteable
		{
			get
			{
				if (_info is FieldInfo fieldInfo)
				{
					bool flag = fieldInfo.IsLiteral && !fieldInfo.IsInitOnly && fieldInfo.IsStatic;
					bool flag2 = !fieldInfo.IsLiteral && fieldInfo.IsInitOnly && fieldInfo.IsStatic;
					if (!flag)
					{
						return !flag2;
					}
					return false;
				}
				if (_info is PropertyInfo propertyInfo)
				{
					return propertyInfo.CanWrite;
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.Synchronized)]
		static Traverse()
		{
			CopyFields = delegate(Traverse from, Traverse to)
			{
				if (to.IsWriteable)
				{
					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 { IsStatic: not false })
				{
					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()
		{
			Traverse traverse = Resolve();
			return AccessTools.GetFieldNames(traverse._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()
		{
			Traverse traverse = Resolve();
			return AccessTools.GetPropertyNames(traverse._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()
		{
			Traverse traverse = Resolve();
			return AccessTools.GetMethodNames(traverse._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(new FileStream(Path.GetFullPath(FileWriterPath), FileMode.Create, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete));
				}
				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 ResultRefVar = "__resultRef";

		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;

		private Type _returnType;

		private Type ReturnType => _returnType ?? (_returnType = AccessTools.GetReturnedType(original));

		public HarmonyManipulator(PatchInfo patchInfo)
		{
			this.patchInfo = patchInfo;
			debug = patchInfo.Debugging;
			dumpPaths = patchInfo.DebugEmitPaths;
		}

		public static void Manipulate(MethodBase original, PatchInfo patchInfo, ILContext ctx)
		{
			HarmonyManipulator harmonyManipulator = new HarmonyManipulator(patchInfo);
			harmonyManipulator.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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: 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];
			Type returnType = ReturnType;
			VariableDefinition val;
			if (!variables.TryGetValue(ResultVar, out var value))
			{
				val = (variables[ResultVar] = ((returnType == typeof(void)) ? null : il.DeclareVariable(returnType)));
				value = val;
			}
			if (value != null && returnType.IsByRef)
			{
				il.Emit(OpCodes.Ldc_I4_1);
				il.Emit(OpCodes.Newarr, returnType.GetElementType());
				il.Emit(OpCodes.Ldc_I4_0);
				il.Emit(OpCodes.Ldelema, returnType.GetElementType());
				il.Emit(OpCodes.Stloc, value);
			}
			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)));
			val = (variables[RunOriginalParam] = il.DeclareVariable(typeof(bool)));
			VariableDefinition varDef = val;
			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 tmpInstanceBoxingVar, out var tmpObjectVar, out var resultRefInvoke, out var tmpBoxVars);
				il.Emit(OpCodes.Call, method);
				if (prefix.hasArgsArrayArg)
				{
					EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
				}
				EmitInstanceUnbox(tmpInstanceBoxingVar, original.DeclaringType);
				EmitResultRefInvoke(resultRefInvoke);
				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_0031: 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, ReturnType);
				il.Emit(OpCodes.Stloc, result);
			}
		}

		private void EmitResultRefInvoke(MethodInfo resultRefInvoke)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_009b: 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)
			if ((object)resultRefInvoke != null)
			{
				VariableDefinition varDef = variables[ResultRefVar];
				ILEmitter.Label label = il.DeclareLabel();
				il.Emit(OpCodes.Ldloc, varDef);
				il.Emit(OpCodes.Brfalse_S, label);
				il.Emit(OpCodes.Ldloc, varDef);
				il.Emit(OpCodes.Callvirt, resultRefInvoke);
				il.Emit(OpCodes.Stloc, variables[ResultVar]);
				il.Emit(OpCodes.Ldnull);
				il.Emit(OpCodes.Stloc, varDef);
				il.MarkLabel(label);
				il.Emit(OpCodes.Nop);
			}
		}

		private void EmitInstanceUnbox(VariableDefinition box, Type declaringType)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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)
			if (box != null)
			{
				il.Emit(OpCodes.Ldarg_0);
				il.Emit(OpCodes.Ldloc, box);
				il.Emit(OpCodes.Unbox_Any, declaringType);
				il.Emit(OpCodes.Stobj, declaringType);
			}
		}

		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_032c: 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;
				}
				(ILEmitter.Label, bool) tuple = MakeReturnLabel();
				ILEmitter.Label item = tuple.Item1;
				bool item2 = tuple.Item2;
				IEnumerable<PatchContext> enumerable = prefixes.Union(postfixes).Union(finalizers);
				foreach (PatchContext item3 in enumerable)
				{
					List<(ParameterInfo, string)> source = ParametersWithRealNames(item3.method);
					(ParameterInfo, string) tuple2 = source.FirstOrDefault<(ParameterInfo, string)>(((ParameterInfo param, string realName) p) => p.realName == ArgsArrayVar);
					if (tuple2.Item1 != null)
					{
						if (tuple2.Item1.ParameterType != typeof(object[]))
						{
							throw new InvalidHarmonyPatchArgumentException("Patch " + item3.method.FullDescription() + " defines __args list, but only type `object[]` is permitted", original, item3.method);
						}
						variables[ArgsArrayVar] = il.DeclareVariable(typeof(object[]));
					}
					if (item3.method.DeclaringType?.FullName == null || variables.ContainsKey(item3.method.DeclaringType.FullName))
					{
						continue;
					}
					foreach (var item4 in source.Where<(ParameterInfo, string)>(((ParameterInfo param, string realName) paramToRealName) => paramToRealName.realName == StateVar))
					{
						variables[item3.method.DeclaringType.FullName] = il.DeclareVariable(item4.Item1.ParameterType.OpenRefType());
					}
				}
				bool flag = WritePrefixes(item);
				WritePostfixes(item, item2 || flag);
				WriteFinalizers(item, item2);
				if (!item2 && !flag && postfixes.Count == 0 && finalizers.Count == 0)
				{
					ctx.Instrs.RemoveAt(ctx.Instrs.Count - 1);
				}
				il.MarkLabel(item);
				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(), item);
				StackTraceFixes.FixStackTrace(ctx);
				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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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_0103: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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)
			t = t.OpenRefType();
			il.Emit(OpCodes.Ldarg, arg);
			if (AccessTools.IsStruct(t))
			{
				il.Emit(OpCodes.Initobj, t);
			}
			else if (AccessTools.IsValue(t))
			{
				Type type = 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_0057: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			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++)
			{
				ParameterInfo parameterInfo2 = parameters[j];
				Type parameterType = parameterInfo2.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, bool originalHasReturn)
		{
			//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_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: 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 returnType = ReturnType;
				VariableDefinition val = (variables[ResultVar] = ((returnType == typeof(void)) ? null : il.DeclareVariable(returnType)));
				returnValueVar = val;
			}
			ILEmitter.ExceptionBlock block = il.BeginExceptionBlock(il.DeclareLabelFor(il.IL.Body.Instructions[0]));
			if (returnValueVar != null && originalHasReturn)
			{
				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 flag = WriteFinalizerCalls(suppressExceptions: true);
			il.MarkLabel(label2);
			label = il.DeclareLabel();
			il.Emit(OpCodes.Ldloc, variables[ExceptionVar]);
			il.Emit(OpCodes.Brfalse, label);
			if (flag)
			{
				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_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: 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 tmpInstanceBoxingVar, out var tmpObjectVar, out var resultRefInvoke, out var tmpBoxVars);
					il.Emit(OpCodes.Call, method);
					if (finalizer.hasArgsArrayArg)
					{
						EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
					}
					EmitInstanceUnbox(tmpInstanceBoxingVar, original.DeclaringType);
					EmitResultRefInvoke(resultRefInvoke);
					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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: 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_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: 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 returnType = ReturnType;
				VariableDefinition val = (variables[ResultVar] = ((returnType == typeof(void)) ? null : il.DeclareVariable(returnType)));
				value = val;
			}
			if (value != null && emitResultStore)
			{
				il.Emit(OpCodes.Stloc, value);
			}
			if (!variables.ContainsKey(RunOriginalParam))
			{
				VariableDefinition val = (variables[RunOriginalParam] = il.DeclareVariable(typeof(bool)));
				VariableDefinition varDef = val;
				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 tmpInstanceBoxingVar, out var tmpObjectVar, out var resultRefInvoke, out var tmpBoxVars);
				il.Emit(OpCodes.Call, method);
				if (item.hasArgsArrayArg)
				{
					EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
				}
				EmitInstanceUnbox(tmpInstanceBoxingVar, original.DeclaringType);
				EmitResultRefInvoke(resultRefInvoke);
				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 tmpInstanceBoxingVar2, out var tmpObjectVar2, out var resultRefInvoke2, out var tmpBoxVars2);
				il.Emit(OpCodes.Call, method2);
				if (item2.hasArgsArrayArg)
				{
					EmitAssignRefsFromArgsArray(variables[ArgsArrayVar]);
				}
				EmitInstanceUnbox(tmpInstanceBoxingVar2, original.DeclaringType);
				EmitResultRefInvoke(resultRefInvoke2);
				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[] patches;
			Patch[] patches2;
			Patch[] patches3;
			Patch[] patches4;
			Patch[] patches5;
			lock (patchInfo)
			{
				patches = patchInfo.prefixes.ToArray();
				patches2 = patchInfo.postfixes.ToArray();
				patches3 = patchInfo.transpilers.ToArray();
				patches4 = patchInfo.finalizers.ToArray();
				patches5 = patchInfo.ilmanipulators.ToArray();
			}
			prefixes = Sort(original, patches, debug);
			postfixes = Sort(original, patches2, debug);
			transpilers = Sort(original, patches3, debug);
			finalizers = Sort(original, patches4, debug);
			ilManipulators = Sort(original, patches5, debug);
			static List<PatchContext> Sort(MethodBase original, Patch[] patches6, bool debug)
			{
				return (from p in PatchFunctions.GetSortedPatchMethodsAsPatches(original, patches6, 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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];
				Type parameterType = parameterInfo.ParameterType;
				if (parameterType.IsByRef)
				{
					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);
					}
				}
				else
				{
					il.Emit(OpCodes.Ldloc, argsArrayVariable);
					il.Emit(OpCodes.Ldc_I4, i);
					il.Emit(OpCodes.Ldelem_Ref);
					il.Emit(parameterType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, parameterType);
					il.Emit(OpCodes.Starg, i + num);
				}
			}
		}

		private void EmitCallParameter(MethodInfo patch, bool allowFirsParamPassthrough, out VariableDefinition tmpInstanceBoxingVar, out VariableDefinition tmpObjectVar, out MethodInfo resultRefInvoke, out List<ArgumentBoxInfo> tmpBoxVars)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_084b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0844: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0850: Unknown result type (might be due to invalid IL or missing references)
			//IL_0858: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_099a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0988: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0655: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bdc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bfd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c0f: Unknown result type (might be due to invalid IL or missing references)
			tmpInstanceBoxingVar = null;
			tmpObjectVar = null;
			resultRefInvoke = null;
			tmpBoxVars = new List<ArgumentBoxInfo>();
			bool flag = !original.IsStatic;
			ParameterInfo[] parameters = original.GetParameters();
			string[] originalParameterNames = parameters.Select((ParameterInfo p) => p.Name).ToArray();
			List<(ParameterInfo, string)> list = ParametersWithRealNames(patch);
			Type declaringType = original.DeclaringType;
			if (allowFirsParamPassthrough && patch.ReturnType != typeof(void) && list.Count > 0 && list[0].Item1.ParameterType == patch.ReturnType)
			{
				list.RemoveRange(0, 1);
			}
			foreach (var item2 in list)
			{
				string item = item2.Item2;
				var (parameterInfo, _) = item2;
				if (item == OriginalMethodParam)
				{
					if (!EmitOriginalBaseMethod())
					{
						il.Emit(OpCodes.Ldnull);
					}
					continue;
				}
				if (item == InstanceParam)
				{
					if (original.IsStatic)
					{
						il.Emit(OpCodes.Ldnull);
						continue;
					}
					Type parameterType = parameterInfo.ParameterType;
					bool isByRef = parameterType.IsByRef;
					if ((object)declaringType == null || !AccessTools.IsStruct(declaringType))
					{
						if (isByRef)
						{
							il.Emit(OpCodes.Ldarga, 0);
						}
						else
						{
							il.Emit(OpCodes.Ldarg_0);
						}
					}
					else if (parameterType != typeof(object) && parameterType != typeof(object).MakeByRefType())
					{
						il.Emit(OpCodes.Ldarg_0);
						if (!isByRef)
						{
							il.Emit(OpCodes.Ldobj, declaringType);
						}
					}
					else if (isByRef)
					{
						il.Emit(OpCodes.Ldarg_0);
						il.Emit(OpCodes.Ldobj, declaringType);
						il.Emit(OpCodes.Box, declaringType);
						tmpInstanceBoxingVar = il.DeclareVariable(typeof(object));
						il.Emit(OpCodes.Stloc, tmpInstanceBoxingVar);
						il.Emit(OpCodes.Ldloca, tmpInstanceBoxingVar);
					}
					else
					{
						il.Emit(OpCodes.Ldarg_0);
						il.Emit(OpCodes.Ldobj, declaringType);
						il.Emit(OpCodes.Box, declaringType);
					}
					continue;
				}
				if (item == ArgsArrayVar)
				{
					if (variables.TryGetValue(ArgsArrayVar, out var value))
					{
						il.Emit(OpCodes.Ldloc, value);
					}
					else
					{
						il.Emit(OpCodes.Ldnull);
					}
					continue;
				}
				if (item.StartsWith(InstanceFieldPrefix, StringComparison.Ordinal))
				{
					string text = item.Substring(InstanceFieldPrefix.Length);
					FieldInfo fieldInfo;
					if (text.All(char.IsDigit))
					{
						fieldInfo = AccessTools.DeclaredField(declaringType, int.Parse(text));
						if ((object)fieldInfo == null)
						{
							throw new ArgumentException("No field found at given index in class " + declaringType.FullName, text);
						}
					}
					else
					{
						fieldInfo = AccessTools.Field(declaringType, text);
						if ((object)fieldInfo == null)
						{
							throw new ArgumentException("No such field defined in class " + declaringType.FullName, text);
						}
					}
					if (fieldInfo.IsStatic)
					{
						il.Emit(parameterInfo.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld, fieldInfo);
						continue;
					}
					il.Emit(OpCodes.Ldarg_0);
					il.Emit(parameterInfo.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld, fieldInfo);
					continue;
				}
				if (item == StateVar)
				{
					OpCode opcode = (parameterInfo.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 == ResultVar)
				{
					Type returnType = ReturnType;
					if (returnType == typeof(void))
					{
						throw new Exception("Cannot get result from void method " + original.FullDescription());
					}
					Type type = parameterInfo.ParameterType;
					if (type.IsByRef && !returnType.IsByRef)
					{
						type = type.GetElementType();
					}
					if (!type.IsAssignableFrom(returnType))
					{
						throw new Exception($"Cannot assign method return type {returnType.FullName} to {ResultVar} type {type.FullName} for method {original.FullDescription()}");
					}
					OpCode opcode2 = ((parameterInfo.ParameterType.IsByRef && !returnType.IsByRef) ? OpCodes.Ldloca : OpCodes.Ldloc);
					if (returnType.IsValueType && parameterInfo.ParameterType == typeof(object).MakeByRefType())
					{
						opcode2 = OpCodes.Ldloc;
					}
					il.Emit(opcode2, variables[ResultVar]);
					if (returnType.IsValueType)
					{
						if (parameterInfo.ParameterType == typeof(object))
						{
							il.Emit(OpCodes.Box, returnType);
						}
						else if (parameterInfo.ParameterType == typeof(object).MakeByRefType())
						{
							il.Emit(OpCodes.Box, returnType);
							tmpObjectVar = il.DeclareVariable(typeof(object));
							il.Emit(OpCodes.Stloc, tmpObjectVar);
							il.Emit(OpCodes.Ldloca, tmpObjectVar);
						}
					}
					continue;
				}
				if (item == ResultRefVar)
				{
					Type returnType2 = ReturnType;
					if (!returnType2.IsByRef)
					{
						throw new Exception($"Cannot use {ResultRefVar} with non-ref return type {returnType2.FullName} of method {original.FullDescription()}");
					}
					Type parameterType2 = parameterInfo.ParameterType;
					Type type2 = typeof(RefResult<>).MakeGenericType(returnType2.GetElementType());
					Type type3 = type2.MakeByRefType();
					if (parameterType2 != type3)
					{
						throw new Exception($"Wrong type of {ResultRefVar} for method {original.FullDescription()}. Expected {type3.FullName}, got {parameterType2.FullName}");
					}
					if (!variables.TryGetValue(ResultRefVar, out var value3))
					{
						VariableDefinition val = (variables[ResultRefVar] = il.DeclareVariable(type3));
						value3 = val;
					}
					il.Emit(OpCodes.Ldloca, value3);
					resultRefInvoke = AccessTools.Method(type2, "Invoke");
					continue;
				}
				if (variables.TryGetValue(item, out var value4))
				{
					OpCode opcode3 = (parameterInfo.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc);
					il.Emit(opcode3, value4);
					continue;
				}
				int result;
				if (item.StartsWith(ParamIndexPrefix, StringComparison.Ordinal))
				{
					string s = item.Substring(ParamIndexPrefix.Length);
					if (!int.TryParse(s, out result))
					{
						throw new Exception("Parameter " + item + " 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, parameterInfo);
					if (result == -1)
					{
						HarmonyMethod mergedFromType = HarmonyMethodExtensions.GetMergedFromType(parameterInfo.ParameterType);
						MethodType? methodType = mergedFromType.methodType;
						if (!methodType.HasValue)
						{
							mergedFromType.methodType = MethodType.Normal;
						}
						MethodBase originalMethod = mergedFromType.GetOriginalMethod();
						if (originalMethod is MethodInfo methodInfo)
						{
							ConstructorInfo constructor = parameterInfo.ParameterType.GetConstructor(new Type[2]
							{
								typeof(object),
								typeof(IntPtr)
							});
							if (constructor != null)
							{
								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 \"" + parameterInfo.Name + "\" not found in method " + original.FullDescription());
					}
				}
				Type parameterType3 = parameters[result].ParameterType;
				Type type4 = (parameterType3.IsByRef ? parameterType3.GetElementType() : parameterType3);
				Type parameterType4 = parameterInfo.ParameterType;
				Type type5 = (parameterType4.IsByRef ? parameterType4.GetElementType() : parameterType4);
				bool flag2 = !parameters[result].IsOut && !parameterType3.IsByRef;
				bool flag3 = !parameterInfo.IsOut && !parameterType4.IsByRef;
				bool flag4 = type4.IsValueType && !type5.IsValueType;
				int num = result + (flag ? 1 : 0);
				if (flag2 == flag3)
				{
					il.Emit(OpCodes.Ldarg, num);
					if (flag4)
					{
						if (flag3)
						{
							il.Emit(OpCodes.Box, type4);
							continue;
						}
						il.Emit(OpCodes.Ldobj, type4);
						il.Emit(OpCodes.Box, type4);
						VariableDefinition val3 = il.DeclareVariable(type5);
						il.Emit(OpCodes.Stloc, val3);
						il.Emit(OpCodes.Ldloca_S, val3);
						tmpBoxVars.Add(new ArgumentBoxInfo
						{
							index = num,
							type = type4,
							tmpVar = val3,
							isByRef = true
						});
					}
				}
				else if (flag2 && !flag3)
				{
					if (flag4)
					{
						il.Emit(OpCodes.Ldarg, num);
						il.Emit(OpCodes.Box, type4);
						VariableDefinition val4 = il.DeclareVariable(type5);
						il.Emit(OpCodes.Stloc, val4);
						il.Emit(OpCodes.Ldloca_S, val4);
						tmpBoxVars.Add(new ArgumentBoxInfo
						{
							index = num,
							type = type4,
							tmpVar = val4,
							isByRef = false
						});
					}
					else
					{
						il.Emit(OpCodes.Ldarga, num);
					}
				}
				else
				{
					il.Emit(OpCodes.Ldarg, num);
					if (flag4)
					{
						il.Emit(OpCodes.Ldobj, type4);
						il.Emit(OpCodes.Box, type4);
					}
					else if (type4.IsValueType)
					{
						il.Emit(OpCodes.Ldobj, type4);
					}
					else
					{
						il.Emit(parameters[result].ParameterType.GetCecilLoadOpCode());
					}
				}
			}
		}

		private static List<(ParameterInfo param, string realName)> ParametersWithRealNames(MethodInfo method)
		{
			IEnumerable<HarmonyArgument> baseArgs = method.GetArgumentAttributes();
			if ((object)method.DeclaringType != null)
			{
				baseArgs = baseArgs.Union(method.DeclaringType.GetArgumentAttributes());
			}
			return method.GetParameters().Select(delegate(ParameterInfo p)
			{
				HarmonyArgument argumentAttribute = p.GetArgumentAttribute();
				return (argumentAttribute != null) ? (p: p, argumentAttribute.OriginalName ?? p.Name) : (p: p, baseArgs.GetRealName(p.Name, null) ?? p.Name);
			}).ToList();
		}
	}
	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_0021: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (ilHook == null)
			{
				ilHook = new ILHook(base.Original, new Manipulator(Manipulator), false);
			}
			try
			{
				ilHook.Undo();
				ilHook.Apply();
			}
			catch (Exception ex)
			{
				throw HarmonyException.Create(ex, hookBody);
			}
			return ilHook.GetEndOfChain();
		}

		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 ConstructorInfo InvalidOperationExceptionCtor = typeof(InvalidOperationException).GetConstructor(new Type[1] { typeof(string) });

		private SimpleNativeDetour _detourOriginal;

		private SimpleNativeDetour _detourAltEntry;

		private IntPtr? _originalEntry;

		private MethodBase _replacement;

		private IDisposable _originalPin;

		private IDisposable _realReplacementPin;

		private IDisposable _altHandle;

		private readonly MethodSignature _signature;

		private readonly MethodInfo _altEntryMethod;

		private readonly IDisposable _altEntryPin;

		public NativeDetourMethodPatcher(MethodBase original)
			: base(original)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			_signature = new MethodSignature(base.Original);
			_altEntryMethod = GenerateAltEntryProxyStub(base.Original, _signature);
			_altEntryPin = PlatformTriple.Current.PinMethodIfNeeded((MethodBase)_altEntryMethod);
			PlatformTriple.Current.Compile((MethodBase)_altEntryMethod);
		}

		private static MethodInfo GenerateAltEntryProxyStub(MethodBase original, MethodSignature signature)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			DynamicMethodDefinition val = signature.CreateDmd($"NativeDetourAltEntry<{original.DeclaringType?.FullName}:{original.Name}>");
			try
			{
				ILContext val2 = new ILContext(val.Definition);
				ILCursor val3 = new ILCursor(val2);
				val3.EmitLdstr(((MemberReference)val.Definition).Name + " should've been detoured!");
				val3.EmitNewobj((MethodBase)InvalidOperationExceptionCtor);
				val3.EmitThrow();
				return val.Generate();
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		public override DynamicMethodDefinition PrepareOriginal()
		{
			return GenerateAltEntryProxyCaller($"NativeDetourProxy<{base.Original.DeclaringType?.FullName}:{base.Original.Name}>");
		}

		public override MethodBase DetourTo(MethodBase replacement)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			PlatformTriple current = PlatformTriple.Current;
			replacement = current.GetIdentifiable(replacement);
			if (replacement == _replacement)
			{
				return replacement;
			}
			lock (_altEntryMethod)
			{
				if (replacement == _replacement)
				{
					return replacement;
				}
				_replacement = replacement;
				MethodBase realDetourTarget = current.GetRealDetourTarget(base.Original, replacement);
				_realReplacementPin?.Dispose();
				_realReplacementPin = current.PinMethodIfNeeded(realDetourTarget);
				IntPtr functionPointer = current.Runtime.GetMethodHandle(realDetourTarget).GetFunctionPointer();
				SimpleNativeDetour detourOriginal = _detourOriginal;
				if (detourOriginal != null)
				{
					detourOriginal.Dispose();
				}
				_altHandle?.Dispose();
				if (_originalPin == null)
				{
					_originalPin = current.PinMethodIfNeeded(base.Original);
				}
				IntPtr intPtr = _originalEntry.GetValueOrDefault();
				IntPtr intPtr2;
				if (!_originalEntry.HasValue)
				{
					intPtr = current.GetNativeMethodBody(base.Original);
					_originalEntry = intPtr;
					intPtr2 = intPtr;
				}
				else
				{
					intPtr2 = intPtr;
				}
				IntPtr intPtr3 = intPtr2;
				NativeDetour val = current.CreateNativeDetour(intPtr3, functionPointer, -1, (IntPtr)0);
				SimpleNativeDetour detourOriginal2 = default(SimpleNativeDetour);
				IDisposable altHandle = default(IDisposable);
				((NativeDetour)(ref val)).Deconstruct(ref detourOriginal2, ref intPtr, ref altHandle);
				_detourOriginal = detourOriginal2;
				IntPtr intPtr4 = intPtr;
				_altHandle = altHandle;
				SimpleNativeDetour detourAltEntry = _detourAltEntry;
				if (detourAltEntry != null)
				{
					detourAltEntry.ChangeTarget(intPtr4);
				}
				else
				{
					_detourAltEntry = current.CreateSimpleDetour(current.GetNativeMethodBody((MethodBase)_altEntryMethod), intPtr4, -1, (IntPtr)0);
				}
				PatchManager.AddReplacementOriginal(base.Original, replacement);
				return replacement;
			}
		}

		public override DynamicMethodDefinition CopyOriginal()
		{
			return GenerateAltEntryProxyCaller($"OrigWrapper<{base.Original.DeclaringType?.FullName}:{base.Original.Name}>");
		}

		private DynamicMethodDefinition GenerateAltEntryProxyCaller(string name)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			DynamicMethodDefinition val = _signature.CreateDmd(name);
			ILContext val2 = new ILContext(val.Definition);
			ILCursor val3 = new ILCursor(val2);
			for (int i = 0; i < _signature.ParameterCount; i++)
			{
				val3.EmitLdarg(i);
			}
			val3.EmitCall((MethodBase)_altEntryMethod);
			val3.EmitRet();
			return val;
		}

		public static void TryResolve(object sender, PatchManager.PatcherResolverEventArgs args)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			FeatureFlags supportedFeatures = PlatformTriple.Current.SupportedFeatures;
			if (((FeatureFlags)(ref supportedFeatures)).Has((ArchitectureFeature)4) && 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 ConditionalWeakTable<MethodBase, MethodBase> ReplacementToOriginals;

		private static readonly Dictionary<long, MethodBase[]> ReplacementToOriginalsMono;

		private static readonly AccessTools.FieldRef<StackFrame, long> MethodAddressRef;

		public static event EventHandler<PatcherResolverEventArgs> ResolvePatcher;

		static PatchManager()
		{
			PatchInfos = new Dictionary<MethodBase, PatchInfo>();
			MethodPatchers = new Dictionary<MethodBase, MethodPatcher>();
			ReplacementToOriginals = new ConditionalWeakTable<MethodBase, MethodBase>();
			ReplacementToOriginalsMono = new Dictionary<long, MethodBase[]>();
			if (AccessTools.IsMonoRuntime)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(StackFrame), "methodAddress");
				if ((object)fieldInfo != null)
				{
					MethodAddressRef = AccessTools.FieldRefAccess<StackFrame, long>(fieldInfo);
				}
			}
			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 e = new PatcherResolverEventArgs
				{
					Original = methodBase
				};
				PatchManager.ResolvePatcher?.Invoke(null, e);
				if (e.MethodPatcher == null)
				{
					throw new NullReferenceException("No suitable patcher found for " + methodBase.FullDescription());
				}
				return MethodPatchers[methodBase] = e.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.ToArray();
			}
		}

		internal static MethodBase GetRealMethod(MethodInfo method, bool useReplacement)
		{
			MethodInfo key = method.Identifiable();
			lock (ReplacementToOriginals)
			{
				if (ReplacementToOriginals.TryGetValue(key, out var value))
				{
					return value;
				}
			}
			if (AccessTools.IsMonoRuntime)
			{
				long key2 = (long)method.MethodHandle.GetFunctionPointer();
				lock (ReplacementToOriginalsMono)
				{
					if (ReplacementToOriginalsMono.TryGetValue(key2, out var value2))
					{
						return useReplacement ? value2[1] : value2[0];
					}
				}
			}
			return method;
		}

		internal static MethodBase GetStackFrameMethod(StackFrame frame, bool useReplacement)
		{
			if (frame.GetMethod() is MethodInfo method)
			{
				return GetRealMethod(method, useReplacement);
			}
			if (MethodAddressRef != null)
			{
				long key = MethodAddressRef(frame);
				lock (ReplacementToOriginalsMono)
				{
					if (ReplacementToOriginalsMono.TryGetValue(key, out var value))
					{
						return useReplacement ? value[1] : value[0];
					}
				}
			}
			return null;
		}

		internal static void AddReplacementOriginal(MethodBase original, MethodBase replacement)
		{
			replacement = (replacement as MethodInfo)?.Identifiable() ?? replacement;
			if (replacement == null)
			{
				return;
			}
			lock (ReplacementToOriginals)
			{
				if (!ConditionalWeakTableExtensions.TryAdd<MethodBase, MethodBase>(ReplacementToOriginals, replacement, original))
				{
					ReplacementToOriginals.Remove(replacement);
					ReplacementToOriginals.Add(replacement, original);
				}
			}
			if (!AccessTools.IsMonoRuntime)
			{
				return;
			}
			long key = (long)replacement.MethodHandle.GetFunctionPointer();
			lock (ReplacementToOriginalsMono)
			{
				ReplacementToOriginalsMono[key] = new MethodBase[2] { original, replacement };
			}
		}

		public static void ClearAllPatcherResolvers()
		{
			PatchManager.ResolvePatcher = null;
		}
	}
}
namespace HarmonyLib.Internal.RuntimeFixes
{
	internal static class StackTraceFixes
	{
		private static bool _applied;

		private static readonly MethodInfo GetExecutingAssembly_MethodInfo = SymbolExtensions.GetMethodInfo(() => Assembly.GetExecutingAssembly());

		private static readonly MethodInfo GetExecutingAssemblyReplacement_MethodInfo = SymbolExtensions.GetMethodInfo(() => GetExecutingAssemblyReplacement());

		private static readonly MethodInfo GetMethod_MethodInfo = AccessTools.DeclaredMethod(typeof(StackFrame), "GetMethod", Type.EmptyTypes);

		private static readonly MethodInfo GetMethodReplacement_MethodInfo = SymbolExtensions.GetMethodInfo(() => GetMethodReplacement(null));

		public static void Install()
		{
			if (!_applied)
			{
				DetourManager.ILHookApplied += OnILChainRefresh;
				DetourManager.ILHookUndone += OnILChainRefresh;
				_applied = true;
			}
		}

		private static void OnILChainRefresh(ILHookInfo self)
		{
			PatchManager.AddReplacementOriginal(((DetourBase)self).Method.Method, ((DetourBase)self).Method.GetEndOfChain());
		}

		private static Assembly GetExecutingAssemblyReplacement()
		{
			StackFrame stackFrame = new StackTrace().GetFrames()?.Skip(1).FirstOrDefault();
			if (stackFrame != null)
			{
				MethodBase methodFromStackframe = Harmony.GetMethodFromStackframe(stackFrame);
				if ((object)methodFromStackframe != null)
				{
					return methodFromStackframe.Module.Assembly;
				}
			}
			return Assembly.GetExecutingAssembly();
		}

		private static MethodBase GetMethodReplacement(StackFrame self)
		{
			return Harmony.GetMethodFromStackframe(self) ?? self.GetMethod();
		}

		internal static void FixStackTrace(ILContext il)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			MethodReference val = null;
			MethodReference val2 = null;
			ILCursor val3 = new ILCursor(il);
			Enumerator<Instruction> enumerator = val3.Instrs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					if (ILPatternMatchingExt.MatchCall(current, (MethodBase)GetExecutingAssembly_MethodInfo))
					{
						if (val == null)
						{
							val = il.Import((MethodBase)GetExecutingAssemblyReplacement_MethodInfo);
						}
						current.Operand = val;
					}
					else if (ILPatternMatchingExt.MatchCallvirt(current, (MethodBase)GetMethod_MethodInfo))
					{
						if (val2 == null)
						{
							val2 = il.Import((MethodBase)GetMethodReplacement_MethodInfo);
						}
						current.OpCode = OpCodes.Call;
						current.Operand = val2;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
		}
	}
}
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)
		{
			ModuleDefinition val = DumpImpl(md, original);
			try
			{
				foreach (string dumpPath in dumpPaths)
				{
					string fullPath = Path.GetFullPath(dumpPath);
					try
					{
						Directory.CreateDirectory(fullPath);
						using FileStream fileStream = File.OpenWrite(Path.Combine(fullPath, ((ModuleReference)val).Name + ".dll"));
						val.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
			{
				((IDisposable)val)?.Dispose();
			}
		}

		internal static ModuleDefinition DumpImpl(MethodDefinition md, MethodBase original = null)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0169: 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_0186: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Expected O, but got Unknown
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Expected O, but got Unknown
			if (md.Body == null)
			{
				throw new ArgumentException("Body of MethodDefinition '" + ((MemberReference)md).Name + "' to dump is null");
			}
			string text = $"HarmonyDump.{SanitizeTypeName(Extensions.GetID((MethodReference)(object)md, (string)null, (string)null, false, true))}.{Guid.NewGuid().GetHashCode():X8}";
			string text2 = (original?.Name ?? ((MemberReference)md).Name).Replace('.', '_');
			ModuleDefinition module = ModuleDefinition.CreateModule(text, new ModuleParameters
			{
				Kind = (ModuleKind)0,
				ReflectionImporterProvider = MMReflectionImporter.ProviderNoDefault
			});
			module.Assembly.CustomAttributes.Add(new CustomAttribute(module.ImportReference((MethodBase)UnverifiableCodeAttributeConstructor)));
			int hashCode = Guid.NewGuid().GetHashCode();
			TypeDefinition val = new TypeDefinition("", $"HarmonyDump<{text2}>?{hashCode}", (TypeAttributes)385)
			{
				BaseType = module.TypeSystem.Object
			};
			module.Types.Add(val);
			MethodDefinition 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,
				NoInlining = true
			};
			val.Methods.Add(clone);
			Relinker val2 = (Relinker)delegate(IMetadataTokenProvider mtp, IGenericParameterProvider? _)
			{
				if ((object)mtp == md)
				{
					return (IMetadataTokenProvider)(object)clone;
				}
				MethodReference val10 = (MethodReference)(object)((mtp is MethodReference) ? mtp : null);
				return (IMetadataTokenProvider)((val10 != null && ((MemberReference)val10).FullName == ((MemberReference)md).FullName && ((MemberReference)((MemberReference)val10).DeclaringType).FullName == ((MemberReference)md.DeclaringType).FullName && ((MemberReference)val10).DeclaringType.Scope.Name == ((TypeReference)md.DeclaringType).Scope.Name) ? ((object)clone) : ((object)Extensions.ImportReference(module, mtp)));
			};
			Enumerator<ParameterDefinition> enumerator = ((MethodReference)md).Parameters.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ParameterDefinition current = enumerator.Current;
					((MethodReference)clone).Parameters.Add(Extensions.Relink(Extensions.Clone(current), val2, (IGenericParameterProvider)(object)clone));
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			((MethodReference)clone).ReturnType = Extensions.Relink(((MethodReference)md).ReturnType, val2, (IGenericParameterProvider)(object)clone);
			MethodBody val3 = (clone.Body = Extensions.Clone(md.Body, clone));
			MethodBody val5 = val3;
			Enumerator<VariableDefinition> enumerator2 = val5.Variables.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					VariableDefinition current2 = enumerator2.Current;
					((VariableReference)current2).VariableType = Extensions.Relink(((VariableReference)current2).VariableType, val2, (IGenericParameterProvider)(object)clone);
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
			foreach (ExceptionHandler item in ((IEnumerable<ExceptionHandler>)val5.ExceptionHandlers).Where((ExceptionHandler handler) => handler.CatchType != null))
			{
				item.CatchType = Extensions.Relink(item.CatchType, val2, (IGenericParameterProvider)(object)clone);
			}
			Enumerator<Instruction> enumerator4 = val5.Instructions.GetEnumerator();
			try
			{
				while (enumerator4.MoveNext())
				{
					Instruction current4 = enumerator4.Current;
					object operand = current4.Operand;
					ParameterDefinition val6 = (ParameterDefinition)((operand is ParameterDefinition) ? operand : null);
					object obj;
					if (val6 == null)
					{
						ILLabel val7 = (ILLabel)((operand is ILLabel) ? operand : null);
						if (val7 == null)
						{
							IMetadataTokenProvider val8 = (IMetadataTokenProvider)((operand is IMetadataTokenProvider) ? operand : null);
							obj = ((val8 == null) ? operand : Extensions.Relink(val8, val2, (IGenericParameterProvider)(object)clone));
						}
						else
						{
							obj = LabelFix(val7, val5.Instructions, md.Body.Instructions, text2);
						}
					}
					else
					{
						obj = ((MethodReference)clone).Parameters[((ParameterReference)val6).Index];
					}
					operand = obj;
					current4.Operand = operand;
				}
			}
			finally
			{
				((IDisposable)enumerator4/*cast due to .constrained prefix*/).Dispose();
			}
			if (((MethodReference)md).HasThis)
			{
				TypeReference val9 = (TypeReference)(object)md.DeclaringType;
				if (val9.IsValueType)
				{
					val9 = (TypeReference)new ByReferenceType(val9);
				}
				((MethodReference)clone).Parameters.Insert(0, new ParameterDefinition("<>_this", (ParameterAttributes)0, Extensions.Relink(val9, val2, (IGenericParameterProvider)(object)clone)));
			}
			return module;
		}

		private static string SanitizeTypeName(string typeName)
		{
			return typeName.Replace(":", "_").Replace(" ", "_").Replace("<", "{")
				.Replace(">", "}");
		}

		private static Instruction LabelFix(ILLabel label, Collection<Instruction> clone, Collection<Instruction> original, string originalName)
		{
			Instruction target = label.Target;
			int num = original.IndexOf(target);
			if (num == -1)
			{
				throw new IndexOutOfRangeException($"ILLabel from dump copy of '{originalName}' cannot be relinked. It points to '{target}', which was not found in the original body");
			}
			return clone[num];
		}
	}
	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 Type t_LocalBuilder;

		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_0013: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: 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_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			storeOpCodes = new Dictionary<Type, OpCode>
			{
				[typeof(bool)] = OpCodes.Stind_I1,
				[typeof(sbyte)] = OpCodes.Stind_I1,
				[typeof(byte)] = OpCodes.Stind_I1,
				[typeof(char)] = OpCodes.Stind_I2,
				[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,
				[typeof(IntPtr)] = OpCodes.Stind_I,
				[typeof(UIntPtr)] = OpCodes.Stind_I,
				[typeof(IntPtr)] = OpCodes.Stind_I,
				[typeof(UIntPtr)] = OpCodes.Stind_I
			};
			loadOpCodes = new Dictionary<Type, OpCode>
			{
				[typeof(bool)] = OpCodes.Ldind_I1,
				[typeof(sbyte)] = OpCodes.Ldind_I1,
				[typeof(byte)] = OpCodes.Ldind_I1,
				[typeof(char)] = OpCodes.Ldind_I2,
				[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,
				[typeof(IntPtr)] = OpCodes.Ldind_I,
				[typeof(UIntPtr)] = OpCodes.Ldind_I,
				[typeof(IntPtr)] = OpCodes.Ldind_I,
				[typeof(UIntPtr)] = OpCodes.Ldind_I
			};
			t_LocalBuilder = Type.GetType("System.Reflection.Emit.RuntimeLocalBuilder") ?? typeof(LocalBuilder);
			c_LocalBuilder = (from c in t_LocalBuilder.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				orderby c.GetParameters().Length descending
				select c).First();
			f_LocalBuilder_position = t_LocalBuilder.GetField("position", BindingFlags.Instance | BindingFlags.NonPublic);
			f_LocalBuilder_is_pinned = t_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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Type type = t;
			if (t.IsEnum)
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (!storeOpCodes.TryGetValue(type, out var value))
			{
				return OpCodes.Stind_Ref;
			}
			return value;
		}

		public static OpCode GetCecilLoadOpCode(this Type t)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Type type = t;
			if (t.IsEnum)
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (!loadOpCodes.TryGetValue(type, 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 static class MethodBodyLogExtensions
	{
		public static string ToILDasmString(this MethodBody mb)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected I4, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			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/*cast due to .constrained prefix*/).Dispose();
			}
			int indent = 0;
			WriteLine(".locals init (");
			indent += 4;
			for (int num = 0; num < mb.Variables.Count; num++)
			{
				VariableDefinition val3 = mb.Variables[num];
				WriteLine($"{((MemberReference)((VariableReference)val3).VariableType).FullName} V_{num}");
			}
			indent -= 4;
			WriteLine(")");
			Stack<string> stack = new Stack<string>();
			Enumerator<Instruction> enumerator3 = instructions.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					Instruction current3 = enumerator3.Current;
					List<ExceptionBlock> list = exBlocks.GetValueSafe(current3) ?? new List<ExceptionBlock>();
					list.Sort((ExceptionBlock a, ExceptionBlock b) => (a.blockType == ExceptionBlockType.EndExceptionBlock) ? (-1) : 0);
					foreach (ExceptionBlock item2 in list)
					{
						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/*cast due to .constrained prefix*/).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 static class MonoModHacks
	{
		private static readonly AccessTools.FieldRef<object, MethodBase> ManagedDetourState_EndOfChain_Ref = AccessTools.FieldRefAccess<object, MethodBase>(AccessTools.DeclaredField(typeof(DetourManager).GetNestedType("ManagedDetourState", AccessTools.all), "EndOfChain"));

		private static readonly AccessTools.FieldRef<MethodDetourInfo, object> MethodDetourInfo_State_Ref = AccessTools.FieldRefAccess<MethodDetourInfo, object>("state");

		private static readonly AccessTools.FieldRef<ILHook, object> ILHook_State_Ref = AccessTools.FieldRefAccess<ILHook, object>("state");

		internal static MethodBase GetEndOfChain(this ILHook self)
		{
			return ManagedDetourState_EndOfChain_Ref(ILHook_State_Ref(self));
		}

		internal static MethodBase GetEndOfChain(this MethodDetourInfo self)
		{
			return ManagedDetourState_EndOfChain_Ref(MethodDetourInfo_State_Ref(self));
		}
	}
	internal class ReflectionTools
	{
		internal struct TypeAndName
		{
			internal Type type;

			internal string name;
		}

		internal static readonly bool isWindows = Environment.OSVersion.Platform.Equals(PlatformID.Win32NT);

		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");
			}
			return new TypeAndName
			{
				type = AccessTools.TypeByName(array[0]),
				name = array[1]
			};
		}

		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)
				{
					throw new ArgumentException("FieldRefAccess return type must be the same as FieldType or " + $"FieldType's underlying integral type ({underlyingType}) for enum types");
				}
			}
			else
			{
				if (fieldType.IsValueType)
				{
					throw new ArgumentException("FieldRefAccess return type must be the same as FieldType for value types");
				}
				if (!typeFromHandle.IsAssignableFrom(fieldType))
				{
					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_0052: Expected O, but got Unknown
			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 Extensions.CreateDelegate<AccessTools.FieldRef<T, F>>((MethodBase)val.Generate());
		}

		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_0057: Expected O, but got Unknown
			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 Extensions.CreateDelegate<AccessTools.StructFieldRef<T, F>>((MethodBase)val.Generate());
		}

		internal static AccessTools.FieldRef<F> StaticFieldRefAccess<F>(FieldInfo fieldInfo)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			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(), Array.Empty<Type>());
			ILGenerator iLGenerator = val.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldsflda, fieldInfo);
			iLGenerator.Emit(OpCodes.Ret);
			return Extensions.CreateDelegate<AccessTools.FieldRef<F>>((MethodBase)val.Generate());
		}

		internal static FieldInfo GetInstanceField(Type type, string fieldName)
		{
			FieldInfo fieldInfo = AccessTools.Field(type, fieldName);
			if ((object)fieldInfo == null)
			{
				throw new MissingFieldException(type.Name, fieldName);
			}
			if (fieldInfo.IsStatic)
			{
				throw new ArgumentException("Field must not be static");
			}
			return fieldInfo;
		}

		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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			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);
			foreach (FieldInfo fieldInfo in fields)
			{
				OpCode value = (OpCode)fieldInfo.GetValue(null);
				SREOpCodes[value.Value] = value;
			}
			FieldInfo[] fields2 = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			foreach (FieldInfo fieldInfo2 in fields2)
			{
				OpCode value2 = (OpCode)fieldInfo2.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[] arr)
			{
				return Result<ILLabel>(arr, (ILLabel l) => l.Target);
			}
			if (insOp is Instruction[] arr2)
			{
				return Result<Instruction>(arr2, (Instruction i) => i);
			}
			return new int[0];
			int[] Result<T>(IEnumerable<T> source, Func<T, Instruction> insGetter)
			{
				return source.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_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: 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;
					CodeInstruction instruction2 = instructions[body.Instructions.IndexOf(current2.TryEnd)].Instruction;
					CodeInstruction instruction3 = instructions[body.Instructions.IndexOf(current2.HandlerStart)].Instruction;
					int index = ((current2.HandlerEnd == null) ? (instructions.Count - 1) : body.Instructions.IndexOf(current2.HandlerEnd.Previous));
					CodeInstruction instruction4 = instructions[index].Instruction;
					instruction.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock));
					instruction4.blocks.Add(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));
					ExceptionHandlerType handlerType = current2.HandlerType;
					switch ((int)handlerType)
					{
					case 0:
						instruction3.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock, ReflectionHelper.ResolveReflection(current2.CatchType)));
						break;
					case 1:
					{
						CodeInstruction instruction5 = instructions[body.Instructions.IndexOf(current2.FilterStart)].Instruction;
						instruction5.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptFilterBlock));
						break;
					}
					case 2:
						instruction3.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFinallyBlock));
						break;
					case 4:
						instruction3.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFaultBlock));
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).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);
				IEnumerable<CodeInstruction> instrs = transpiler.Invoke(null, transpilerArguments) as IEnumerable<CodeInstruction>;
				enumerable = NormalizeInstructions(instrs).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/*cast due to .constrained prefix*/).Dispose();
			}
			foreach (RawInstruction codeInstruction3 in codeInstructions)
			{
				codeInstruction3.Instruction.operand = codeInstruction3.Operand;
				switch (codeInstruction3.Instruction.opcode.OperandType)
				{
				case OperandType.InlineVar:
				case OperandType.ShortInlineVar:
				{
					object operand = codeInstruction3.Operand;
					VariableDefinition val = (VariableDefinition)((operand is VariableDefinition) ? operand : null);
					if (val != null)
					{
						codeInstruction3.Instruction.operand = localsCache[val];
					}
					break;
				}
				case OperandType.InlineSwitch:
					if (codeInstruction3.Operand is CodeInstruction[] array)
					{
						List<Label> list = new List<Label>();
						CodeInstruction[] array2 = array;
						foreach (CodeInstruction codeInstruction2 in array2)
						{
							Label item = defineLabel();
							codeInstruction2.labels.Add(item);
							list.Add(item);
						}
						codeInstruction3.Instruction.operand = list.ToArray();
					}
					break;
				case OperandType.InlineBrTarget:
				case OperandType.ShortInlineBrTarget:
					if (codeInstruction3.Instruction.operand is CodeInstruction codeInstruction)
					{
						Label label = defineLabel();
						codeInstruction.labels.Add(label);
						codeInstruction3.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();
			IEnumerable<CodeInstruction> enumerable = ApplyTranspilers(proxy, original, (Func<VariableDefinition, LocalBuilder>)((VariableDefinition vDef) => il.GetLocal(vDef)), (Func<Label>)((ILGeneratorShim)il).DefineLabel);
			foreach (CodeInstruction item in enumerable)
			{
				item.labels.ForEach(delegate(Label l)
				{
					((ILGeneratorShim)il).MarkLabel(l);
				});
				item.blocks.ForEach(delegate(ExceptionBlock b)
				{
					il.MarkBlockBefore(b);
				});
				if ((!(item.opcode == OpCodes.Endfilter) && !(item.opcode == OpCodes.Endfinally)) || item.blocks.Count <= 0)
				{
					switch (item.opcode.OperandType)
					{
					case OperandType.InlineNone:
						((ILGeneratorShim)il).Emit(item.opcode);
						break;
					case OperandType.InlineSig:
						throw new NotSupportedException("Emitting opcodes with CallSites is currently not fully implemented");
					default:
						if (item.operand == null)
						{
							throw new ArgumentNullException("operand", $"Invalid argument for {item}");
						}
						il.Emit(item.opcode, item.operand);
						break;
					}
				}
				item.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;
			}
		}
	}
}