using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.SymbolStore;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Iced.Intel;
using Iced.Intel.BlockEncoderInternal;
using Iced.Intel.DecoderInternal;
using Iced.Intel.EncoderInternal;
using Iced.Intel.Internal;
using Microsoft.Cci;
using Microsoft.Cci.Pdb;
using Microsoft.CodeAnalysis;
using Microsoft.Win32.SafeHandles;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Metadata;
using Mono.Cecil.PE;
using Mono.Collections.Generic;
using Mono.CompilerServices.SymbolWriter;
using Mono.Security.Cryptography;
using MonoMod;
using MonoMod.Backports.ILHelpers;
using MonoMod.Cil;
using MonoMod.Core;
using MonoMod.Core.Interop;
using MonoMod.Core.Interop.Attributes;
using MonoMod.Core.Platforms;
using MonoMod.Core.Platforms.Architectures;
using MonoMod.Core.Platforms.Architectures.AltEntryFactories;
using MonoMod.Core.Platforms.Memory;
using MonoMod.Core.Platforms.Runtimes;
using MonoMod.Core.Platforms.Systems;
using MonoMod.Core.Utils;
using MonoMod.Logs;
using MonoMod.SourceGen.Attributes;
using MonoMod.Utils;
using MonoMod.Utils.Cil;
using MonoMod.Utils.Interop;

