using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DolfeLive")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("An extension to Harmony aiming to create a Mixin like patching system via attributes")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+ab8158bec05765c2649cfb5066ece72a8bd8b76b")]
[assembly: AssemblyProduct("Harmony.PatchExtensions")]
[assembly: AssemblyTitle("Harmony.PatchExtensions")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/UltraModding/Harmony.PatchExtensions/tree/master")]
[assembly: AssemblyVersion("1.3.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace HarmonyLib.PatchExtensions
{
	internal static class ConflictResolver
	{
		public static void DetectPatchConflicts(Dictionary<MethodInfo, List<QueuedPatch>> patches, HashSet<MethodInfo> toRemove)
		{
			foreach (KeyValuePair<MethodInfo, List<QueuedPatch>> item in patches.Where<KeyValuePair<MethodInfo, List<QueuedPatch>>>((KeyValuePair<MethodInfo, List<QueuedPatch>> group) => group.Value.Count > 1))
			{
				LogConflict(item.Key, item.Value.Select((QueuedPatch p) => p.HarmonyMethod.method));
				switch (MixinLoader.ConflictResolutionMethod)
				{
				case MixinLoader.ConflictResolver.SkipConflicts:
					toRemove.Add(item.Key);
					break;
				case MixinLoader.ConflictResolver.Error:
					toRemove.Add(item.Key);
					throw new InvalidOperationException($"Conflict detected: {item.Value.Count} patches target {item.Key.Name}");
				}
			}
		}

		public static void DetectTranspilerConflicts(Dictionary<MethodBase, List<TranspilerConfig>> transpilers, HashSet<MethodBase> toRemove)
		{
			foreach (KeyValuePair<MethodBase, List<TranspilerConfig>> transpiler in transpilers)
			{
				MethodBase key = transpiler.Key;
				List<TranspilerConfig> value = transpiler.Value;
				IEnumerable<IGrouping<(string, uint, uint), TranspilerConfig>> source = from t in value
					group t by (TargetMember: t.TargetMember, StartIndex: t.StartIndex, Occurrence: t.Occurrence);
				foreach (IGrouping<(string, uint, uint), TranspilerConfig> item in source.Where((IGrouping<(string TargetMember, uint StartIndex, uint Occurrence), TranspilerConfig> grouping) => grouping.Count() > 1))
				{
					if (item.Count(delegate(TranspilerConfig transpilerConfig)
					{
						AT type = transpilerConfig.Type;
						return (type == AT.RETURN || type == AT.REDIRECT) ? true : false;
					}) > 1)
					{
						LogConflict(key, item.Select((TranspilerConfig transpilerConfig) => transpilerConfig.PatchMethod));
						switch (MixinLoader.ConflictResolutionMethod)
						{
						case MixinLoader.ConflictResolver.SkipConflicts:
							toRemove.Add(key);
							break;
						case MixinLoader.ConflictResolver.Error:
							toRemove.Add(key);
							throw new InvalidOperationException($"Conflict detected: {item.Count()} transpiler patches target {key.Name} at {item.Key}");
						}
					}
				}
			}
		}

		private static void LogConflict(MethodBase targetMethod, IEnumerable<MethodInfo> patchMethods)
		{
			Logger.LogWarning("Multiple Mixins queued for " + targetMethod.DeclaringType?.FullName + "." + targetMethod.Name);
			foreach (MethodInfo patchMethod in patchMethods)
			{
				string value = string.Join(", ", from p in patchMethod.GetParameters()
					select p.ParameterType.Name + " " + p.Name + (p.HasDefaultValue ? $" = {p.DefaultValue}" : ""));
				Logger.LogWarning($"  - {patchMethod.DeclaringType?.FullName}.{patchMethod.Name}({value})");
			}
		}
	}
	public static class Logger
	{
		private static StreamWriter _writer;

		public static string LogPath { get; private set; }

		static Logger()
		{
			LogPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "LogFile.txt");
			Log("Logging to file at: " + LogPath);
			_writer = new StreamWriter(LogPath);
		}

		public static void Log(string log)
		{
			Console.WriteLine("[HarmonyLib.PatchExtensions | Log] " + log);
		}

		public static void LogWarning(string log)
		{
			Console.WriteLine("[HarmonyLib.PatchExtensions | Warning] " + log);
		}

		public static void LogError(string log)
		{
			Console.WriteLine("[HarmonyLib.PatchExtensions | Error] " + log);
		}

		public static void LogFile(string toString)
		{
			_writer.WriteLine(toString);
			_writer.Flush();
		}
	}
	internal static class MixinApplier
	{
		public static void ApplyPatches(Dictionary<MethodInfo, List<QueuedPatch>> _queuedPatches, Harmony harmony, ModuleBuilder _moduleBuilder)
		{
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			foreach (KeyValuePair<MethodInfo, List<QueuedPatch>> _queuedPatch in _queuedPatches)
			{
				MethodInfo key = _queuedPatch.Key;
				foreach (QueuedPatch item in _queuedPatch.Value)
				{
					switch (item.Type)
					{
					case AT.HEAD:
						if (item.Overwriting && item.PatchMethod.ReturnType != typeof(bool) && item.PatchMethod.ReturnType != typeof(void))
						{
							if (item.PatchMethod.ReturnType != key.ReturnType)
							{
								Logger.LogError($"Patch {item.PatchMethod.Name} returns {item.PatchMethod.Name}, but target returns {key.ReturnType.Name}. They must match.");
								return;
							}
							Logger.Log($"Using wrapper as the method returns: {item.PatchMethod.ReturnType}");
							MethodInfo methodInfo = BoolLessPrefix(key, item.PatchMethod, _moduleBuilder);
							if (methodInfo == null)
							{
								Logger.LogError("Failed to create wrapper for " + item.PatchMethod.Name);
								break;
							}
							Logger.Log("Applied HEAD (prefix) with wrapper on " + key.Name + " using " + item.HarmonyMethod.methodName);
							harmony.Patch((MethodBase)key, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						}
						else
						{
							harmony.Patch((MethodBase)key, item.HarmonyMethod, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							Logger.Log("Applied HEAD (prefix) on " + key.Name + " using " + item.HarmonyMethod.methodName);
						}
						break;
					case AT.POSTFIX:
						harmony.Patch((MethodBase)key, (HarmonyMethod)null, item.HarmonyMethod, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						Logger.Log("Applied RETURN (postfix) on " + key.Name + " using " + item.HarmonyMethod.methodName);
						break;
					case AT.FINALLY:
					{
						Type returnType = item.PatchMethod.ReturnType;
						if (returnType != typeof(void) && returnType != typeof(Exception))
						{
							Logger.LogError($"Finalizer {item.PatchMethod.Name} must return void or Exception, got {returnType.Name}.");
						}
						else
						{
							harmony.Patch((MethodBase)key, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, item.HarmonyMethod, (HarmonyMethod)null);
							Logger.Log("Applied FINALLY on " + key.Name + " using " + item.HarmonyMethod.methodName);
						}
						break;
					}
					default:
						throw new NotImplementedException($"Have not implemented: {item.Type}");
					}
				}
			}
		}

		private static MethodInfo? BoolLessPrefix(MethodInfo targetMethod, MethodInfo userPatchMethod, ModuleBuilder _moduleBuilder)
		{
			string name = $"MixinWrapper_{userPatchMethod.Name}_{Guid.NewGuid():N}";
			TypeBuilder typeBuilder = _moduleBuilder.DefineType(name, TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed);
			ParameterInfo[] parameters = userPatchMethod.GetParameters();
			Type returnType = targetMethod.ReturnType;
			List<Type> list = parameters.Select((ParameterInfo p) => p.ParameterType).ToList();
			list.Add(returnType.MakeByRefType());
			MethodBuilder methodBuilder = typeBuilder.DefineMethod("Wrapper_" + userPatchMethod.Name, MethodAttributes.Public | MethodAttributes.Static, typeof(bool), list.ToArray());
			for (int num = 0; num < parameters.Length; num++)
			{
				methodBuilder.DefineParameter(num + 1, ParameterAttributes.None, parameters[num].Name);
			}
			methodBuilder.DefineParameter(parameters.Length + 1, ParameterAttributes.Out, "__result");
			ILGenerator iLGenerator = methodBuilder.GetILGenerator();
			LoadArg(iLGenerator, parameters.Length);
			for (int num2 = 0; num2 < parameters.Length; num2++)
			{
				LoadArg(iLGenerator, num2);
			}
			iLGenerator.Emit(OpCodes.Call, userPatchMethod);
			iLGenerator.Emit(OpCodes.Stobj, returnType);
			iLGenerator.Emit(OpCodes.Ldc_I4_0);
			iLGenerator.Emit(OpCodes.Ret);
			Type type = CreateType(typeBuilder);
			return type.GetMethod("Wrapper_" + userPatchMethod.Name);
		}

		private static Type CreateType(TypeBuilder typeBuilder)
		{
			return typeBuilder.CreateTypeInfo().AsType();
		}

		private static void LoadArg(ILGenerator il, int index)
		{
			switch (index)
			{
			case 0:
				il.Emit(OpCodes.Ldarg_0);
				break;
			case 1:
				il.Emit(OpCodes.Ldarg_1);
				break;
			case 2:
				il.Emit(OpCodes.Ldarg_2);
				break;
			case 3:
				il.Emit(OpCodes.Ldarg_3);
				break;
			default:
				il.Emit(OpCodes.Ldarg, index);
				break;
			}
		}
	}
	public static class MixinLoader
	{
		public enum ConflictResolver
		{
			Warn,
			Error,
			SkipConflicts
		}

		public static ConflictResolver ConflictResolutionMethod;

		private static ModuleBuilder _moduleBuilder;

		internal static Dictionary<MethodBase, List<TranspilerConfig>> QueuedTranspilers;

		internal static Dictionary<Assembly, List<TranspilerConfig>> AssemblyTranspilers;

		private static Dictionary<MethodInfo, List<QueuedPatch>> _queuedPatches;

		private static Version LatestBreakingVersion { get; }

		static MixinLoader()
		{
			LatestBreakingVersion = new Version(1, 2, 0);
			ConflictResolutionMethod = ConflictResolver.Warn;
			QueuedTranspilers = new Dictionary<MethodBase, List<TranspilerConfig>>();
			AssemblyTranspilers = new Dictionary<Assembly, List<TranspilerConfig>>();
			_queuedPatches = new Dictionary<MethodInfo, List<QueuedPatch>>();
			AssemblyName name = new AssemblyName("DolfeMixinDynamicAssembly");
			AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
			_moduleBuilder = assemblyBuilder.DefineDynamicModule("MixinWrappers");
		}

		public static void ApplyPatches(Harmony harmony, Assembly assembly)
		{
			WarnOutOfDate();
			ApplyPatches(harmony, assembly, Array.Empty<Type>());
		}

		public static void ApplyPatches(Harmony harmony, Assembly assembly, params Type[] patchTypes)
		{
			WarnOutOfDate();
			HashSet<Type> allowedTypes = ((patchTypes.Length == 0) ? null : new HashSet<Type>(patchTypes));
			ApplyPatches(harmony, assembly, allowedTypes);
		}

		private static void WarnOutOfDate()
		{
			Assembly assembly = new StackTrace().GetFrame(2)?.GetMethod()?.Module.Assembly ?? null;
			if (!(assembly == null))
			{
				AssemblyName assemblyName = assembly.GetReferencedAssemblies().FirstOrDefault((AssemblyName a) => a.Name == Assembly.GetExecutingAssembly().GetName().Name);
				if (assemblyName != null && assemblyName.Version < LatestBreakingVersion)
				{
					Logger.LogError($"{assembly.FullName} is using an outdated version of Harmony.PatchExtensions ({assemblyName.Version}), a breaking update has been introduced since then ({LatestBreakingVersion})");
				}
			}
		}

		private static void ApplyPatches(Harmony harmony, Assembly assembly, HashSet<Type>? allowedTypes)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_0620: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Expected O, but got Unknown
			QueuedTranspilers.Clear();
			_queuedPatches.Clear();
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (allowedTypes != null && !allowedTypes.Contains(type))
				{
					continue;
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					IEnumerable<PatchAttribute> customAttributes = methodInfo.GetCustomAttributes<PatchAttribute>();
					foreach (PatchAttribute item2 in customAttributes)
					{
						if (item2.DoNotPatch)
						{
							Logger.LogWarning(methodInfo.Name + " has attribute errors so it has been skipped");
							continue;
						}
						if (item2.TargetMethod == null)
						{
							Logger.LogWarning("You must set TargetMethod in " + methodInfo.Name + " for the Patch to work");
							continue;
						}
						HarmonyMethod harmonyMethod = new HarmonyMethod(methodInfo);
						QueuedPatch item = new QueuedPatch(harmonyMethod, item2.At, item2.Overwriting, methodInfo);
						switch (item2.At)
						{
						case AT.HEAD:
						case AT.POSTFIX:
						case AT.FINALLY:
							if (!_queuedPatches.ContainsKey(item2.TargetMethod))
							{
								_queuedPatches[item2.TargetMethod] = new List<QueuedPatch>();
							}
							_queuedPatches[item2.TargetMethod].Add(item);
							Logger.Log($"Queueing {item2.At} on {item2.TargetMethod.Name}");
							break;
						case AT.LOOP_BEFORE:
						case AT.LOOP_TOP:
						case AT.LOOP_BOTTOM:
						case AT.LOOP_AFTER:
						case AT.BRANCH_TRUE:
						case AT.BRANCH_FALSE:
							AddTranspiler(QueuedTranspilers, item2.TargetMethod, new TranspilerConfig(item2.At, item2.TargetMember, methodInfo, item2.Occurrence, item2.StartIndex, item2.ArgIndex, item2.TargetType));
							break;
						default:
							if (string.IsNullOrEmpty(item2.TargetMember))
							{
								Logger.LogWarning($"You must set 'targetMember' in {methodInfo.Name} when using AT.{item2.At}");
							}
							else
							{
								AddTranspiler(QueuedTranspilers, item2.TargetMethod, new TranspilerConfig(item2.At, item2.TargetMember, methodInfo, item2.Occurrence, item2.StartIndex, item2.ArgIndex, item2.TargetType));
							}
							break;
						}
					}
					IEnumerable<AssemblyPatchAttribute> customAttributes2 = methodInfo.GetCustomAttributes<AssemblyPatchAttribute>();
					foreach (AssemblyPatchAttribute item3 in customAttributes2)
					{
						if (item3.DoNotPatch)
						{
							Logger.LogWarning(methodInfo.Name + " has attribute errors so it has been skipped");
							continue;
						}
						Assembly assembly2 = item3.TargetType.Assembly;
						if (!AssemblyTranspilers.ContainsKey(assembly2))
						{
							AssemblyTranspilers[assembly2] = new List<TranspilerConfig>();
						}
						AssemblyTranspilers[assembly2].Add(new TranspilerConfig(item3.At, item3.TargetMember, methodInfo, item3.Occurrence, 0u, 0u, item3.TargetType));
					}
				}
			}
			foreach (KeyValuePair<Assembly, List<TranspilerConfig>> assemblyTranspiler in AssemblyTranspilers)
			{
				Assembly key = assemblyTranspiler.Key;
				List<TranspilerConfig> value = assemblyTranspiler.Value;
				foreach (TranspilerConfig item4 in value)
				{
					if (string.IsNullOrEmpty(item4.TargetMember))
					{
						Logger.LogError("TargetMember is null or empty in " + item4.PatchMethod.Name);
						continue;
					}
					FieldInfo target = item4.TargetType?.GetField(item4.TargetMember) ?? throw new InvalidOperationException("TargetType required to resolve field '" + item4.TargetMember + "'");
					IEnumerable<Type> enumerable = ((!(item4.TargetType != null)) ? ((IEnumerable<Type>)key.GetTypes()) : ((IEnumerable<Type>)new Type[1] { item4.TargetType }));
					foreach (Type item5 in enumerable)
					{
						foreach (MethodBase item6 in OpCodeHelper.FindMethodsUsingField(item5, target))
						{
							if (!QueuedTranspilers.ContainsKey(item6))
							{
								QueuedTranspilers[item6] = new List<TranspilerConfig>();
							}
							QueuedTranspilers[item6].Add(new TranspilerConfig(item4.Type, null, item4.PatchMethod, item4.Occurrence, 0u, 0u, item4.TargetType));
						}
					}
				}
			}
			HashSet<MethodInfo> hashSet = new HashSet<MethodInfo>();
			HarmonyLib.PatchExtensions.ConflictResolver.DetectPatchConflicts(_queuedPatches, hashSet);
			foreach (MethodInfo item7 in hashSet)
			{
				_queuedPatches.Remove(item7);
			}
			HashSet<MethodBase> hashSet2 = new HashSet<MethodBase>();
			HarmonyLib.PatchExtensions.ConflictResolver.DetectTranspilerConflicts(QueuedTranspilers, hashSet2);
			foreach (MethodBase item8 in hashSet2)
			{
				QueuedTranspilers.Remove(item8);
			}
			MixinApplier.ApplyPatches(_queuedPatches, harmony, _moduleBuilder);
			HarmonyMethod val = new HarmonyMethod(typeof(TranspilerApplier), "TranspilerPiler", (Type[])null);
			foreach (MethodBase key2 in QueuedTranspilers.Keys)
			{
				try
				{
					Logger.Log("Processing patch for " + key2.Name);
					harmony.Patch(key2, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
					Logger.Log("Processed patch for " + key2.Name);
				}
				catch (Exception ex)
				{
					StackFrame[] frames = new StackTrace().GetFrames();
					string value2 = string.Join(", ", frames.Select((StackFrame _) => $"{_.GetFileName()}:{_.GetFileLineNumber()}"));
					Logger.LogError($"Exception {key2.Name}: {ex.Message}, type: {ex.GetType()}, {value2}");
					Exception ex2 = ex;
					int num = 0;
					while (ex2 != null)
					{
						Logger.LogError($"[{num}] {ex2.GetType()}: {ex2.Message}");
						ex2 = ex2.InnerException;
						num++;
					}
					HarmonyException ex3 = (HarmonyException)(object)((ex is HarmonyException) ? ex : null);
					if (ex3 == null)
					{
						continue;
					}
					foreach (KeyValuePair<int, CodeInstruction> instructionsWithOffset in ex3.GetInstructionsWithOffsets())
					{
						Logger.LogError($"IL[{instructionsWithOffset.Key:X4}] {instructionsWithOffset.Value}");
					}
					Logger.LogError($"ErrorOffset: {ex3.GetErrorOffset()}, ErrorIndex: {ex3.GetErrorIndex()}");
				}
			}
		}

		private static void AddTranspiler<TKey>(Dictionary<TKey, List<TranspilerConfig>> dict, TKey key, TranspilerConfig config)
		{
			if (!dict.TryGetValue(key, out List<TranspilerConfig> value))
			{
				value = (dict[key] = new List<TranspilerConfig>());
			}
			value.Add(config);
		}
	}
	public class OpCodeHelper
	{
		private static readonly HashSet<OpCode> LocalOpcodes = new HashSet<OpCode>
		{
			OpCodes.Ldloc_0,
			OpCodes.Ldloc_1,
			OpCodes.Ldloc_2,
			OpCodes.Ldloc_3,
			OpCodes.Ldloc_S,
			OpCodes.Ldloc,
			OpCodes.Ldloca_S,
			OpCodes.Ldloca,
			OpCodes.Stloc_0,
			OpCodes.Stloc_1,
			OpCodes.Stloc_2,
			OpCodes.Stloc_3,
			OpCodes.Stloc_S,
			OpCodes.Stloc
		};

		private static readonly HashSet<OpCode> ArgLocodes = new HashSet<OpCode>
		{
			OpCodes.Ldarg_0,
			OpCodes.Ldarg_1,
			OpCodes.Ldarg_2,
			OpCodes.Ldarg_3,
			OpCodes.Ldarg,
			OpCodes.Ldarg_S,
			OpCodes.Ldarga,
			OpCodes.Ldarga_S,
			OpCodes.Starg,
			OpCodes.Starg_S
		};

		private static readonly HashSet<OpCode> MethodCallOpcodes = new HashSet<OpCode>
		{
			OpCodes.Call,
			OpCodes.Callvirt,
			OpCodes.Newobj
		};

		private static readonly HashSet<OpCode> FieldOpcodes = new HashSet<OpCode>
		{
			OpCodes.Stfld,
			OpCodes.Ldfld,
			OpCodes.Ldsfld,
			OpCodes.Stsfld,
			OpCodes.Ldflda,
			OpCodes.Ldsflda
		};

		private static readonly HashSet<OpCode> BranchOpcodes = new HashSet<OpCode>
		{
			OpCodes.Brtrue,
			OpCodes.Brtrue_S,
			OpCodes.Brfalse,
			OpCodes.Brfalse_S
		};

		private static readonly HashSet<OpCode> LoopOpcodes = new HashSet<OpCode>
		{
			OpCodes.Br,
			OpCodes.Br_S
		};

		private static readonly HashSet<OpCode> ConditionalOpcodes = new HashSet<OpCode>
		{
			OpCodes.Blt,
			OpCodes.Blt_S,
			OpCodes.Ble,
			OpCodes.Ble_S,
			OpCodes.Bgt,
			OpCodes.Bgt_S,
			OpCodes.Bge,
			OpCodes.Bge_S,
			OpCodes.Brtrue,
			OpCodes.Brtrue_S,
			OpCodes.Brfalse,
			OpCodes.Brfalse_S
		};

		public static bool IsLocalOpcode(OpCode opcode)
		{
			return LocalOpcodes.Contains(opcode);
		}

		public static bool IsArgOpcode(OpCode opcode)
		{
			return ArgLocodes.Contains(opcode);
		}

		public static bool IsMethod(OpCode opcode)
		{
			return MethodCallOpcodes.Contains(opcode);
		}

		public static bool IsField(OpCode opcode)
		{
			return FieldOpcodes.Contains(opcode);
		}

		public static bool IsBranch(OpCode opcode)
		{
			return BranchOpcodes.Contains(opcode);
		}

		public static bool IsLoop(OpCode opcode)
		{
			return LoopOpcodes.Contains(opcode);
		}

		public static bool IsConditional(OpCode opcode)
		{
			return ConditionalOpcodes.Contains(opcode);
		}

		public static bool TryGetLocalIndex(CodeInstruction instruction, out int index, out bool isWrite, out bool isAddress)
		{
			index = -1;
			isWrite = false;
			isAddress = false;
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldloc_0)
			{
				index = 0;
				return true;
			}
			if (opcode == OpCodes.Ldloc_1)
			{
				index = 1;
				return true;
			}
			if (opcode == OpCodes.Ldloc_2)
			{
				index = 2;
				return true;
			}
			if (opcode == OpCodes.Ldloc_3)
			{
				index = 3;
				return true;
			}
			if (opcode == OpCodes.Ldloc_S)
			{
				index = ((LocalBuilder)instruction.operand).LocalIndex;
				return true;
			}
			if (opcode == OpCodes.Ldloc)
			{
				index = ((LocalBuilder)instruction.operand).LocalIndex;
				return true;
			}
			if (opcode == OpCodes.Ldloca_S)
			{
				index = ((LocalBuilder)instruction.operand).LocalIndex;
				isAddress = true;
				return true;
			}
			if (opcode == OpCodes.Ldloca)
			{
				index = ((LocalBuilder)instruction.operand).LocalIndex;
				isAddress = true;
				return true;
			}
			if (opcode == OpCodes.Stloc_0)
			{
				index = 0;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Stloc_1)
			{
				index = 1;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Stloc_2)
			{
				index = 2;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Stloc_3)
			{
				index = 3;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Stloc_S)
			{
				index = ((LocalBuilder)instruction.operand).LocalIndex;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Stloc)
			{
				index = ((LocalBuilder)instruction.operand).LocalIndex;
				isWrite = true;
				return true;
			}
			return false;
		}

		public static bool TryGetArgIndex(CodeInstruction instruction, out int index, out bool isWrite, out bool isAddress)
		{
			index = -1;
			isWrite = false;
			isAddress = false;
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldarg_0)
			{
				index = 0;
				return true;
			}
			if (opcode == OpCodes.Ldarg_1)
			{
				index = 1;
				return true;
			}
			if (opcode == OpCodes.Ldarg_2)
			{
				index = 2;
				return true;
			}
			if (opcode == OpCodes.Ldarg_3)
			{
				index = 3;
				return true;
			}
			if (opcode == OpCodes.Ldarg_S)
			{
				index = (byte)instruction.operand;
				return true;
			}
			if (opcode == OpCodes.Ldarg)
			{
				index = (short)instruction.operand;
				return true;
			}
			if (opcode == OpCodes.Ldarga_S)
			{
				index = (byte)instruction.operand;
				isAddress = true;
				return true;
			}
			if (opcode == OpCodes.Ldarga)
			{
				index = (short)instruction.operand;
				isAddress = true;
				return true;
			}
			if (opcode == OpCodes.Starg_S)
			{
				index = (byte)instruction.operand;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Starg)
			{
				index = (short)instruction.operand;
				isWrite = true;
				return true;
			}
			return false;
		}

		public static bool TryGetFieldInfo(CodeInstruction instruction, out FieldInfo field, out bool isWrite, out bool isAddress, out bool isStatic)
		{
			field = null;
			isWrite = false;
			isAddress = false;
			isStatic = false;
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldfld)
			{
				field = (FieldInfo)instruction.operand;
				return true;
			}
			if (opcode == OpCodes.Ldsfld)
			{
				field = (FieldInfo)instruction.operand;
				isStatic = true;
				return true;
			}
			if (opcode == OpCodes.Ldflda)
			{
				field = (FieldInfo)instruction.operand;
				isAddress = true;
				return true;
			}
			if (opcode == OpCodes.Ldsflda)
			{
				field = (FieldInfo)instruction.operand;
				isAddress = true;
				isStatic = true;
				return true;
			}
			if (opcode == OpCodes.Stfld)
			{
				field = (FieldInfo)instruction.operand;
				isWrite = true;
				return true;
			}
			if (opcode == OpCodes.Stsfld)
			{
				field = (FieldInfo)instruction.operand;
				isWrite = true;
				isStatic = true;
				return true;
			}
			return false;
		}

		public static bool IsLoopEntryBranch(CodeInstruction instruction, List<CodeInstruction> instructions)
		{
			if (IsLoop(instruction.opcode))
			{
				object operand = instruction.operand;
				if (operand is Label)
				{
					Label conditionLabel = (Label)operand;
					int num = instructions.FindIndex((CodeInstruction ci) => ci == instruction);
					int num2 = instructions.FindIndex((CodeInstruction ci) => ci.labels.Contains(conditionLabel));
					if (num == -1 || num2 == -1)
					{
						return false;
					}
					for (int num3 = num2; num3 < instructions.Count; num3++)
					{
						CodeInstruction val = instructions[num3];
						if (IsConditional(val.opcode))
						{
							operand = val.operand;
							if (operand is Label)
							{
								Label bodyLabel = (Label)operand;
								int num4 = instructions.FindIndex((CodeInstruction ci) => ci.labels.Contains(bodyLabel));
								if (num4 != -1)
								{
									return num4 > num;
								}
								return false;
							}
							return false;
						}
						if (val.opcode == OpCodes.Ret || IsLoop(val.opcode))
						{
							return false;
						}
					}
					return false;
				}
			}
			return false;
		}

		public static IEnumerable<MethodBase> FindMethodsUsingField(Type scanType, FieldInfo target)
		{
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			foreach (MethodBase item in scanType.GetMethods(bindingAttr).Cast<MethodBase>().Concat(scanType.GetConstructors(bindingAttr)))
			{
				if (item.IsAbstract || item.ContainsGenericParameters)
				{
					continue;
				}
				MethodBody methodBody = item.GetMethodBody();
				if (methodBody == null)
				{
					continue;
				}
				foreach (CodeInstruction originalInstruction in PatchProcessor.GetOriginalInstructions(item, (ILGenerator)null))
				{
					if (TryGetFieldInfo(originalInstruction, out FieldInfo field, out bool _, out bool _, out bool _) && field == target)
					{
						yield return item;
						break;
					}
				}
			}
		}
	}
	public enum AT
	{
		HEAD,
		RETURN,
		POSTFIX,
		INVOKE,
		REDIRECT,
		AFTER,
		ARG,
		LOOP_BEFORE,
		LOOP_TOP,
		LOOP_BOTTOM,
		LOOP_AFTER,
		FINALLY,
		BRANCH_TRUE,
		BRANCH_FALSE,
		LOCAL_WRITE,
		LOCAL_READ,
		[Obsolete("Not yet implemented")]
		ARG_WRITE,
		[Obsolete("Not yet implemented")]
		ARG_READ,
		[Obsolete("Not yet implemented")]
		FIELD_WRITE,
		[Obsolete("Not yet implemented")]
		FIELD_READ,
		[Obsolete("Not yet implemented")]
		TBD
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
	public class PatchAttribute : Attribute
	{
		internal bool DoNotPatch { get; private set; } = true;

		public MethodInfo? TargetMethod { get; }

		public AT At { get; }

		public string TargetMember { get; }

		public bool Overwriting { get; }

		public uint Occurrence { get; }

		public uint StartIndex { get; }

		public uint ArgIndex { get; }

		public Type? TargetType { get; }

		public PatchAttribute(Type type, string methodName, AT at, string? targetMember = null, Type? targetType = null, uint occurrence = 0u, uint startIndex = 0u, uint argIndex = 0u, bool overwriting = false)
		{
			TargetMethod = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ?? null;
			if (TargetMethod == null)
			{
				Logger.LogError($"Could not find method '{methodName}' in type '{type.FullName}', not running this patch.");
				return;
			}
			bool flag = string.IsNullOrEmpty(targetMember);
			bool flag2 = flag;
			if (flag2)
			{
				flag2 = (((uint)(at - 3) <= 2u || (uint)(at - 14) <= 5u) ? true : false);
			}
			if (flag2)
			{
				Logger.LogError("targetMember is null or empty, not running this patch.");
				return;
			}
			TargetMember = targetMember;
			if (at == AT.ARG && argIndex == 0)
			{
				Logger.LogError("argIndex not set when required for ARG, not running this patch.");
				return;
			}
			ArgIndex = argIndex;
			TargetType = targetType;
			Occurrence = occurrence;
			At = at;
			StartIndex = startIndex;
			if (overwriting && at != AT.HEAD)
			{
				Logger.LogWarning("FYI, overwriting set on a non head AT does nothing");
			}
			Overwriting = overwriting;
			DoNotPatch = false;
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
	public class AssemblyPatchAttribute : Attribute
	{
		public bool DoNotPatch { get; private set; } = true;

		public bool TargetAssembly { get; }

		public Type TargetType { get; }

		public string TargetMember { get; }

		public AT At { get; }

		public bool ScanEntireAssembly { get; }

		public uint Occurrence { get; }

		public AssemblyPatchAttribute(Type? fieldDeclaringType, string fieldName, AT at, bool scanEntireAssembly = false, uint occurrence = 0u)
		{
			DoNotPatch = true;
			TargetAssembly = true;
			TargetType = fieldDeclaringType;
			TargetMember = fieldName;
			At = at;
			ScanEntireAssembly = scanEntireAssembly;
			Occurrence = occurrence;
			if (fieldDeclaringType == null)
			{
				Logger.LogError("fieldDeclaringType is null, not running this patch.");
				return;
			}
			if (string.IsNullOrEmpty(fieldName))
			{
				Logger.LogError("fieldName is null or empty, not running this patch.");
				return;
			}
			if (at != AT.FIELD_READ && at != AT.FIELD_WRITE)
			{
				Logger.LogError($"AssemblyPatchAttribute only supports FIELD_READ/FIELD_WRITE, not {at}.");
			}
			DoNotPatch = false;
		}
	}
	internal class QueuedPatch
	{
		public HarmonyMethod HarmonyMethod;

		public AT Type;

		public bool Overwriting;

		public MethodInfo PatchMethod;

		public QueuedPatch(HarmonyMethod harmonyMethod, AT type, bool overwriting, MethodInfo patchMethod)
		{
			HarmonyMethod = harmonyMethod;
			Type = type;
			Overwriting = overwriting;
			PatchMethod = patchMethod;
		}
	}
	public static class TranspilerApplier
	{
		public static IEnumerable<CodeInstruction> TranspilerPiler(IEnumerable<CodeInstruction> instructions, MethodBase original, ILGenerator generator)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			if (!MixinLoader.QueuedTranspilers.TryGetValue(original, out List<TranspilerConfig> value))
			{
				return instructions;
			}
			CodeMatcher matcher = new CodeMatcher(instructions, generator);
			foreach (TranspilerConfig config in value)
			{
				matcher.Start();
				int num = 0;
				int num2 = 0;
				var (requiredClass, requiredMethod) = GetRequired(config);
				while (true)
				{
					matcher.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instruction) => Matcher(instruction, config, requiredMethod, requiredClass, matcher)), (string)null)
					});
					if (matcher.IsInvalid)
					{
						break;
					}
					num++;
					if (config.StartIndex == 0 || num >= config.StartIndex)
					{
						num2++;
						if (config.Occurrence == 0 || num2 == config.Occurrence)
						{
							switch (config.Type)
							{
							case AT.INVOKE:
								matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
								{
									new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
								});
								break;
							case AT.REDIRECT:
								if (ApplyRedirect(matcher, config))
								{
									continue;
								}
								break;
							case AT.AFTER:
								ApplyAfter(matcher, config, generator);
								break;
							case AT.RETURN:
								ApplyReturn(original, generator, matcher, config);
								break;
							case AT.ARG:
								ApplyArg(matcher, config, generator);
								break;
							case AT.BRANCH_TRUE:
								ApplyBranch(matcher, config, generator, wantTrue: true);
								break;
							case AT.BRANCH_FALSE:
								ApplyBranch(matcher, config, generator, wantTrue: false);
								break;
							case AT.LOOP_BEFORE:
								matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
								{
									new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
								});
								break;
							case AT.LOOP_TOP:
								ApplyLoopTop(matcher, config, generator);
								break;
							case AT.LOOP_BOTTOM:
								ApplyLoopBottom(matcher, config, generator);
								break;
							case AT.LOOP_AFTER:
								ApplyLoopAfter(matcher, config, generator);
								break;
							case AT.LOCAL_READ:
								LocalRead(original, matcher, config, generator);
								break;
							case AT.LOCAL_WRITE:
								LocalWrite(original, matcher, config, generator);
								break;
							case AT.ARG_READ:
								ArgRead(original, matcher, config, generator);
								break;
							case AT.ARG_WRITE:
								ArgWrite(original, matcher, config, generator);
								break;
							case AT.FIELD_READ:
								FieldRead(original, matcher, config, generator);
								break;
							case AT.FIELD_WRITE:
								FieldWrite(original, matcher, config, generator);
								break;
							}
							if (config.Occurrence != 0)
							{
								break;
							}
						}
					}
					matcher.Advance(1);
				}
				Logger.LogFile("-- " + config.PatchMethod.Name + " ---");
				foreach (CodeInstruction item in matcher.Instructions())
				{
					Logger.LogFile($"{item.opcode}   {item.operand}");
				}
			}
			return matcher.InstructionEnumeration();
		}

		private static void ArgWrite(MethodBase original, CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			Dictionary<int, string> dictionary = new Dictionary<int, string>();
			for (int i = 0; i < original.GetParameters().Length; i++)
			{
				ParameterInfo parameterInfo = original.GetParameters()[i];
				dictionary.Add(i, parameterInfo.Name);
			}
			CodeInstruction instruction = matcher.Instruction;
			if (OpCodeHelper.TryGetArgIndex(instruction, out var index, out var isWrite, out var isAddress) && !(!isWrite || isAddress) && dictionary.TryGetValue(index, out var value) && value == config.TargetMember)
			{
				Logger.Log("Writing arg: " + value);
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				});
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static void ArgRead(MethodBase original, CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			Dictionary<int, string> dictionary = new Dictionary<int, string>();
			for (int i = 0; i < original.GetParameters().Length; i++)
			{
				ParameterInfo parameterInfo = original.GetParameters()[i];
				dictionary.Add(i, parameterInfo.Name);
			}
			CodeInstruction instruction = matcher.Instruction;
			if (OpCodeHelper.TryGetArgIndex(instruction, out var index, out var isWrite, out var isAddress) && !(isWrite || isAddress) && dictionary.TryGetValue(index, out var value) && value == config.TargetMember)
			{
				matcher.Advance(1);
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				});
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static void FieldRead(MethodBase original, CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			if (OpCodeHelper.TryGetFieldInfo(instruction, out FieldInfo field, out bool isWrite, out bool isAddress, out bool _) && !(isWrite || isAddress) && field.Name == config.TargetMember && (config.TargetType == null || field.DeclaringType == config.TargetType))
			{
				matcher.Advance(1);
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				});
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static void FieldWrite(MethodBase original, CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			if (OpCodeHelper.TryGetFieldInfo(instruction, out FieldInfo field, out bool isWrite, out bool isAddress, out bool _) && !(!isWrite || isAddress) && field.Name == config.TargetMember && (config.TargetType == null || field.DeclaringType == config.TargetType))
			{
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				});
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static void LocalWrite(MethodBase original, CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			string text = original.DeclaringType?.Assembly.Location;
			if (text == null)
			{
				throw new Exception("Unable to get target Assembly path.");
			}
			ModuleDefinition val = ModuleDefinition.ReadModule(text, new ReaderParameters
			{
				ReadSymbols = true
			});
			MethodDefinition val2 = (MethodDefinition)val.LookupToken(original.MetadataToken);
			Dictionary<int, string> dictionary = new Dictionary<int, string>();
			Enumerator<VariableDebugInformation> enumerator = val2.DebugInformation.Scope.Variables.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					VariableDebugInformation current = enumerator.Current;
					dictionary.Add(current.Index, current.Name);
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			CodeInstruction instruction = matcher.Instruction;
			if (OpCodeHelper.TryGetLocalIndex(instruction, out var index, out var isWrite, out var isAddress) && !(!isWrite || isAddress) && dictionary.TryGetValue(index, out var value) && value == config.TargetMember)
			{
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				});
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static void LocalRead(MethodBase original, CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			string text = original.DeclaringType?.Assembly.Location;
			if (text == null)
			{
				throw new Exception("Unable to get target Assembly path.");
			}
			ModuleDefinition val = ModuleDefinition.ReadModule(text, new ReaderParameters
			{
				ReadSymbols = true
			});
			MethodDefinition val2 = (MethodDefinition)val.LookupToken(original.MetadataToken);
			Dictionary<int, string> dictionary = new Dictionary<int, string>();
			Enumerator<VariableDebugInformation> enumerator = val2.DebugInformation.Scope.Variables.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					VariableDebugInformation current = enumerator.Current;
					dictionary.Add(current.Index, current.Name);
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			CodeInstruction instruction = matcher.Instruction;
			if (OpCodeHelper.TryGetLocalIndex(instruction, out var index, out var isWrite, out var isAddress) && !(isWrite || isAddress) && dictionary.TryGetValue(index, out var value) && value == config.TargetMember)
			{
				matcher.Advance(1);
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				});
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static void ApplyLoopTop(CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			Label conditionLabel = (Label)instruction.operand;
			int pos = matcher.Pos;
			int num = matcher.Instructions().FindIndex((CodeInstruction ci) => ci.labels.Contains(conditionLabel));
			if (num == -1)
			{
				throw new Exception("Could not resolve branch target label.");
			}
			matcher.Advance(num - pos);
			ContinueToConditional(matcher);
			CodeInstruction instruction2 = matcher.Instruction;
			Label bodyLabel = (Label)instruction2.operand;
			int pos2 = matcher.Pos;
			int num2 = matcher.Instructions().FindIndex((CodeInstruction ci) => ci.labels.Contains(bodyLabel));
			if (num2 == -1)
			{
				throw new Exception("Could not resolve loop body label.");
			}
			matcher.Advance(num2 - pos2);
			matcher.Advance(1);
			matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
			});
		}

		private static void ApplyLoopBottom(CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			Label conditionLabel = (Label)instruction.operand;
			int pos = matcher.Pos;
			List<CodeInstruction> list = matcher.Instructions();
			int num = list.FindIndex((CodeInstruction codeInstruction) => codeInstruction.labels.Contains(conditionLabel));
			if (num == -1)
			{
				throw new Exception("Could not resolve branch target label.");
			}
			int num2 = num;
			for (int num3 = pos + 1; num3 < num; num3++)
			{
				if (!OpCodeHelper.IsLoop(list[num3].opcode))
				{
					continue;
				}
				object operand = list[num3].operand;
				if (operand is Label)
				{
					Label continueLabel = (Label)operand;
					int num4 = list.FindIndex((CodeInstruction x) => x.labels.Contains(continueLabel));
					if (num4 > num3 && num4 < num)
					{
						num2 = num4;
						break;
					}
				}
			}
			matcher.Advance(num2 - pos);
			matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
			});
		}

		private static void ApplyLoopAfter(CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			Label conditionLabel = (Label)instruction.operand;
			int pos = matcher.Pos;
			int num = matcher.Instructions().FindIndex((CodeInstruction ci) => ci.labels.Contains(conditionLabel));
			if (num == -1)
			{
				throw new Exception("Could not resolve branch target label.");
			}
			matcher.Advance(num - pos);
			ContinueToConditional(matcher);
			matcher.Advance(1);
			CodeInstruction instruction2 = matcher.Instruction;
			CodeInstruction val = new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
			{
				labels = instruction2.labels
			};
			instruction2.labels = new List<Label>();
			matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { val });
		}

		private static void ContinueToConditional(CodeMatcher matcher)
		{
			int num = 0;
			int count = matcher.Instructions().Count;
			while (!OpCodeHelper.IsConditional(matcher.Instruction.opcode))
			{
				matcher.Advance(1);
				if (++num > count)
				{
					throw new Exception("Failed to resolve loop condition branch.");
				}
			}
		}

		private static void ApplyBranch(CodeMatcher matcher, TranspilerConfig config, ILGenerator generator, bool wantTrue)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			OpCode opCode = (wantTrue ? OpCodes.Brfalse_S : OpCodes.Brtrue_S);
			Label label = generator.DefineLabel();
			matcher.Instruction.labels.Add(label);
			matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Dup, (object)null)
			});
			matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(opCode, (object)label)
			});
			matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
			});
		}

		private static void ApplyArg(CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			if (instruction.operand is MethodInfo methodInfo)
			{
				int num = methodInfo.GetParameters().Length;
				if (config.ArgIndex > num)
				{
					Logger.LogWarning($"ARG ArgIndex '{config.ArgIndex}' is bigger than the args on '{methodInfo.Name}' ({num}). Skipped.");
				}
				else
				{
					int num2 = num - (int)config.ArgIndex;
					matcher.Advance(-num2);
					matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
					});
					matcher.Advance(num2);
				}
			}
		}

		private static void ApplyReturn(MethodBase original, ILGenerator generator, CodeMatcher matcher, TranspilerConfig config)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if (original is MethodInfo methodInfo && methodInfo.ReturnType != typeof(void))
			{
				LocalBuilder localBuilder = generator.DeclareLocal(((MethodInfo)original).ReturnType);
				matcher.Insert((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Stloc, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod),
					new CodeInstruction(OpCodes.Ldloc, (object)localBuilder)
				});
				matcher.Advance(3);
			}
		}

		private static void ApplyAfter(CodeMatcher matcher, TranspilerConfig config, ILGenerator generator)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			bool flag = false;
			Type type = null;
			if (instruction.operand is MethodInfo methodInfo)
			{
				flag = methodInfo.ReturnType != typeof(void);
				type = methodInfo.ReturnType;
			}
			matcher.Advance(1);
			if (flag && type != null)
			{
				LocalBuilder localBuilder = generator.DeclareLocal(type);
				matcher.Insert((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Stloc, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod),
					new CodeInstruction(OpCodes.Ldloc, (object)localBuilder)
				});
				matcher.Advance(3);
			}
			else
			{
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)config.PatchMethod)
				});
			}
		}

		private static bool ApplyRedirect(CodeMatcher matcher, TranspilerConfig config)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			CodeInstruction instruction = matcher.Instruction;
			if (!(instruction.operand is MethodBase originalMethod))
			{
				Logger.LogWarning("REDIRECT target '" + config.TargetMember + "' is a field, not a method. Skipped.");
				matcher.Advance(1);
				return true;
			}
			if (!DontScrewUpStack(originalMethod, instruction.opcode, config.PatchMethod))
			{
				Logger.LogWarning($"REDIRECT patch '{config.PatchMethod.Name}' doesn't match with '{config.TargetMember}'. Skipped.");
				matcher.Advance(1);
				return true;
			}
			matcher.SetInstruction(new CodeInstruction(OpCodes.Call, (object)config.PatchMethod));
			return false;
		}

		private static (string, string) GetRequired(TranspilerConfig config)
		{
			if (string.IsNullOrEmpty(config.TargetMember))
			{
				return ("", "");
			}
			string item = "";
			string text = config.TargetMember;
			if (text.Contains('.'))
			{
				string[] array = text.Split('.');
				item = array[0];
				text = array[1];
			}
			else if (text.Contains("::"))
			{
				string[] array2 = text.Split(new string[1] { "::" }, StringSplitOptions.None);
				item = array2[0];
				text = array2[1];
			}
			return (item, text);
		}

		private static bool Matcher(CodeInstruction instruction, TranspilerConfig config, string requiredMethod, string requiredClass, CodeMatcher matcher)
		{
			Logger.LogFile($"{instruction.opcode}   {instruction.operand}");
			bool result = instruction.opcode == OpCodes.Ret;
			if (config.Type == AT.RETURN)
			{
				return result;
			}
			bool result2 = OpCodeHelper.IsBranch(instruction.opcode);
			AT type = config.Type;
			if ((uint)(type - 12) <= 1u)
			{
				return result2;
			}
			type = config.Type;
			if ((uint)(type - 7) <= 3u)
			{
				return OpCodeHelper.IsLoopEntryBranch(instruction, matcher.Instructions());
			}
			bool result3 = OpCodeHelper.IsLocalOpcode(instruction.opcode);
			type = config.Type;
			if ((uint)(type - 14) <= 1u)
			{
				return result3;
			}
			bool result4 = OpCodeHelper.IsArgOpcode(instruction.opcode);
			type = config.Type;
			if ((uint)(type - 16) <= 1u)
			{
				return result4;
			}
			bool flag = OpCodeHelper.IsField(instruction.opcode);
			type = config.Type;
			if ((uint)(type - 18) <= 1u)
			{
				return flag;
			}
			bool flag2 = OpCodeHelper.IsMethod(instruction.opcode);
			if (!flag2 && !flag)
			{
				return false;
			}
			string name;
			string text;
			if (flag2 && instruction.operand is MethodInfo methodInfo)
			{
				name = methodInfo.Name;
				text = methodInfo.DeclaringType?.Name;
			}
			else
			{
				if (!flag || !(instruction.operand is FieldInfo fieldInfo))
				{
					return false;
				}
				name = fieldInfo.Name;
				text = fieldInfo.DeclaringType?.Name;
			}
			if (name != requiredMethod)
			{
				return false;
			}
			if (!string.IsNullOrEmpty(requiredClass) && text != requiredClass)
			{
				return false;
			}
			return true;
		}

		private static bool DontScrewUpStack(MethodBase originalMethod, OpCode opCode, MethodInfo patchMethod)
		{
			List<Type> list = (from p in originalMethod.GetParameters()
				select p.ParameterType).ToList();
			if (opCode != OpCodes.Newobj && !originalMethod.IsStatic)
			{
				list.Insert(0, originalMethod.DeclaringType);
			}
			List<Type> list2 = (from p in patchMethod.GetParameters()
				select p.ParameterType).ToList();
			if (list.Count != list2.Count)
			{
				return false;
			}
			for (int num = 0; num < list.Count; num++)
			{
				if (!list[num].IsAssignableFrom(list2[num]))
				{
					return false;
				}
			}
			Type type = ((originalMethod is MethodInfo methodInfo) ? methodInfo.ReturnType : originalMethod.DeclaringType);
			return patchMethod.ReturnType == type;
		}
	}
	internal class TranspilerConfig
	{
		public AT Type;

		public string? TargetMember;

		public Type? TargetType;

		public MethodInfo PatchMethod;

		public uint Occurrence;

		public uint StartIndex;

		public uint ArgIndex;

		public TranspilerConfig(AT type, string targetMember, MethodInfo patchMethod, uint occurrence, uint startIndex, uint argIndex, Type targetType)
		{
			Type = type;
			TargetMember = targetMember;
			PatchMethod = patchMethod;
			Occurrence = occurrence;
			StartIndex = startIndex;
			ArgIndex = argIndex;
			TargetType = targetType;
		}
	}
}