[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: AssemblyCompany("Andreas Pardeike")]
[assembly: AssemblyConfiguration("ReleaseFat")]
[assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyDescription("A general non-destructive patch library for .NET and Mono modules")]
[assembly: AssemblyFileVersion("2.3.6.0")]
[assembly: AssemblyInformationalVersion("2.3.6.0+f41da7608c5c3e9c7bf16551462b14c0b5392db3")]
[assembly: AssemblyProduct("Harmony")]
[assembly: AssemblyTitle("0Harmony")]
[assembly: SecurityPermission(System.Security.Permissions.SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.3.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
	static <Module>()
	{
		<d93ed7d0-1242-4c9d-a80d-b2e3dba3921c>MMDbgLog.LogVersion();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 HarmonyLib
{
	public class DelegateTypeFactory
	{
		private readonly ModuleBuilder module;

		private static int counter;

		public DelegateTypeFactory()
		{
			counter++;
			string name = $"HarmonyDTFAssembly{counter}";
			AssemblyBuilder assemblyBuilder = PatchTools.DefineDynamicAssembly(name);
			module = assemblyBuilder.DefineDynamicModule($"HarmonyDTFModule{counter}");
		}

		public Type CreateDelegateType(MethodInfo method)
		{
			System.Reflection.TypeAttributes attr = System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Sealed;
			TypeBuilder typeBuilder = module.DefineType($"HarmonyDTFType{counter}", attr, typeof(MulticastDelegate));
			ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.RTSpecialName, CallingConventions.Standard, new Type[2]
			{
				typeof(object),
				typeof(IntPtr)
			});
			constructorBuilder.SetImplementationFlags(System.Reflection.MethodImplAttributes.CodeTypeMask);
			ParameterInfo[] parameters = method.GetParameters();
			MethodBuilder methodBuilder = typeBuilder.DefineMethod("Invoke", System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Virtual | System.Reflection.MethodAttributes.HideBySig, method.ReturnType, parameters.Types());
			methodBuilder.SetImplementationFlags(System.Reflection.MethodImplAttributes.CodeTypeMask);
			for (int i = 0; i < parameters.Length; i++)
			{
				methodBuilder.DefineParameter(i + 1, System.Reflection.ParameterAttributes.None, parameters[i].Name);
			}
			return typeBuilder.CreateType();
		}
	}
	[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>()
		{
			ConstructorInfo constructor = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null);
			if ((object)constructor == null)
			{
				throw new ApplicationException($"The type {typeof(T)} must declare an empty constructor (the constructor may be private, internal, protected, protected internal, or public).");
			}
			DynamicMethodDefinition dynamicMethodDefinition = new DynamicMethodDefinition("InstantiateObject_" + typeof(T).Name, typeof(T), null);
			ILGenerator iLGenerator = dynamicMethodDefinition.GetILGenerator();
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Newobj, constructor);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ret);
			return Extensions.CreateDelegate<InstantiationHandler<T>>(dynamicMethodDefinition.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 dynamicMethodDefinition = CreateGetDynamicMethod<T, S>(propertyInfo.DeclaringType);
			ILGenerator iLGenerator = dynamicMethodDefinition.GetILGenerator();
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Call, getMethod);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ret);
			return Extensions.CreateDelegate<GetterHandler<T, S>>(dynamicMethodDefinition.Generate());
		}

		[Obsolete("Use AccessTools.FieldRefAccess<T, S>(fieldInfo)")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static GetterHandler<T, S> CreateGetterHandler<T, S>(FieldInfo fieldInfo)
		{
			DynamicMethodDefinition dynamicMethodDefinition = CreateGetDynamicMethod<T, S>(fieldInfo.DeclaringType);
			ILGenerator iLGenerator = dynamicMethodDefinition.GetILGenerator();
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ldfld, fieldInfo);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ret);
			return Extensions.CreateDelegate<GetterHandler<T, S>>(dynamicMethodDefinition.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 dynamicMethodDefinition = CreateSetDynamicMethod<T, S>(propertyInfo.DeclaringType);
			ILGenerator iLGenerator = dynamicMethodDefinition.GetILGenerator();
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Call, setMethod);
			iLGenerator.Emit(System.Reflection.Emit.OpCodes.Ret);
			return Extensions.CreateDelegate<SetterHandler<T, S>>(dynamicMethodDefinition.Generate());
		}

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

		private static DynamicMethodDefinition CreateGetDynamicMethod<T, S>(Type type)
		{
			return new DynamicMethodDefinition("DynamicGet_" + type.Name, typeof(S), new Type[1] { typeof(T) });
		}

		private static DynamicMethodDefinition CreateSetDynamicMethod<T, S>(Type type)
		{
			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)
		{
			DynamicMethodDefinition dynamicMethodDefinition = new DynamicMethodDefinition("FastInvoke_" + methodInfo.Name + "_" + (directBoxValueAccess ? "direct" : "indirect"), typeof(object), new Type[2]
			{
				typeof(object),
				typeof(object[])
			});
			ILGenerator iLGenerator = dynamicMethodDefinition.GetILGenerator();
			if (!methodInfo.IsStatic)
			{
				Emit(iLGenerator, System.Reflection.Emit.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, System.Reflection.Emit.OpCodes.Ldarg_1);
					EmitFastInt(iLGenerator, i);
				}
				Emit(iLGenerator, System.Reflection.Emit.OpCodes.Ldarg_1);
				EmitFastInt(iLGenerator, i);
				if (isByRef && !isValueType)
				{
					Emit(iLGenerator, System.Reflection.Emit.OpCodes.Ldelema, typeof(object));
					continue;
				}
				Emit(iLGenerator, System.Reflection.Emit.OpCodes.Ldelem_Ref);
				if (!isValueType)
				{
					continue;
				}
				if (!isByRef || !directBoxValueAccess)
				{
					Emit(iLGenerator, System.Reflection.Emit.OpCodes.Unbox_Any, type);
					if (isByRef)
					{
						Emit(iLGenerator, System.Reflection.Emit.OpCodes.Box, type);
						Emit(iLGenerator, System.Reflection.Emit.OpCodes.Dup);
						if (flag)
						{
							flag = false;
							iLGenerator.DeclareLocal(typeof(object), pinned: false);
						}
						Emit(iLGenerator, System.Reflection.Emit.OpCodes.Stloc_0);
						Emit(iLGenerator, System.Reflection.Emit.OpCodes.Stelem_Ref);
						Emit(iLGenerator, System.Reflection.Emit.OpCodes.Ldloc_0);
						Emit(iLGenerator, System.Reflection.Emit.OpCodes.Unbox, type);
					}
				}
				else
				{
					Emit(iLGenerator, System.Reflection.Emit.OpCodes.Unbox, type);
				}
			}
			if (methodInfo.IsStatic)
			{
				EmitCall(iLGenerator, System.Reflection.Emit.OpCodes.Call, methodInfo);
			}
			else
			{
				EmitCall(iLGenerator, System.Reflection.Emit.OpCodes.Callvirt, methodInfo);
			}
			if ((object)methodInfo.ReturnType == typeof(void))
			{
				Emit(iLGenerator, System.Reflection.Emit.OpCodes.Ldnull);
			}
			else
			{
				EmitBoxIfNeeded(iLGenerator, methodInfo.ReturnType);
			}
			Emit(iLGenerator, System.Reflection.Emit.OpCodes.Ret);
			return Extensions.CreateDelegate<FastInvokeHandler>(dynamicMethodDefinition.Generate());
		}

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

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

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

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

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

		internal static void EmitFastInt(ILGenerator il, int value)
		{
			switch (value)
			{
			case -1:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_M1);
				return;
			case 0:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
				return;
			case 1:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
				return;
			case 2:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_2);
				return;
			case 3:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_3);
				return;
			case 4:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_4);
				return;
			case 5:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_5);
				return;
			case 6:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_6);
				return;
			case 7:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_7);
				return;
			case 8:
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_8);
				return;
			}
			if (value > -129 && value < 128)
			{
				il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_S, (sbyte)value);
			}
			else
			{
				il.Emit(System.Reflection.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 class ByteBuffer
	{
		internal byte[] buffer;

		internal int position;

		internal ByteBuffer(byte[] buffer)
		{
			this.buffer = buffer;
		}

		internal byte ReadByte()
		{
			CheckCanRead(1);
			return buffer[position++];
		}

		internal byte[] ReadBytes(int length)
		{
			CheckCanRead(length);
			byte[] array = new byte[length];
			Buffer.BlockCopy(buffer, position, array, 0, length);
			position += length;
			return array;
		}

		internal short ReadInt16()
		{
			CheckCanRead(2);
			short result = (short)(buffer[position] | (buffer[position + 1] << 8));
			position += 2;
			return result;
		}

		internal int ReadInt32()
		{
			CheckCanRead(4);
			int result = buffer[position] | (buffer[position + 1] << 8) | (buffer[position + 2] << 16) | (buffer[position + 3] << 24);
			position += 4;
			return result;
		}

		internal long ReadInt64()
		{
			CheckCanRead(8);
			uint num = (uint)(buffer[position] | (buffer[position + 1] << 8) | (buffer[position + 2] << 16) | (buffer[position + 3] << 24));
			uint num2 = (uint)(buffer[position + 4] | (buffer[position + 5] << 8) | (buffer[position + 6] << 16) | (buffer[position + 7] << 24));
			long result = (long)(((ulong)num2 << 32) | num);
			position += 8;
			return result;
		}

		internal float ReadSingle()
		{
			if (!BitConverter.IsLittleEndian)
			{
				byte[] array = ReadBytes(4);
				Array.Reverse((Array)array);
				return BitConverter.ToSingle(array, 0);
			}
			CheckCanRead(4);
			float result = BitConverter.ToSingle(buffer, position);
			position += 4;
			return result;
		}

		internal double ReadDouble()
		{
			if (!BitConverter.IsLittleEndian)
			{
				byte[] array = ReadBytes(8);
				Array.Reverse((Array)array);
				return BitConverter.ToDouble(array, 0);
			}
			CheckCanRead(8);
			double result = BitConverter.ToDouble(buffer, position);
			position += 8;
			return result;
		}

		private void CheckCanRead(int count)
		{
			if (position + count > buffer.Length)
			{
				throw new ArgumentOutOfRangeException("count", $"position({position}) + count({count}) > buffer.Length({buffer.Length})");
			}
		}
	}
	internal class CodeTranspiler
	{
		[CompilerGenerated]
		private sealed class <ConvertToOurInstructions>d__7 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable instructions;

			public IEnumerable <>3__instructions;

			private Type codeInstructionType;

			public Type <>3__codeInstructionType;

			private Dictionary<object, Dictionary<string, object>> unassignedValues;

			public Dictionary<object, Dictionary<string, object>> <>3__unassignedValues;

			private List<object> originalInstructions;

			public List<object> <>3__originalInstructions;

			private List<object> <newInstructions>5__2;

			private int <index>5__3;

			private List<object>.Enumerator <>7__wrap3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ConvertToOurInstructions>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Thread.CurrentThread.ManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<newInstructions>5__2 = null;
				<>7__wrap3 = default(List<object>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<newInstructions>5__2 = instructions.Cast<object>().ToList();
						<index>5__3 = -1;
						<>7__wrap3 = <newInstructions>5__2.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap3.MoveNext())
					{
						object current = <>7__wrap3.Current;
						<index>5__3++;
						object root = AccessTools.MakeDeepCopy(current, codeInstructionType);
						if (unassignedValues.TryGetValue(current, out var value))
						{
							bool flag = ShouldAddExceptionInfo(current, <index>5__3, originalInstructions, <newInstructions>5__2, unassignedValues);
							Traverse traverse = Traverse.Create(root);
							foreach (KeyValuePair<string, object> item in value)
							{
								if (flag || item.Key != "blocks")
								{
									traverse.Field(item.Key).SetValue(item.Value);
								}
							}
						}
						<>2__current = root;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap3 = default(List<object>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap3).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<object> IEnumerable<object>.GetEnumerator()
			{
				<ConvertToOurInstructions>d__7 <ConvertToOurInstructions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Thread.CurrentThread.ManagedThreadId)
				{
					<>1__state = 0;
					<ConvertToOurInstructions>d__ = this;
				}
				else
				{
					<ConvertToOurInstructions>d__ = new <ConvertToOurInstructions>d__7(0);
				}
				<ConvertToOurInstructions>d__.instructions = <>3__instructions;
				<ConvertToOurInstructions>d__.codeInstructionType = <>3__codeInstructionType;
				<ConvertToOurInstructions>d__.originalInstructions = <>3__originalInstructions;
				<ConvertToOurInstructions>d__.unassignedValues = <>3__unassignedValues;
				return <ConvertToOurInstructions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<object>)this).GetEnumerator();
			}
		}

		private readonly IEnumerable<CodeInstruction> codeInstructions;

		private readonly List<MethodInfo> transpilers = new List<MethodInfo>();

		private static readonly Dictionary<System.Reflection.Emit.OpCode, System.Reflection.Emit.OpCode> allJumpCodes = new Dictionary<System.Reflection.Emit.OpCode, System.Reflection.Emit.OpCode>
		{
			{
				System.Reflection.Emit.OpCodes.Beq_S,
				System.Reflection.Emit.OpCodes.Beq
			},
			{
				System.Reflection.Emit.OpCodes.Bge_S,
				System.Reflection.Emit.OpCodes.Bge
			},
			{
				System.Reflection.Emit.OpCodes.Bge_Un_S,
				System.Reflection.Emit.OpCodes.Bge_Un
			},
			{
				System.Reflection.Emit.OpCodes.Bgt_S,
				System.Reflection.Emit.OpCodes.Bgt
			},
			{
				System.Reflection.Emit.OpCodes.Bgt_Un_S,
				System.Reflection.Emit.OpCodes.Bgt_Un
			},
			{
				System.Reflection.Emit.OpCodes.Ble_S,
				System.Reflection.Emit.OpCodes.Ble
			},
			{
				System.Reflection.Emit.OpCodes.Ble_Un_S,
				System.Reflection.Emit.OpCodes.Ble_Un
			},
			{
				System.Reflection.Emit.OpCodes.Blt_S,
				System.Reflection.Emit.OpCodes.Blt
			},
			{
				System.Reflection.Emit.OpCodes.Blt_Un_S,
				System.Reflection.Emit.OpCodes.Blt_Un
			},
			{
				System.Reflection.Emit.OpCodes.Bne_Un_S,
				System.Reflection.Emit.OpCodes.Bne_Un
			},
			{
				System.Reflection.Emit.OpCodes.Brfalse_S,
				System.Reflection.Emit.OpCodes.Brfalse
			},
			{
				System.Reflection.Emit.OpCodes.Brtrue_S,
				System.Reflection.Emit.OpCodes.Brtrue
			},
			{
				System.Reflection.Emit.OpCodes.Br_S,
				System.Reflection.Emit.OpCodes.Br
			},
			{
				System.Reflection.Emit.OpCodes.Leave_S,
				System.Reflection.Emit.OpCodes.Leave
			}
		};

		internal CodeTranspiler(List<ILInstruction> ilInstructions)
		{
			codeInstructions = ilInstructions.Select((ILInstruction ilInstruction) => ilInstruction.GetCodeInstruction()).ToList().AsEnumerable();
		}

		internal void Add(MethodInfo transpiler)
		{
			transpilers.Add(transpiler);
		}

		internal static object ConvertInstruction(Type type, object instruction, out Dictionary<string, object> unassigned)
		{
			Dictionary<string, object> nonExisting = new Dictionary<string, object>();
			object result = AccessTools.MakeDeepCopy(instruction, type, delegate(string namePath, Traverse trvSrc, Traverse trvDest)
			{
				object value = trvSrc.GetValue();
				if (!trvDest.FieldExists())
				{
					nonExisting[namePath] = value;
					return null;
				}
				return (namePath == "opcode") ? ((object)ReplaceShortJumps((System.Reflection.Emit.OpCode)value)) : value;
			});
			unassigned = nonExisting;
			return result;
		}

		internal static bool ShouldAddExceptionInfo(object op, int opIndex, List<object> originalInstructions, List<object> newInstructions, Dictionary<object, Dictionary<string, object>> unassignedValues)
		{
			int num = originalInstructions.IndexOf(op);
			if (num == -1)
			{
				return false;
			}
			if (!unassignedValues.TryGetValue(op, out var unassigned))
			{
				return false;
			}
			if (!unassigned.TryGetValue("blocks", out var blocksObject))
			{
				return false;
			}
			List<ExceptionBlock> blocks = blocksObject as List<ExceptionBlock>;
			int num2 = newInstructions.Count((object instr) => instr == op);
			if (num2 <= 1)
			{
				return true;
			}
			ExceptionBlock exceptionBlock = blocks.FirstOrDefault((ExceptionBlock block) => block.blockType != ExceptionBlockType.EndExceptionBlock);
			ExceptionBlock exceptionBlock2 = blocks.FirstOrDefault((ExceptionBlock block) => block.blockType == ExceptionBlockType.EndExceptionBlock);
			if (exceptionBlock != null && exceptionBlock2 == null)
			{
				object obj = originalInstructions.Skip(num + 1).FirstOrDefault(delegate(object instr)
				{
					if (!unassignedValues.TryGetValue(instr, out unassigned))
					{
						return false;
					}
					if (!unassigned.TryGetValue("blocks", out blocksObject))
					{
						return false;
					}
					blocks = blocksObject as List<ExceptionBlock>;
					return blocks.Count > 0;
				});
				if (obj != null)
				{
					int num3 = num + 1;
					int num4 = num3 + originalInstructions.Skip(num3).ToList().IndexOf(obj) - 1;
					IEnumerable<object> first = originalInstructions.GetRange(num3, num4 - num3).Intersect(newInstructions);
					obj = newInstructions.Skip(opIndex + 1).FirstOrDefault(delegate(object instr)
					{
						if (!unassignedValues.TryGetValue(instr, out unassigned))
						{
							return false;
						}
						if (!unassigned.TryGetValue("blocks", out blocksObject))
						{
							return false;
						}
						blocks = blocksObject as List<ExceptionBlock>;
						return blocks.Count > 0;
					});
					if (obj != null)
					{
						num3 = opIndex + 1;
						num4 = num3 + newInstructions.Skip(opIndex + 1).ToList().IndexOf(obj) - 1;
						List<object> range = newInstructions.GetRange(num3, num4 - num3);
						List<object> list = first.Except(range).ToList();
						return list.Count == 0;
					}
				}
			}
			if (exceptionBlock == null && exceptionBlock2 != null)
			{
				object obj2 = originalInstructions.GetRange(0, num).LastOrDefault(delegate(object instr)
				{
					if (!unassignedValues.TryGetValue(instr, out unassigned))
					{
						return false;
					}
					if (!unassigned.TryGetValue("blocks", out blocksObject))
					{
						return false;
					}
					blocks = blocksObject as List<ExceptionBlock>;
					return blocks.Count > 0;
				});
				if (obj2 != null)
				{
					int num5 = originalInstructions.GetRange(0, num).LastIndexOf(obj2);
					int num6 = num;
					IEnumerable<object> first2 = originalInstructions.GetRange(num5, num6 - num5).Intersect(newInstructions);
					obj2 = newInstructions.GetRange(0, opIndex).LastOrDefault(delegate(object instr)
					{
						if (!unassignedValues.TryGetValue(instr, out unassigned))
						{
							return false;
						}
						if (!unassigned.TryGetValue("blocks", out blocksObject))
						{
							return false;
						}
						blocks = blocksObject as List<ExceptionBlock>;
						return blocks.Count > 0;
					});
					if (obj2 != null)
					{
						num5 = newInstructions.GetRange(0, opIndex).LastIndexOf(obj2);
						num6 = opIndex;
						List<object> range2 = newInstructions.GetRange(num5, num6 - num5);
						IEnumerable<object> source = first2.Except(range2);
						return !source.Any();
					}
				}
			}
			return true;
		}

		internal static IEnumerable ConvertInstructionsAndUnassignedValues(Type type, IEnumerable enumerable, out Dictionary<object, Dictionary<string, object>> unassignedValues)
		{
			Assembly assembly = type.GetGenericTypeDefinition().Assembly;
			Type type2 = assembly.GetType(typeof(List<>).FullName);
			Type type3 = type.GetGenericArguments()[0];
			Type type4 = type2.MakeGenericType(type3);
			Type type5 = assembly.GetType(type4.FullName);
			object obj = Activator.CreateInstance(type5);
			MethodInfo method = obj.GetType().GetMethod("Add");
			unassignedValues = new Dictionary<object, Dictionary<string, object>>();
			foreach (object item in enumerable)
			{
				Dictionary<string, object> unassigned;
				object obj2 = ConvertInstruction(type3, item, out unassigned);
				unassignedValues.Add(obj2, unassigned);
				method.Invoke(obj, new object[1] { obj2 });
			}
			return obj as IEnumerable;
		}

		internal static IEnumerable ConvertToOurInstructions(IEnumerable instructions, Type codeInstructionType, List<object> originalInstructions, Dictionary<object, Dictionary<string, object>> unassignedValues)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ConvertToOurInstructions>d__7(-2)
			{
				<>3__instructions = instructions,
				<>3__codeInstructionType = codeInstructionType,
				<>3__originalInstructions = originalInstructions,
				<>3__unassignedValues = unassignedValues
			};
		}

		private static bool IsCodeInstructionsParameter(Type type)
		{
			if (type.IsGenericType)
			{
				return type.GetGenericTypeDefinition().Name.StartsWith("IEnumerable", StringComparison.Ordinal);
			}
			return false;
		}

		internal static IEnumerable ConvertToGeneralInstructions(MethodInfo transpiler, IEnumerable enumerable, out Dictionary<object, Dictionary<string, object>> unassignedValues)
		{
			Type type = (from p in transpiler.GetParameters()
				select p.ParameterType).FirstOrDefault(IsCodeInstructionsParameter);
			if ((object)type == typeof(IEnumerable<CodeInstruction>))
			{
				unassignedValues = null;
				object obj = enumerable as IList<CodeInstruction>;
				if (obj == null)
				{
					List<CodeInstruction> list = new List<CodeInstruction>();
					list.AddRange((enumerable as IEnumerable<CodeInstruction>) ?? enumerable.Cast<CodeInstruction>());
					obj = list;
				}
				return (IEnumerable)obj;
			}
			return ConvertInstructionsAndUnassignedValues(type, enumerable, out unassignedValues);
		}

		internal static List<object> GetTranspilerCallParameters(ILGenerator generator, MethodInfo transpiler, MethodBase method, IEnumerable instructions)
		{
			List<object> parameter = new List<object>();
			(from param in transpiler.GetParameters()
				select param.ParameterType).Do(delegate(Type type)
			{
				if (type.IsAssignableFrom(typeof(ILGenerator)))
				{
					parameter.Add(generator);
				}
				else if (type.IsAssignableFrom(typeof(MethodBase)))
				{
					parameter.Add(method);
				}
				else if (IsCodeInstructionsParameter(type))
				{
					parameter.Add(instructions);
				}
			});
			return parameter;
		}

		internal List<CodeInstruction> GetResult(ILGenerator generator, MethodBase method)
		{
			IEnumerable instructions = codeInstructions;
			transpilers.ForEach(delegate(MethodInfo transpiler)
			{
				instructions = ConvertToGeneralInstructions(transpiler, instructions, out var unassignedValues);
				List<object> originalInstructions = null;
				if (unassignedValues != null)
				{
					originalInstructions = instructions.Cast<object>().ToList();
				}
				List<object> transpilerCallParameters = GetTranspilerCallParameters(generator, transpiler, method, instructions);
				if (transpiler.Invoke(null, transpilerCallParameters.ToArray()) is IEnumerable enumerable)
				{
					instructions = enumerable;
				}
				if (unassignedValues != null)
				{
					instructions = ConvertToOurInstructions(instructions, typeof(CodeInstruction), originalInstructions, unassignedValues);
				}
			});
			return (instructions as List<CodeInstruction>) ?? instructions.Cast<CodeInstruction>().ToList();
		}

		private static System.Reflection.Emit.OpCode ReplaceShortJumps(System.Reflection.Emit.OpCode opcode)
		{
			foreach (KeyValuePair<System.Reflection.Emit.OpCode, System.Reflection.Emit.OpCode> allJumpCode in allJumpCodes)
			{
				if (opcode == allJumpCode.Key)
				{
					return allJumpCode.Value;
				}
			}
			return opcode;
		}
	}
	internal class LeaveTry
	{
		public override string ToString()
		{
			return "(autogenerated)";
		}
	}
	internal class Emitter
	{
		private readonly CecilILGenerator il;

		private readonly Dictionary<int, CodeInstruction> instructions = new Dictionary<int, CodeInstruction>();

		private readonly bool debug;

		internal Emitter(ILGenerator il, bool debug)
		{
			this.il = il.GetProxiedShim<CecilILGenerator>();
			this.debug = debug;
		}

		internal Dictionary<int, CodeInstruction> GetInstructions()
		{
			return instructions;
		}

		internal void AddInstruction(System.Reflection.Emit.OpCode opcode, object operand)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, operand));
		}

		internal int CurrentPos()
		{
			return il.ILOffset;
		}

		internal static string CodePos(int offset)
		{
			return $"IL_{offset:X4}: ";
		}

		internal string CodePos()
		{
			return CodePos(CurrentPos());
		}

		internal void LogComment(string comment)
		{
			if (debug)
			{
				string str = $"{CodePos()}// {comment}";
				FileLog.LogBuffered(str);
			}
		}

		internal void LogIL(System.Reflection.Emit.OpCode opcode)
		{
			if (debug)
			{
				FileLog.LogBuffered($"{CodePos()}{opcode}");
			}
		}

		internal void LogIL(System.Reflection.Emit.OpCode opcode, object arg, string extra = null)
		{
			if (debug)
			{
				string text = FormatArgument(arg, extra);
				string text2 = ((text.Length > 0) ? " " : "");
				string text3 = opcode.ToString();
				if (opcode.FlowControl == System.Reflection.Emit.FlowControl.Branch || opcode.FlowControl == System.Reflection.Emit.FlowControl.Cond_Branch)
				{
					text3 += " =>";
				}
				text3 = text3.PadRight(10);
				FileLog.LogBuffered($"{CodePos()}{text3}{text2}{text}");
			}
		}

		internal void LogAllLocalVariables()
		{
			if (debug)
			{
				il.IL.Body.Variables.Do(delegate(VariableDefinition v)
				{
					string str = string.Format("{0}Local var {1}: {2}{3}", CodePos(0), v.Index, v.VariableType.FullName, v.IsPinned ? "(pinned)" : "");
					FileLog.LogBuffered(str);
				});
			}
		}

		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 ((object)type == typeof(Label))
			{
				return $"Label{((Label)argument).GetHashCode()}";
			}
			if ((object)type == typeof(Label[]))
			{
				return "Labels" + string.Join(",", ((Label[])argument).Select((Label l) => l.GetHashCode().ToString()).ToArray());
			}
			if ((object)type == typeof(LocalBuilder))
			{
				return $"{((LocalBuilder)argument).LocalIndex} ({((LocalBuilder)argument).LocalType})";
			}
			if ((object)type == typeof(string))
			{
				return argument.ToString().ToLiteral();
			}
			return argument.ToString().Trim();
		}

		internal void MarkLabel(Label label)
		{
			if (debug)
			{
				FileLog.LogBuffered(CodePos() + FormatArgument(label));
			}
			il.MarkLabel(label);
		}

		internal void MarkBlockBefore(ExceptionBlock block, out Label? label)
		{
			label = null;
			switch (block.blockType)
			{
			case ExceptionBlockType.BeginExceptionBlock:
				if (debug)
				{
					FileLog.LogBuffered(".try");
					FileLog.LogBuffered("{");
					FileLog.ChangeIndent(1);
				}
				label = il.BeginExceptionBlock();
				break;
			case ExceptionBlockType.BeginCatchBlock:
				if (debug)
				{
					LogIL(System.Reflection.Emit.OpCodes.Leave, new LeaveTry());
					FileLog.ChangeIndent(-1);
					FileLog.LogBuffered("} // end try");
					FileLog.LogBuffered($".catch {block.catchType}");
					FileLog.LogBuffered("{");
					FileLog.ChangeIndent(1);
				}
				il.BeginCatchBlock(block.catchType);
				break;
			case ExceptionBlockType.BeginExceptFilterBlock:
				if (debug)
				{
					LogIL(System.Reflection.Emit.OpCodes.Leave, new LeaveTry());
					FileLog.ChangeIndent(-1);
					FileLog.LogBuffered("} // end try");
					FileLog.LogBuffered(".filter");
					FileLog.LogBuffered("{");
					FileLog.ChangeIndent(1);
				}
				il.BeginExceptFilterBlock();
				break;
			case ExceptionBlockType.BeginFaultBlock:
				if (debug)
				{
					LogIL(System.Reflection.Emit.OpCodes.Leave, new LeaveTry());
					FileLog.ChangeIndent(-1);
					FileLog.LogBuffered("} // end try");
					FileLog.LogBuffered(".fault");
					FileLog.LogBuffered("{");
					FileLog.ChangeIndent(1);
				}
				il.BeginFaultBlock();
				break;
			case ExceptionBlockType.BeginFinallyBlock:
				if (debug)
				{
					LogIL(System.Reflection.Emit.OpCodes.Leave, new LeaveTry());
					FileLog.ChangeIndent(-1);
					FileLog.LogBuffered("} // end try");
					FileLog.LogBuffered(".finally");
					FileLog.LogBuffered("{");
					FileLog.ChangeIndent(1);
				}
				il.BeginFinallyBlock();
				break;
			}
		}

		internal void MarkBlockAfter(ExceptionBlock block)
		{
			ExceptionBlockType blockType = block.blockType;
			if (blockType == ExceptionBlockType.EndExceptionBlock)
			{
				if (debug)
				{
					LogIL(System.Reflection.Emit.OpCodes.Leave, new LeaveTry());
					FileLog.ChangeIndent(-1);
					FileLog.LogBuffered("} // end handler");
				}
				il.EndExceptionBlock();
			}
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode));
			LogIL(opcode);
			il.Emit(opcode);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, LocalBuilder local)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, local));
			LogIL(opcode, local);
			il.Emit(opcode, local);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, FieldInfo field)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, field));
			LogIL(opcode, field);
			il.Emit(opcode, field);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, Label[] labels)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, labels));
			LogIL(opcode, labels);
			il.Emit(opcode, labels);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, Label label)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, label));
			LogIL(opcode, label);
			il.Emit(opcode, label);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, string str)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, str));
			LogIL(opcode, str);
			il.Emit(opcode, str);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, float arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, byte arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, sbyte arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, double arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, int arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, MethodInfo meth)
		{
			if (opcode.Equals(System.Reflection.Emit.OpCodes.Call) || opcode.Equals(System.Reflection.Emit.OpCodes.Callvirt) || opcode.Equals(System.Reflection.Emit.OpCodes.Newobj))
			{
				EmitCall(opcode, meth, null);
				return;
			}
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, meth));
			LogIL(opcode, meth);
			il.Emit(opcode, meth);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, short arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, SignatureHelper signature)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, signature));
			LogIL(opcode, signature);
			il.Emit(opcode, signature);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, ConstructorInfo con)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, con));
			LogIL(opcode, con);
			il.Emit(opcode, con);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, Type cls)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, cls));
			LogIL(opcode, cls);
			il.Emit(opcode, cls);
		}

		internal void Emit(System.Reflection.Emit.OpCode opcode, long arg)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, arg));
			LogIL(opcode, arg);
			il.Emit(opcode, arg);
		}

		internal void EmitCall(System.Reflection.Emit.OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, methodInfo));
			string extra = ((optionalParameterTypes != null && optionalParameterTypes.Length != 0) ? optionalParameterTypes.Description() : null);
			LogIL(opcode, methodInfo, extra);
			il.EmitCall(opcode, methodInfo, optionalParameterTypes);
		}

		internal void EmitCalli(System.Reflection.Emit.OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, unmanagedCallConv));
			string extra = returnType.FullName + " " + parameterTypes.Description();
			LogIL(opcode, unmanagedCallConv, extra);
			il.EmitCalli(opcode, unmanagedCallConv, returnType, parameterTypes);
		}

		internal void EmitCalli(System.Reflection.Emit.OpCode opcode, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
		{
			instructions.Add(CurrentPos(), new CodeInstruction(opcode, callingConvention));
			string extra = returnType.FullName + " " + parameterTypes.Description() + " " + optionalParameterTypes.Description();
			LogIL(opcode, callingConvention, extra);
			il.EmitCalli(opcode, callingConvention, returnType, parameterTypes, optionalParameterTypes);
		}
	}
	internal static class HarmonySharedState
	{
		private const string name = "HarmonySharedState";

		internal const int internalVersion = 102;

		private static readonly Dictionary<MethodBase, byte[]> state;

		private static readonly Dictionary<MethodInfo, MethodBase> originals;

		private static readonly Dictionary<long, MethodBase[]> originalsMono;

		private static readonly AccessTools.FieldRef<StackFrame, long> methodAddressRef;

		internal static readonly int actualVersion;

		static HarmonySharedState()
		{
			Type orCreateSharedStateType = GetOrCreateSharedStateType();
			if (AccessTools.IsMonoRuntime)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(StackFrame), "methodAddress");
				if ((object)fieldInfo != null)
				{
					methodAddressRef = AccessTools.FieldRefAccess<StackFrame, long>(fieldInfo);
				}
			}
			FieldInfo field = orCreateSharedStateType.GetField("version");
			if ((int)field.GetValue(null) == 0)
			{
				field.SetValue(null, 102);
			}
			actualVersion = (int)field.GetValue(null);
			FieldInfo field2 = orCreateSharedStateType.GetField("state");
			if (field2.GetValue(null) == null)
			{
				field2.SetValue(null, new Dictionary<MethodBase, byte[]>());
			}
			FieldInfo field3 = orCreateSharedStateType.GetField("originals");
			if ((object)field3 != null && field3.GetValue(null) == null)
			{
				field3.SetValue(null, new Dictionary<MethodInfo, MethodBase>());
			}
			FieldInfo field4 = orCreateSharedStateType.GetField("originalsMono");
			if ((object)field4 != null && field4.GetValue(null) == null)
			{
				field4.SetValue(null, new Dictionary<long, MethodBase[]>());
			}
			state = (Dictionary<MethodBase, byte[]>)field2.GetValue(null);
			originals = new Dictionary<MethodInfo, MethodBase>();
			if ((object)field3 != null)
			{
				originals = (Dictionary<MethodInfo, MethodBase>)field3.GetValue(null);
			}
			originalsMono = new Dictionary<long, MethodBase[]>();
			if ((object)field4 != null)
			{
				originalsMono = (Dictionary<long, MethodBase[]>)field4.GetValue(null);
			}
		}

		private static Type GetOrCreateSharedStateType()
		{
			Type type = Type.GetType("HarmonySharedState", throwOnError: false);
			if ((object)type != null)
			{
				return type;
			}
			using ModuleDefinition moduleDefinition = ModuleDefinition.CreateModule("HarmonySharedState", new ModuleParameters
			{
				Kind = ModuleKind.Dll,
				ReflectionImporterProvider = MMReflectionImporter.Provider
			});
			Mono.Cecil.TypeAttributes attributes = Mono.Cecil.TypeAttributes.Public | Mono.Cecil.TypeAttributes.Abstract | Mono.Cecil.TypeAttributes.Sealed;
			TypeDefinition typeDefinition = new TypeDefinition("", "HarmonySharedState", attributes)
			{
				BaseType = moduleDefinition.TypeSystem.Object
			};
			moduleDefinition.Types.Add(typeDefinition);
			typeDefinition.Fields.Add(new FieldDefinition("state", Mono.Cecil.FieldAttributes.Public | Mono.Cecil.FieldAttributes.Static, moduleDefinition.ImportReference(typeof(Dictionary<MethodBase, byte[]>))));
			typeDefinition.Fields.Add(new FieldDefinition("originals", Mono.Cecil.FieldAttributes.Public | Mono.Cecil.FieldAttributes.Static, moduleDefinition.ImportReference(typeof(Dictionary<MethodInfo, MethodBase>))));
			typeDefinition.Fields.Add(new FieldDefinition("originalsMono", Mono.Cecil.FieldAttributes.Public | Mono.Cecil.FieldAttributes.Static, moduleDefinition.ImportReference(typeof(Dictionary<long, MethodBase[]>))));
			typeDefinition.Fields.Add(new FieldDefinition("version", Mono.Cecil.FieldAttributes.Public | Mono.Cecil.FieldAttributes.Static, moduleDefinition.ImportReference(typeof(int))));
			return ReflectionHelper.Load(moduleDefinition).GetType("HarmonySharedState");
		}

		internal static PatchInfo GetPatchInfo(MethodBase method)
		{
			byte[] valueSafe;
			lock (state)
			{
				valueSafe = state.GetValueSafe(method);
			}
			if (valueSafe == null)
			{
				return null;
			}
			return PatchInfoSerialization.Deserialize(valueSafe);
		}

		internal static IEnumerable<MethodBase> GetPatchedMethods()
		{
			lock (state)
			{
				return state.Keys.ToArray();
			}
		}

		internal static void UpdatePatchInfo(MethodBase original, MethodInfo replacement, PatchInfo patchInfo)
		{
			byte[] value = patchInfo.Serialize();
			lock (state)
			{
				state[original] = value;
			}
			lock (originals)
			{
				originals[replacement.Identifiable()] = original;
			}
			if (AccessTools.IsMonoRuntime)
			{
				long key = (long)replacement.MethodHandle.GetFunctionPointer();
				lock (originalsMono)
				{
					originalsMono[key] = new MethodBase[2] { original, replacement };
				}
			}
		}

		internal static MethodBase GetRealMethod(MethodInfo method, bool useReplacement)
		{
			MethodInfo key = method.Identifiable();
			lock (originals)
			{
				if (originals.TryGetValue(key, out var value))
				{
					return value;
				}
			}
			if (AccessTools.IsMonoRuntime)
			{
				long key2 = (long)method.MethodHandle.GetFunctionPointer();
				lock (originalsMono)
				{
					if (originalsMono.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 (originalsMono)
				{
					if (originalsMono.TryGetValue(key, out var value))
					{
						return useReplacement ? value[1] : value[0];
					}
				}
			}
			return null;
		}
	}
	internal class ILInstruction
	{
		internal int offset;

		internal System.Reflection.Emit.OpCode opcode;

		internal object operand;

		internal object argument;

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

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

		internal ILInstruction(System.Reflection.Emit.OpCode opcode, object operand = null)
		{
			this.opcode = opcode;
			this.operand = operand;
			argument = operand;
		}

		internal CodeInstruction GetCodeInstruction()
		{
			CodeInstruction codeInstruction = new CodeInstruction(opcode, argument);
			if (opcode.OperandType == System.Reflection.Emit.OperandType.InlineNone)
			{
				codeInstruction.operand = null;
			}
			codeInstruction.labels = labels;
			codeInstruction.blocks = blocks;
			return codeInstruction;
		}

		internal int GetSize()
		{
			int num = opcode.Size;
			switch (opcode.OperandType)
			{
			case System.Reflection.Emit.OperandType.InlineSwitch:
				num += (1 + ((Array)operand).Length) * 4;
				break;
			case System.Reflection.Emit.OperandType.InlineI8:
			case System.Reflection.Emit.OperandType.InlineR:
				num += 8;
				break;
			case System.Reflection.Emit.OperandType.InlineBrTarget:
			case System.Reflection.Emit.OperandType.InlineField:
			case System.Reflection.Emit.OperandType.InlineI:
			case System.Reflection.Emit.OperandType.InlineMethod:
			case System.Reflection.Emit.OperandType.InlineSig:
			case System.Reflection.Emit.OperandType.InlineString:
			case System.Reflection.Emit.OperandType.InlineTok:
			case System.Reflection.Emit.OperandType.InlineType:
			case System.Reflection.Emit.OperandType.ShortInlineR:
				num += 4;
				break;
			case System.Reflection.Emit.OperandType.InlineVar:
				num += 2;
				break;
			case System.Reflection.Emit.OperandType.ShortInlineBrTarget:
			case System.Reflection.Emit.OperandType.ShortInlineI:
			case System.Reflection.Emit.OperandType.ShortInlineVar:
				num++;
				break;
			}
			return num;
		}

		public override string ToString()
		{
			string str = "";
			AppendLabel(ref str, this);
			str = str + ": " + opcode.Name;
			if (operand == null)
			{
				return str;
			}
			str += " ";
			switch (opcode.OperandType)
			{
			case System.Reflection.Emit.OperandType.InlineBrTarget:
			case System.Reflection.Emit.OperandType.ShortInlineBrTarget:
				AppendLabel(ref str, operand);
				break;
			case System.Reflection.Emit.OperandType.InlineSwitch:
			{
				ILInstruction[] array = (ILInstruction[])operand;
				for (int i = 0; i < array.Length; i++)
				{
					if (i > 0)
					{
						str += ",";
					}
					AppendLabel(ref str, array[i]);
				}
				break;
			}
			case System.Reflection.Emit.OperandType.InlineString:
				str += $"\"{operand}\"";
				break;
			default:
				str += operand;
				break;
			}
			return str;
		}

		private static void AppendLabel(ref string str, object argument)
		{
			ILInstruction iLInstruction = argument as ILInstruction;
			str += $"IL_{iLInstruction?.offset.ToString("X4") ?? argument}";
		}
	}
	internal static class InlineSignatureParser
	{
		internal static InlineSignature ImportCallSite(Module moduleFrom, byte[] data)
		{
			InlineSignature inlineSignature = new InlineSignature();
			BinaryReader reader;
			using (MemoryStream input = new MemoryStream(data, writable: false))
			{
				reader = new BinaryReader(input);
				try
				{
					ReadMethodSignature(inlineSignature);
					return inlineSignature;
				}
				finally
				{
					if (reader != null)
					{
						((IDisposable)reader).Dispose();
					}
				}
			}
			Type GetTypeDefOrRef()
			{
				uint num3 = ReadCompressedUInt32();
				uint num4 = num3 >> 2;
				return moduleFrom.ResolveType((num3 & 3) switch
				{
					0u => (int)(0x2000000 | num4), 
					1u => (int)(0x1000000 | num4), 
					2u => (int)(0x1B000000 | num4), 
					_ => 0, 
				});
			}
			int ReadCompressedInt32()
			{
				byte b = reader.ReadByte();
				reader.BaseStream.Seek(-1L, SeekOrigin.Current);
				int num = (int)ReadCompressedUInt32();
				int num2 = num >> 1;
				if ((num & 1) == 0)
				{
					return num2;
				}
				switch (b & 0xC0)
				{
				case 0:
				case 64:
					return num2 - 64;
				case 128:
					return num2 - 8192;
				default:
					return num2 - 268435456;
				}
			}
			uint ReadCompressedUInt32()
			{
				byte b2 = reader.ReadByte();
				if ((b2 & 0x80) == 0)
				{
					return b2;
				}
				if ((b2 & 0x40) == 0)
				{
					return (uint)(((b2 & -129) << 8) | reader.ReadByte());
				}
				return (uint)(((b2 & -193) << 24) | (reader.ReadByte() << 16) | (reader.ReadByte() << 8) | reader.ReadByte());
			}
			void ReadMethodSignature(InlineSignature method)
			{
				byte b3 = reader.ReadByte();
				if ((b3 & 0x20u) != 0)
				{
					method.HasThis = true;
					b3 = (byte)(b3 & 0xFFFFFFDFu);
				}
				if ((b3 & 0x40u) != 0)
				{
					method.ExplicitThis = true;
					b3 = (byte)(b3 & 0xFFFFFFBFu);
				}
				method.CallingConvention = (CallingConvention)(b3 + 1);
				if ((b3 & 0x10u) != 0)
				{
					ReadCompressedUInt32();
				}
				uint num7 = ReadCompressedUInt32();
				method.ReturnType = ReadTypeSignature();
				for (int k = 0; k < num7; k++)
				{
					method.Parameters.Add(ReadTypeSignature());
				}
			}
			object ReadTypeSignature()
			{
				MetadataType metadataType = (MetadataType)reader.ReadByte();
				switch (metadataType)
				{
				case MetadataType.ValueType:
				case MetadataType.Class:
					return GetTypeDefOrRef();
				case MetadataType.Pointer:
					return ((Type)ReadTypeSignature()).MakePointerType();
				case MetadataType.FunctionPointer:
				{
					InlineSignature inlineSignature2 = new InlineSignature();
					ReadMethodSignature(inlineSignature2);
					return inlineSignature2;
				}
				case MetadataType.ByReference:
					return ((Type)ReadTypeSignature()).MakePointerType();
				case (MetadataType)29:
					return ((Type)ReadTypeSignature()).MakeArrayType();
				case MetadataType.Array:
				{
					Type type = (Type)ReadTypeSignature();
					uint rank = ReadCompressedUInt32();
					uint num5 = ReadCompressedUInt32();
					for (int i = 0; i < num5; i++)
					{
						ReadCompressedUInt32();
					}
					uint num6 = ReadCompressedUInt32();
					for (int j = 0; j < num6; j++)
					{
						ReadCompressedInt32();
					}
					return type.MakeArrayType((int)rank);
				}
				case MetadataType.OptionalModifier:
					return new InlineSignature.ModifierType
					{
						IsOptional = true,
						Modifier = GetTypeDefOrRef(),
						Type = ReadTypeSignature()
					};
				case MetadataType.RequiredModifier:
					return new InlineSignature.ModifierType
					{
						IsOptional = false,
						Modifier = GetTypeDefOrRef(),
						Type = ReadTypeSignature()
					};
				case MetadataType.Var:
				case MetadataType.MVar:
					throw new NotSupportedException($"Unsupported generic callsite element: {metadataType}");
				case MetadataType.GenericInstance:
				{
					reader.ReadByte();
					Type typeDefOrRef = GetTypeDefOrRef();
					int count = (int)ReadCompressedUInt32();
					return typeDefOrRef.MakeGenericType((from _ in Enumerable.Range(0, count)
						select (Type)ReadTypeSignature()).ToArray());
				}
				case MetadataType.Object:
					return typeof(object);
				case MetadataType.Void:
					return typeof(void);
				case MetadataType.TypedByReference:
					return typeof(TypedReference);
				case MetadataType.IntPtr:
					return typeof(IntPtr);
				case MetadataType.UIntPtr:
					return typeof(UIntPtr);
				case MetadataType.Boolean:
					return typeof(bool);
				case MetadataType.Char:
					return typeof(char);
				case MetadataType.SByte:
					return typeof(sbyte);
				case MetadataType.Byte:
					return typeof(byte);
				case MetadataType.Int16:
					return typeof(short);
				case MetadataType.UInt16:
					return typeof(ushort);
				case MetadataType.Int32:
					return typeof(int);
				case MetadataType.UInt32:
					return typeof(uint);
				case MetadataType.Int64:
					return typeof(long);
				case MetadataType.UInt64:
					return typeof(ulong);
				case MetadataType.Single:
					return typeof(float);
				case MetadataType.Double:
					return typeof(double);
				case MetadataType.String:
					return typeof(string);
				default:
					throw new NotSupportedException($"Unsupported callsite element: {metadataType}");
				}
			}
		}
	}
	internal class MethodCopier
	{
		private readonly MethodBodyReader reader;

		private readonly List<MethodInfo> transpilers = new List<MethodInfo>();

		internal MethodCopier(MethodBase fromMethod, ILGenerator toILGenerator, LocalBuilder[] existingVariables = null)
		{
			if ((object)fromMethod == null)
			{
				throw new ArgumentNullException("fromMethod");
			}
			reader = new MethodBodyReader(fromMethod, toILGenerator);
			reader.DeclareVariables(existingVariables);
			reader.GenerateInstructions();
		}

		internal void SetDebugging(bool debug)
		{
			reader.SetDebugging(debug);
		}

		internal void AddTranspiler(MethodInfo transpiler)
		{
			transpilers.Add(transpiler);
		}

		internal List<CodeInstruction> Finalize(Emitter emitter, List<Label> endLabels, out bool hasReturnCode, out bool methodEndsInDeadCode)
		{
			return reader.FinalizeILCodes(emitter, transpilers, endLabels, out hasReturnCode, out methodEndsInDeadCode);
		}

		internal static List<CodeInstruction> GetInstructions(ILGenerator generator, MethodBase method, int maxTranspilers)
		{
			if (generator == null)
			{
				throw new ArgumentNullException("generator");
			}
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			LocalBuilder[] existingVariables = MethodPatcher.DeclareOriginalLocalVariables(generator, method);
			MethodCopier methodCopier = new MethodCopier(method, generator, existingVariables);
			Patches patchInfo = Harmony.GetPatchInfo(method);
			if (patchInfo != null)
			{
				List<MethodInfo> sortedPatchMethods = PatchFunctions.GetSortedPatchMethods(method, patchInfo.Transpilers.ToArray(), debug: false);
				for (int i = 0; i < maxTranspilers && i < sortedPatchMethods.Count; i++)
				{
					methodCopier.AddTranspiler(sortedPatchMethods[i]);
				}
			}
			bool hasReturnCode;
			bool methodEndsInDeadCode;
			return methodCopier.Finalize(null, null, out hasReturnCode, out methodEndsInDeadCode);
		}
	}
	internal class MethodBodyReader
	{
		private class ThisParameter : ParameterInfo
		{
			internal ThisParameter(MethodBase method)
			{
				MemberImpl = method;
				ClassImpl = method.DeclaringType;
				NameImpl = "this";
				PositionImpl = -1;
			}
		}

		private readonly ILGenerator generator;

		private readonly MethodBase method;

		private bool debug;

		private readonly Module module;

		private readonly Type[] typeArguments;

		private readonly Type[] methodArguments;

		private readonly ByteBuffer ilBytes;

		private readonly ParameterInfo this_parameter;

		private readonly ParameterInfo[] parameters;

		private readonly IList<ExceptionHandlingClause> exceptions;

		private readonly List<ILInstruction> ilInstructions;

		private readonly List<LocalVariableInfo> localVariables;

		private LocalBuilder[] variables;

		private static readonly Dictionary<System.Reflection.Emit.OpCode, System.Reflection.Emit.OpCode> shortJumps;

		private static readonly System.Reflection.Emit.OpCode[] one_byte_opcodes;

		private static readonly System.Reflection.Emit.OpCode[] two_bytes_opcodes;

		internal static List<ILInstruction> GetInstructions(ILGenerator generator, MethodBase method)
		{
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			MethodBodyReader methodBodyReader = new MethodBodyReader(method, generator);
			methodBodyReader.DeclareVariables(null);
			methodBodyReader.GenerateInstructions();
			return methodBodyReader.ilInstructions;
		}

		internal MethodBodyReader(MethodBase method, ILGenerator generator)
		{
			this.generator = generator;
			this.method = method;
			module = method.Module;
			System.Reflection.MethodBody methodBody = method.GetMethodBody();
			if ((methodBody?.GetILAsByteArray()?.Length).GetValueOrDefault() == 0)
			{
				ilBytes = new ByteBuffer(new byte[0]);
				ilInstructions = new List<ILInstruction>();
			}
			else
			{
				byte[] iLAsByteArray = methodBody.GetILAsByteArray();
				if (iLAsByteArray == null)
				{
					throw new ArgumentException("Can not get IL bytes of method " + method.FullDescription());
				}
				ilBytes = new ByteBuffer(iLAsByteArray);
				ilInstructions = new List<ILInstruction>((iLAsByteArray.Length + 1) / 2);
			}
			Type declaringType = method.DeclaringType;
			if ((object)declaringType != null && declaringType.IsGenericType)
			{
				try
				{
					typeArguments = declaringType.GetGenericArguments();
				}
				catch
				{
					typeArguments = null;
				}
			}
			if (method.IsGenericMethod)
			{
				try
				{
					methodArguments = method.GetGenericArguments();
				}
				catch
				{
					methodArguments = null;
				}
			}
			if (!method.IsStatic)
			{
				this_parameter = new ThisParameter(method);
			}
			parameters = method.GetParameters();
			localVariables = methodBody?.LocalVariables?.ToList() ?? new List<LocalVariableInfo>();
			exceptions = methodBody?.ExceptionHandlingClauses ?? new List<ExceptionHandlingClause>();
		}

		internal void SetDebugging(bool debug)
		{
			this.debug = debug;
		}

		internal void GenerateInstructions()
		{
			while (ilBytes.position < ilBytes.buffer.Length)
			{
				int position = ilBytes.position;
				ILInstruction iLInstruction = new ILInstruction(ReadOpCode())
				{
					offset = position
				};
				ReadOperand(iLInstruction);
				ilInstructions.Add(iLInstruction);
			}
			HandleNativeMethod();
			ResolveBranches();
			ParseExceptions();
		}

		internal void HandleNativeMethod()
		{
			if (!(method is MethodInfo methodInfo))
			{
				return;
			}
			DllImportAttribute dllImportAttribute = methodInfo.GetCustomAttributes(inherit: false).OfType<DllImportAttribute>().FirstOrDefault();
			if (dllImportAttribute != null)
			{
				string assemblyName = (methodInfo.DeclaringType?.FullName ?? "").Replace(".", "_") + "_" + methodInfo.Name;
				AssemblyName assemblyName2 = new AssemblyName(assemblyName);
				AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName2, AssemblyBuilderAccess.Run);
				ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName2.Name);
				TypeBuilder typeBuilder = moduleBuilder.DefineType("NativeMethodHolder", System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.UnicodeClass);
				MethodBuilder methodBuilder = typeBuilder.DefinePInvokeMethod(methodInfo.Name, dllImportAttribute.Value, System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Static | System.Reflection.MethodAttributes.PinvokeImpl, CallingConventions.Standard, methodInfo.ReturnType, (from x in methodInfo.GetParameters()
					select x.ParameterType).ToArray(), dllImportAttribute.CallingConvention, dllImportAttribute.CharSet);
				methodBuilder.SetImplementationFlags(methodBuilder.GetMethodImplementationFlags() | System.Reflection.MethodImplAttributes.PreserveSig);
				Type type = typeBuilder.CreateType();
				MethodInfo operand = type.GetMethod(methodInfo.Name);
				int num = method.GetParameters().Length;
				for (int i = 0; i < num; i++)
				{
					ilInstructions.Add(new ILInstruction(System.Reflection.Emit.OpCodes.Ldarg, i)
					{
						offset = 0
					});
				}
				ilInstructions.Add(new ILInstruction(System.Reflection.Emit.OpCodes.Call, operand)
				{
					offset = num
				});
				ilInstructions.Add(new ILInstruction(System.Reflection.Emit.OpCodes.Ret)
				{
					offset = num + 5
				});
			}
		}

		internal void DeclareVariables(LocalBuilder[] existingVariables)
		{
			if (generator == null)
			{
				return;
			}
			if (existingVariables != null)
			{
				variables = existingVariables;
				return;
			}
			variables = localVariables.Select((LocalVariableInfo lvi) => generator.DeclareLocal(lvi.LocalType, lvi.IsPinned)).ToArray();
		}

		private void ResolveBranches()
		{
			foreach (ILInstruction ilInstruction in ilInstructions)
			{
				switch (ilInstruction.opcode.OperandType)
				{
				case System.Reflection.Emit.OperandType.InlineBrTarget:
				case System.Reflection.Emit.OperandType.ShortInlineBrTarget:
					ilInstruction.operand = GetInstruction((int)ilInstruction.operand, isEndOfInstruction: false);
					break;
				case System.Reflection.Emit.OperandType.InlineSwitch:
				{
					int[] array = (int[])ilInstruction.operand;
					ILInstruction[] array2 = new ILInstruction[array.Length];
					for (int i = 0; i < array.Length; i++)
					{
						array2[i] = GetInstruction(array[i], isEndOfInstruction: false);
					}
					ilInstruction.operand = array2;
					break;
				}
				}
			}
		}

		private void ParseExceptions()
		{
			foreach (ExceptionHandlingClause exception in exceptions)
			{
				int tryOffset = exception.TryOffset;
				int handlerOffset = exception.HandlerOffset;
				int offset = exception.HandlerOffset + exception.HandlerLength - 1;
				ILInstruction instruction = GetInstruction(tryOffset, isEndOfInstruction: false);
				instruction.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock));
				ILInstruction instruction2 = GetInstruction(offset, isEndOfInstruction: true);
				instruction2.blocks.Add(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));
				switch (exception.Flags)
				{
				case ExceptionHandlingClauseOptions.Filter:
				{
					ILInstruction instruction6 = GetInstruction(exception.FilterOffset, isEndOfInstruction: false);
					instruction6.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptFilterBlock));
					break;
				}
				case ExceptionHandlingClauseOptions.Finally:
				{
					ILInstruction instruction5 = GetInstruction(handlerOffset, isEndOfInstruction: false);
					instruction5.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFinallyBlock));
					break;
				}
				case ExceptionHandlingClauseOptions.Clause:
				{
					ILInstruction instruction4 = GetInstruction(handlerOffset, isEndOfInstruction: false);
					instruction4.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock, exception.CatchType));
					break;
				}
				case ExceptionHandlingClauseOptions.Fault:
				{
					ILInstruction instruction3 = GetInstruction(handlerOffset, isEndOfInstruction: false);
					instruction3.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFaultBlock));
					break;
				}
				}
			}
		}

		private bool EndsInDeadCode(List<CodeInstruction> list)
		{
			int count = list.Count;
			if (count < 2 || list.Last().opcode != System.Reflection.Emit.OpCodes.Throw)
			{
				return false;
			}
			return list.GetRange(0, count - 1).All((CodeInstruction code) => code.opcode != System.Reflection.Emit.OpCodes.Ret);
		}

		internal List<CodeInstruction> FinalizeILCodes(Emitter emitter, List<MethodInfo> transpilers, List<Label> endLabels, out bool hasReturnCode, out bool methodEndsInDeadCode)
		{
			hasReturnCode = false;
			methodEndsInDeadCode = false;
			if (generator == null)
			{
				return null;
			}
			foreach (ILInstruction ilInstruction in ilInstructions)
			{
				switch (ilInstruction.opcode.OperandType)
				{
				case System.Reflection.Emit.OperandType.InlineSwitch:
					if (ilInstruction.operand is ILInstruction[] array)
					{
						List<Label> list = new List<Label>();
						ILInstruction[] array2 = array;
						foreach (ILInstruction iLInstruction2 in array2)
						{
							Label item = generator.DefineLabel();
							iLInstruction2.labels.Add(item);
							list.Add(item);
						}
						ilInstruction.argument = list.ToArray();
					}
					break;
				case System.Reflection.Emit.OperandType.InlineBrTarget:
				case System.Reflection.Emit.OperandType.ShortInlineBrTarget:
					if (ilInstruction.operand is ILInstruction iLInstruction)
					{
						Label label2 = generator.DefineLabel();
						iLInstruction.labels.Add(label2);
						ilInstruction.argument = label2;
					}
					break;
				}
			}
			CodeTranspiler codeTranspiler = new CodeTranspiler(ilInstructions);
			transpilers.Do(codeTranspiler.Add);
			List<CodeInstruction> result = codeTranspiler.GetResult(generator, method);
			if (emitter == null)
			{
				return result;
			}
			emitter.LogComment("start original");
			if (debug)
			{
				List<string> buffer = FileLog.GetBuffer(clear: true);
				emitter.LogAllLocalVariables();
				FileLog.LogBuffered(buffer);
			}
			hasReturnCode = result.Any((CodeInstruction code) => code.opcode == System.Reflection.Emit.OpCodes.Ret);
			methodEndsInDeadCode = EndsInDeadCode(result);
			while (true)
			{
				CodeInstruction codeInstruction2 = result.LastOrDefault();
				if (codeInstruction2 == null || codeInstruction2.opcode != System.Reflection.Emit.OpCodes.Ret)
				{
					break;
				}
				endLabels.AddRange(codeInstruction2.labels);
				result.RemoveAt(result.Count - 1);
			}
			result.Do(delegate(CodeInstruction codeInstruction)
			{
				codeInstruction.labels.Do(delegate(Label label)
				{
					emitter.MarkLabel(label);
				});
				codeInstruction.blocks.Do(delegate(ExceptionBlock block)
				{
					emitter.MarkBlockBefore(block, out var _);
				});
				System.Reflection.Emit.OpCode opCode = codeInstruction.opcode;
				object obj = codeInstruction.operand;
				if (opCode == System.Reflection.Emit.OpCodes.Ret)
				{
					Label label3 = generator.DefineLabel();
					opCode = System.Reflection.Emit.OpCodes.Br;
					obj = label3;
					endLabels.Add(label3);
				}
				if (shortJumps.TryGetValue(opCode, out var value))
				{
					opCode = value;
				}
				switch (opCode.OperandType)
				{
				case System.Reflection.Emit.OperandType.InlineNone:
					emitter.Emit(opCode);
					break;
				case System.Reflection.Emit.OperandType.InlineSig:
				{
					CecilILGenerator proxiedShim = generator.GetProxiedShim<CecilILGenerator>();
					if (proxiedShim == null)
					{
						throw new NotSupportedException();
					}
					if (obj == null)
					{
						throw new Exception($"Wrong null argument: {codeInstruction}");
					}
					if (!(obj is ICallSiteGenerator))
					{
						throw new Exception($"Wrong Emit argument type {obj.GetType()} in {codeInstruction}");
					}
					emitter.AddInstruction(opCode, obj);
					emitter.LogIL(opCode, obj);
					proxiedShim.Emit(opCode, (ICallSiteGenerator)obj);
					break;
				}
				default:
					if (obj == null)
					{
						throw new Exception($"Wrong null argument: {codeInstruction}");
					}
					emitter.AddInstruction(opCode, obj);
					emitter.LogIL(opCode, obj);
					generator.DynEmit(opCode, obj);
					break;
				}
				codeInstruction.blocks.Do(delegate(ExceptionBlock block)
				{
					emitter.MarkBlockAfter(block);
				});
			});
			emitter.LogComment("end original" + (methodEndsInDeadCode ? " (has dead code end)" : ""));
			return result;
		}

		private static void GetMemberInfoValue(MemberInfo info, out object result)
		{
			result = null;
			switch (info.MemberType)
			{
			case MemberTypes.Constructor:
				result = (ConstructorInfo)info;
				break;
			case MemberTypes.Event:
				result = (EventInfo)info;
				break;
			case MemberTypes.Field:
				result = (FieldInfo)info;
				break;
			case MemberTypes.Method:
				result = (MethodInfo)info;
				break;
			case MemberTypes.TypeInfo:
			case MemberTypes.NestedType:
				result = (Type)info;
				break;
			case MemberTypes.Property:
				result = (PropertyInfo)info;
				break;
			}
		}

		private void ReadOperand(ILInstruction instruction)
		{
			switch (instruction.opcode.OperandType)
			{
			case System.Reflection.Emit.OperandType.InlineNone:
				instruction.argument = null;
				break;
			case System.Reflection.Emit.OperandType.InlineSwitch:
			{
				int num6 = ilBytes.ReadInt32();
				int num7 = ilBytes.position + 4 * num6;
				int[] array3 = new int[num6];
				for (int i = 0; i < num6; i++)
				{
					array3[i] = ilBytes.ReadInt32() + num7;
				}
				instruction.operand = array3;
				break;
			}
			case System.Reflection.Emit.OperandType.ShortInlineBrTarget:
			{
				sbyte b4 = (sbyte)ilBytes.ReadByte();
				instruction.operand = b4 + ilBytes.position;
				break;
			}
			case System.Reflection.Emit.OperandType.InlineBrTarget:
			{
				int num8 = ilBytes.ReadInt32();
				instruction.operand = num8 + ilBytes.position;
				break;
			}
			case System.Reflection.Emit.OperandType.ShortInlineI:
				if (instruction.opcode == System.Reflection.Emit.OpCodes.Ldc_I4_S)
				{
					sbyte b = (sbyte)ilBytes.ReadByte();
					instruction.operand = b;
					instruction.argument = (sbyte)instruction.operand;
				}
				else
				{
					byte b2 = ilBytes.ReadByte();
					instruction.operand = b2;
					instruction.argument = (byte)instruction.operand;
				}
				break;
			case System.Reflection.Emit.OperandType.InlineI:
			{
				int num5 = ilBytes.ReadInt32();
				instruction.operand = num5;
				instruction.argument = (int)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.ShortInlineR:
			{
				float num4 = ilBytes.ReadSingle();
				instruction.operand = num4;
				instruction.argument = (float)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.InlineR:
			{
				double num3 = ilBytes.ReadDouble();
				instruction.operand = num3;
				instruction.argument = (double)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.InlineI8:
			{
				long num2 = ilBytes.ReadInt64();
				instruction.operand = num2;
				instruction.argument = (long)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.InlineSig:
			{
				int metadataToken3 = ilBytes.ReadInt32();
				byte[] data = module.ResolveSignature(metadataToken3);
				instruction.argument = (instruction.operand = InlineSignatureParser.ImportCallSite(module, data));
				break;
			}
			case System.Reflection.Emit.OperandType.InlineString:
			{
				int metadataToken6 = ilBytes.ReadInt32();
				instruction.operand = module.ResolveString(metadataToken6);
				instruction.argument = (string)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.InlineTok:
			{
				int metadataToken5 = ilBytes.ReadInt32();
				instruction.operand = module.ResolveMember(metadataToken5, typeArguments, methodArguments);
				((MemberInfo)instruction.operand).DeclaringType?.FixReflectionCacheAuto();
				GetMemberInfoValue((MemberInfo)instruction.operand, out instruction.argument);
				break;
			}
			case System.Reflection.Emit.OperandType.InlineType:
			{
				int metadataToken4 = ilBytes.ReadInt32();
				instruction.operand = module.ResolveType(metadataToken4, typeArguments, methodArguments);
				((Type)instruction.operand).FixReflectionCacheAuto();
				instruction.argument = (Type)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.InlineMethod:
			{
				int metadataToken2 = ilBytes.ReadInt32();
				instruction.operand = module.ResolveMethod(metadataToken2, typeArguments, methodArguments);
				((MemberInfo)instruction.operand).DeclaringType?.FixReflectionCacheAuto();
				if (instruction.operand is ConstructorInfo)
				{
					instruction.argument = (ConstructorInfo)instruction.operand;
				}
				else
				{
					instruction.argument = (MethodInfo)instruction.operand;
				}
				break;
			}
			case System.Reflection.Emit.OperandType.InlineField:
			{
				int metadataToken = ilBytes.ReadInt32();
				instruction.operand = module.ResolveField(metadataToken, typeArguments, methodArguments);
				((MemberInfo)instruction.operand).DeclaringType?.FixReflectionCacheAuto();
				instruction.argument = (FieldInfo)instruction.operand;
				break;
			}
			case System.Reflection.Emit.OperandType.ShortInlineVar:
			{
				byte b3 = ilBytes.ReadByte();
				if (TargetsLocalVariable(instruction.opcode))
				{
					LocalVariableInfo localVariable2 = GetLocalVariable(b3);
					if (localVariable2 == null)
					{
						instruction.argument = b3;
						break;
					}
					instruction.operand = localVariable2;
					LocalBuilder[] array2 = variables;
					instruction.argument = ((array2 != null) ? array2[localVariable2.LocalIndex] : null) ?? localVariable2;
				}
				else
				{
					instruction.operand = GetParameter(b3);
					instruction.argument = b3;
				}
				break;
			}
			case System.Reflection.Emit.OperandType.InlineVar:
			{
				short num = ilBytes.ReadInt16();
				if (TargetsLocalVariable(instruction.opcode))
				{
					LocalVariableInfo localVariable = GetLocalVariable(num);
					if (localVariable == null)
					{
						instruction.argument = num;
						break;
					}
					instruction.operand = localVariable;
					LocalBuilder[] array = variables;
					instruction.argument = ((array != null) ? array[localVariable.LocalIndex] : null) ?? localVariable;
				}
				else
				{
					instruction.operand = GetParameter(num);
					instruction.argument = num;
				}
				break;
			}
			default:
				throw new NotSupportedException();
			}
		}

		private ILInstruction GetInstruction(int offset, bool isEndOfInstruction)
		{
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", offset, $"Instruction offset {offset} is less than 0");
			}
			int num = ilInstructions.Count - 1;
			ILInstruction iLInstruction = ilInstructions[num];
			if (offset > iLInstruction.offset + iLInstruction.GetSize() - 1)
			{
				throw new ArgumentOutOfRangeException("offset", offset, $"Instruction offset {offset} is outside valid range 0 - {iLInstruction.offset + iLInstruction.GetSize() - 1}");
			}
			int num2 = 0;
			int num3 = num;
			while (num2 <= num3)
			{
				int num4 = num2 + (num3 - num2) / 2;
				iLInstruction = ilInstructions[num4];
				if (isEndOfInstruction)
				{
					if (offset == iLInstruction.offset + iLInstruction.GetSize() - 1)
					{
						return iLInstruction;
					}
				}
				else if (offset == iLInstruction.offset)
				{
					return iLInstruction;
				}
				if (offset < iLInstruction.offset)
				{
					num3 = num4 - 1;
				}
				else
				{
					num2 = num4 + 1;
				}
			}
			throw new Exception($"Cannot find instruction for {offset:X4}");
		}

		private static bool TargetsLocalVariable(System.Reflection.Emit.OpCode opcode)
		{
			return opcode.Name.Contains("loc");
		}

		private LocalVariableInfo GetLocalVariable(int index)
		{
			return localVariables?[index];
		}

		private ParameterInfo GetParameter(int index)
		{
			if (index == 0)
			{
				return this_parameter;
			}
			return parameters[index - 1];
		}

		private System.Reflection.Emit.OpCode ReadOpCode()
		{
			byte b = ilBytes.ReadByte();
			if (b == 254)
			{
				return two_bytes_opcodes[ilBytes.ReadByte()];
			}
			return one_byte_opcodes[b];
		}

		[MethodImpl(MethodImplOptions.Synchronized)]
		static MethodBodyReader()
		{
			shortJumps = new Dictionary<System.Reflection.Emit.OpCode, System.Reflection.Emit.OpCode>
			{
				{
					System.Reflection.Emit.OpCodes.Leave_S,
					System.Reflection.Emit.OpCodes.Leave
				},
				{
					System.Reflection.Emit.OpCodes.Brfalse_S,
					System.Reflection.Emit.OpCodes.Brfalse
				},
				{
					System.Reflection.Emit.OpCodes.Brtrue_S,
					System.Reflection.Emit.OpCodes.Brtrue
				},
				{
					System.Reflection.Emit.OpCodes.Beq_S,
					System.Reflection.Emit.OpCodes.Beq
				},
				{
					System.Reflection.Emit.OpCodes.Bge_S,
					System.Reflection.Emit.OpCodes.Bge
				},
				{
					System.Reflection.Emit.OpCodes.Bgt_S,
					System.Reflection.Emit.OpCodes.Bgt
				},
				{
					System.Reflection.Emit.OpCodes.Ble_S,
					System.Reflection.Emit.OpCodes.Ble
				},
				{
					System.Reflection.Emit.OpCodes.Blt_S,
					System.Reflection.Emit.OpCodes.Blt
				},
				{
					System.Reflection.Emit.OpCodes.Bne_Un_S,
					System.Reflection.Emit.OpCodes.Bne_Un
				},
				{
					System.Reflection.Emit.OpCodes.Bge_Un_S,
					System.Reflection.Emit.OpCodes.Bge_Un
				},
				{
					System.Reflection.Emit.OpCodes.Bgt_Un_S,
					System.Reflection.Emit.OpCodes.Bgt_Un
				},
				{
					System.Reflection.Emit.OpCodes.Ble_Un_S,
					System.Reflection.Emit.OpCodes.Ble_Un
				},
				{
					System.Reflection.Emit.OpCodes.Br_S,
					System.Reflection.Emit.OpCodes.Br
				},
				{
					System.Reflection.Emit.OpCodes.Blt_Un_S,
					System.Reflection.Emit.OpCodes.Blt_Un
				}
			};
			one_byte_opcodes = new System.Reflection.Emit.OpCode[225];
			two_bytes_opcodes = new System.Reflection.Emit.OpCode[31];
			FieldInfo[] fields = typeof(System.Reflection.Emit.OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				System.Reflection.Emit.OpCode opCode = (System.Reflection.Emit.OpCode)fieldInfo.GetValue(null);
				if (opCode.OpCodeType != System.Reflection.Emit.OpCodeType.Nternal)
				{
					if (opCode.Size == 1)
					{
						one_byte_opcodes[opCode.Value] = opCode;
					}
					else
					{
						two_bytes_opcodes[opCode.Value & 0xFF] = opCode;
					}
				}
			}
		}
	}
	internal class MethodPatcher
	{
		private const string INSTANCE_PARAM = "__instance";

		private const string ORIGINAL_METHOD_PARAM = "__originalMethod";

		private const string ARGS_ARRAY_VAR = "__args";

		private const string RESULT_VAR = "__result";

		private const string RESULT_REF_VAR = "__resultRef";

		private const string STATE_VAR = "__state";

		private const string EXCEPTION_VAR = "__exception";

		private const string RUN_ORIGINAL_VAR = "__runOriginal";

		private const string PARAM_INDEX_PREFIX = "__";

		private const string INSTANCE_FIELD_PREFIX = "___";

		private readonly bool debug;

		private readonly MethodBase original;

		private readonly MethodBase source;

		private readonly List<MethodInfo> prefixes;

		private readonly List<MethodInfo> postfixes;

		private readonly List<MethodInfo> transpilers;

		private readonly List<MethodInfo> finalizers;

		private readonly int idx;

		private readonly Type returnType;

		private readonly DynamicMethodDefinition patch;

		private readonly ILGenerator il;

		private readonly Emitter emitter;

		private static readonly HashSet<Type> PrimitivesWithObjectTypeCode = new HashSet<Type>
		{
			typeof(IntPtr),
			typeof(UIntPtr),
			typeof(IntPtr),
			typeof(UIntPtr)
		};

		private static readonly MethodInfo m_GetMethodFromHandle1 = typeof(MethodBase).GetMethod("GetMethodFromHandle", new Type[1] { typeof(RuntimeMethodHandle) });

		private static readonly MethodInfo m_GetMethodFromHandle2 = typeof(MethodBase).GetMethod("GetMethodFromHandle", new Type[2]
		{
			typeof(RuntimeMethodHandle),
			typeof(RuntimeTypeHandle)
		});

		internal MethodPatcher(MethodBase original, MethodBase source, List<MethodInfo> prefixes, List<MethodInfo> postfixes, List<MethodInfo> transpilers, List<MethodInfo> finalizers, bool debug)
		{
			if ((object)original == null)
			{
				throw new ArgumentNullException("original");
			}
			this.debug = debug;
			this.original = original;
			this.source = source;
			this.prefixes = prefixes;
			this.postfixes = postfixes;
			this.transpilers = transpilers;
			this.finalizers = finalizers;
			if (debug)
			{
				FileLog.LogBuffered("### Patch: " + original.FullDescription());
				FileLog.FlushBuffer();
			}
			idx = prefixes.Count + postfixes.Count + finalizers.Count;
			returnType = AccessTools.GetReturnedType(original);
			patch = CreateDynamicMethod(original, $"_Patch{idx}", debug);
			if (patch == null)
			{
				throw new Exception("Could not create replacement method");
			}
			il = patch.GetILGenerator();
			emitter = new Emitter(il, debug);
		}

		internal static IEnumerable<(ParameterInfo info, string realName)> OriginalParameters(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, argumentAttribute.OriginalName ?? p.Name) : (p, baseArgs.GetRealName(p.Name, null) ?? p.Name);
			});
		}

		internal static Dictionary<string, string> RealNames(MethodInfo method)
		{
			return OriginalParameters(method).ToDictionary(((ParameterInfo info, string realName) pair) => pair.info.Name, ((ParameterInfo info, string realName) pair) => pair.realName);
		}

		internal MethodInfo CreateReplacement(out Dictionary<int, CodeInstruction> finalInstructions)
		{
			LocalBuilder[] existingVariables = DeclareOriginalLocalVariables(il, source ?? original);
			Dictionary<string, LocalBuilder> privateVars = new Dictionary<string, LocalBuilder>();
			List<MethodInfo> list = prefixes.Union(postfixes).Union(finalizers).ToList();
			Dictionary<MethodInfo, HashSet<(ParameterInfo info, string realName)>> parameterNames = list.ToDictionary((MethodInfo fix) => fix, (MethodInfo fix) => new HashSet<(ParameterInfo, string)>(OriginalParameters(fix)));
			LocalBuilder localBuilder = null;
			if (idx > 0)
			{
				localBuilder = DeclareLocalVariable(returnType, isReturnValue: true);
				privateVars["__result"] = localBuilder;
			}
			if (list.Any((MethodInfo fix) => parameterNames[fix].Any(((ParameterInfo info, string realName) pair) => pair.realName == "__resultRef")) && returnType.IsByRef)
			{
				LocalBuilder localBuilder2 = il.DeclareLocal(typeof(RefResult<>).MakeGenericType(returnType.GetElementType()));
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldnull);
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder2);
				privateVars["__resultRef"] = localBuilder2;
			}
			LocalBuilder localBuilder3 = null;
			if (list.Any((MethodInfo fix) => parameterNames[fix].Any(((ParameterInfo info, string realName) pair) => pair.realName == "__args")))
			{
				PrepareArgumentArray();
				localBuilder3 = il.DeclareLocal(typeof(object[]));
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder3);
				privateVars["__args"] = localBuilder3;
			}
			Label? label = null;
			LocalBuilder localBuilder4 = null;
			bool flag = prefixes.Any(PrefixAffectsOriginal);
			bool flag2 = list.Any((MethodInfo fix) => parameterNames[fix].Any(((ParameterInfo info, string realName) pair) => pair.realName == "__runOriginal"));
			if (flag || flag2)
			{
				localBuilder4 = DeclareLocalVariable(typeof(bool));
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder4);
				if (flag)
				{
					label = il.DefineLabel();
				}
			}
			list.ForEach(delegate(MethodInfo fix)
			{
				if ((object)fix.DeclaringType != null && !privateVars.ContainsKey(fix.DeclaringType.AssemblyQualifiedName))
				{
					(from pair in parameterNames[fix]
						where pair.realName == "__state"
						select pair.info).Do(delegate(ParameterInfo patchParam)
					{
						LocalBuilder value = DeclareLocalVariable(patchParam.ParameterType);
						privateVars[fix.DeclaringType.AssemblyQualifiedName] = value;
					});
				}
			});
			LocalBuilder local = null;
			if (finalizers.Count > 0)
			{
				local = DeclareLocalVariable(typeof(bool));
				privateVars["__exception"] = DeclareLocalVariable(typeof(Exception));
				emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock), out var _);
			}
			AddPrefixes(privateVars, localBuilder4);
			if (label.HasValue)
			{
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, localBuilder4);
				emitter.Emit(System.Reflection.Emit.OpCodes.Brfalse, label.Value);
			}
			MethodCopier methodCopier = new MethodCopier(source ?? original, il, existingVariables);
			methodCopier.SetDebugging(debug);
			foreach (MethodInfo transpiler in transpilers)
			{
				methodCopier.AddTranspiler(transpiler);
			}
			methodCopier.AddTranspiler(PatchTools.m_GetExecutingAssemblyReplacementTranspiler);
			List<Label> list2 = new List<Label>();
			methodCopier.Finalize(emitter, list2, out var hasReturnCode, out var methodEndsInDeadCode);
			foreach (Label item in list2)
			{
				emitter.MarkLabel(item);
			}
			if (localBuilder != null && hasReturnCode)
			{
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder);
			}
			if (label.HasValue)
			{
				emitter.MarkLabel(label.Value);
			}
			AddPostfixes(privateVars, localBuilder4, passthroughPatches: false);
			if (localBuilder != null && (hasReturnCode || (methodEndsInDeadCode && label.HasValue)))
			{
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, localBuilder);
			}
			bool flag3 = AddPostfixes(privateVars, localBuilder4, passthroughPatches: true);
			bool flag4 = finalizers.Count > 0;
			if (flag4)
			{
				if (flag3)
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder);
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, localBuilder);
				}
				AddFinalizers(privateVars, localBuilder4, catchExceptions: false);
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, local);
				Label label3 = il.DefineLabel();
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, privateVars["__exception"]);
				emitter.Emit(System.Reflection.Emit.OpCodes.Brfalse, label3);
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, privateVars["__exception"]);
				emitter.Emit(System.Reflection.Emit.OpCodes.Throw);
				emitter.MarkLabel(label3);
				emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock), out var _);
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, privateVars["__exception"]);
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, local);
				Label label5 = il.DefineLabel();
				emitter.Emit(System.Reflection.Emit.OpCodes.Brtrue, label5);
				bool flag5 = AddFinalizers(privateVars, localBuilder4, catchExceptions: true);
				emitter.MarkLabel(label5);
				Label label6 = il.DefineLabel();
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, privateVars["__exception"]);
				emitter.Emit(System.Reflection.Emit.OpCodes.Brfalse, label6);
				if (flag5)
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Rethrow);
				}
				else
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, privateVars["__exception"]);
					emitter.Emit(System.Reflection.Emit.OpCodes.Throw);
				}
				emitter.MarkLabel(label6);
				emitter.MarkBlockAfter(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));
				if (localBuilder != null)
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldloc, localBuilder);
				}
			}
			if (!methodEndsInDeadCode || label.HasValue || flag4 || postfixes.Count > 0)
			{
				emitter.Emit(System.Reflection.Emit.OpCodes.Ret);
			}
			finalInstructions = emitter.GetInstructions();
			if (debug)
			{
				FileLog.LogBuffered("DONE");
				FileLog.LogBuffered("");
				FileLog.FlushBuffer();
			}
			return patch.Generate();
		}

		internal static DynamicMethodDefinition CreateDynamicMethod(MethodBase original, string suffix, bool debug)
		{
			if ((object)original == null)
			{
				throw new ArgumentNullException("original");
			}
			string text = (original.DeclaringType?.FullName ?? "GLOBALTYPE") + "." + original.Name + suffix;
			text = text.Replace("<>", "");
			ParameterInfo[] parameters = original.GetParameters();
			List<Type> list = new List<Type>();
			list.AddRange(parameters.Types());
			if (!original.IsStatic)
			{
				if (AccessTools.IsStruct(original.DeclaringType))
				{
					list.Insert(0, original.DeclaringType.MakeByRefType());
				}
				else
				{
					list.Insert(0, original.DeclaringType);
				}
			}
			Type returnedType = AccessTools.GetReturnedType(original);
			DynamicMethodDefinition dynamicMethodDefinition = new DynamicMethodDefinition(text, returnedType, list.ToArray());
			int num = ((!original.IsStatic) ? 1 : 0);
			if (!original.IsStatic)
			{
				dynamicMethodDefinition.Definition.Parameters[0].Name = "this";
			}
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterDefinition parameterDefinition = dynamicMethodDefinition.Definition.Parameters[i + num];
				parameterDefinition.Attributes = (Mono.Cecil.ParameterAttributes)parameters[i].Attributes;
				parameterDefinition.Name = parameters[i].Name;
			}
			if (debug)
			{
				List<string> list2 = list.Select((Type p) => p.FullDescription()).ToList();
				if (list.Count == dynamicMethodDefinition.Definition.Parameters.Count)
				{
					for (int j = 0; j < list.Count; j++)
					{
						List<string> list3 = list2;
						int index = j;
						list3[index] = list3[index] + " " + dynamicMethodDefinition.Definition.Parameters[j].Name;
					}
				}
				FileLog.Log($"### Replacement: static {returnedType.FullDescription()} {original.DeclaringType?.FullName ?? "GLOBALTYPE"}::{text}({list2.Join()})");
			}
			return dynamicMethodDefinition;
		}

		internal static LocalBuilder[] DeclareOriginalLocalVariables(ILGenerator il, MethodBase member)
		{
			IList<LocalVariableInfo> list = member.GetMethodBody()?.LocalVariables;
			if (list == null)
			{
				return new LocalBuilder[0];
			}
			return list.Select((LocalVariableInfo lvi) => il.DeclareLocal(lvi.LocalType, lvi.IsPinned)).ToArray();
		}

		private LocalBuilder DeclareLocalVariable(Type type, bool isReturnValue = false)
		{
			if (type.IsByRef)
			{
				if (isReturnValue)
				{
					LocalBuilder localBuilder = il.DeclareLocal(type);
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
					emitter.Emit(System.Reflection.Emit.OpCodes.Newarr, type.GetElementType());
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldelema, type.GetElementType());
					emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder);
					return localBuilder;
				}
				type = type.GetElementType();
			}
			if (type.IsEnum)
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (AccessTools.IsClass(type))
			{
				LocalBuilder localBuilder2 = il.DeclareLocal(type);
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldnull);
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder2);
				return localBuilder2;
			}
			if (AccessTools.IsStruct(type))
			{
				LocalBuilder localBuilder3 = il.DeclareLocal(type);
				emitter.Emit(System.Reflection.Emit.OpCodes.Ldloca, localBuilder3);
				emitter.Emit(System.Reflection.Emit.OpCodes.Initobj, type);
				return localBuilder3;
			}
			if (AccessTools.IsValue(type))
			{
				LocalBuilder localBuilder4 = il.DeclareLocal(type);
				if ((object)type == typeof(float))
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_R4, 0f);
				}
				else if ((object)type == typeof(double))
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0);
				}
				else if ((object)type == typeof(long) || (object)type == typeof(ulong))
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_I8, 0L);
				}
				else
				{
					emitter.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, 0);
				}
				emitter.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder4);
				return localBuilder4;
			}
			return null;
		}

		private static System.Reflection.Emit.OpCode LoadIndOpCodeFor(Type type)
		{
			if (PrimitivesWithObjectTypeCode.Contains(type))
			{
				return System.Reflection.Emit.OpCodes.Ldind_I;
			}
			switch (Type.GetTypeCode(type))
			{
			case TypeCode.Boolean:
			case TypeCode.SByte:
			case TypeCode.Byte:
				return System.Reflection.Emit.OpCodes.Ldind_I1;
			case TypeCode.Char:
			case TypeCode.Int16:
			case TypeCode.UInt16:
				return System.Reflection.Emit.OpCodes.Ldind_I2;
			case TypeCode.Int32:
			case TypeCode.UInt32:
				return System.Reflection.Emit.OpCodes.Ldind_I4;
			case TypeCode.Int64:
			case TypeCode.UInt64:
				return System.Reflection.Emit.OpCodes.Ldind_I8;
			case TypeCode.Single:
				return System.Reflection.Emit.OpCodes.Ldind_R4;
			case TypeCode.Double:
				return System.Reflection.Emit.OpCodes.Ldind_R8;
			case TypeCode.Decimal:
			case TypeCode.DateTime:
				throw new NotSupportedException();
			case TypeCode.Empty:
			case TypeCode.Object:
			case TypeCode.DBNull:
			case TypeCode.String:
				return System.Reflection.Emit.OpCodes.Ldind_Ref;
			default:
				return System.Reflection.Emit.OpCodes.Ldind_Ref;
			}
		}

		private static System.Reflection.Emit.OpCode StoreIndOpCodeFor(Type type)
		{
			if (PrimitivesWithObjectTypeCode.Contains(type))
			{
				return System.Reflection.Emit.OpCodes.Stind_I;
			}
			switch (Type.GetTypeCode(type))
			{
			case TypeCode.Boolean:
			case TypeCode.SByte:
			case TypeCode.Byte:
				return System.Reflection.Emit.OpCodes.Stind_I1;
			case TypeCode.Char:
			case TypeCode.Int16:
			case TypeCode.UInt16:
				return System.Reflection.Emit.OpCodes.Stind_I2;
			case TypeCode.Int32:
			case TypeCode.UInt32:
				return System.Reflection.Emit.OpCodes.Stind_I4;
			case TypeCode.Int64:
			case TypeCode.UInt64:
				return System.Reflection.Emit.OpCodes.Stind_I8;
			case TypeCode.Single:
				return System.Reflection.Emit.OpCodes.Stind_R4;
			case TypeCode.Double:
				return System.Reflection.Emit.OpCodes.Stind_R8;
			case TypeCode.Decimal:
			case TypeCode.DateTime:
				throw new NotSupportedException();
			case TypeCode.Empty:
			case TypeCode.Object:
			case TypeCode.DBNull:
			case