using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using EnhancedPrefabLoaderPrepatch.Extensions;
using EnhancedPrefabLoaderPrepatch.Models;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Rocks;
using MonoMod.Cil;
using Newtonsoft.Json;
using Scripts;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("EnhancedPrefabLoaderPrepatch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+40cdc7df25d66bcd28939d889a9240738f060bdd")]
[assembly: AssemblyProduct("Enhanced Prefab Loader Prepatch")]
[assembly: AssemblyTitle("EnhancedPrefabLoaderPrepatch")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 EnhancedPrefabLoaderPrepatch
{
	public class BidirectionalDictionary<k, v>
	{
		private Dictionary<v, k> m_InverseDictionary = new Dictionary<v, k>();

		public v this[k key]
		{
			get
			{
				return Dictionary[key];
			}
			set
			{
				Dictionary[key] = value;
				m_InverseDictionary[value] = key;
			}
		}

		public Dictionary<k, v> Dictionary { get; } = new Dictionary<k, v>();


		public bool TryGetValue(k key, out v value)
		{
			return Dictionary.TryGetValue(key, out value);
		}

		public bool TryGetKey(v value, out k key)
		{
			return m_InverseDictionary.TryGetValue(value, out key);
		}

		public void Clear()
		{
			Dictionary.Clear();
			m_InverseDictionary.Clear();
		}

		public void AddAll(IEnumerable<KeyValuePair<k, v>> items)
		{
			foreach (KeyValuePair<k, v> item in items)
			{
				this[item.Key] = item.Value;
			}
		}
	}
	public static class EnumPatcher
	{
		public static BidirectionalDictionary<string, int> PatchEnum(AssemblyDefinition assembly, string enumName, List<string> names, int startingValue, BidirectionalDictionary<string, int> savedValues = null)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			BidirectionalDictionary<string, int> bidirectionalDictionary = new BidirectionalDictionary<string, int>();
			TypeDefinition val = ((IEnumerable<TypeDefinition>)assembly.MainModule.Types).FirstOrDefault((Func<TypeDefinition, bool>)((TypeDefinition t) => ((MemberReference)t).Name == enumName));
			if (val != null)
			{
				FieldDefinition val2 = ((IEnumerable<FieldDefinition>)val.Fields).FirstOrDefault((Func<FieldDefinition, bool>)((FieldDefinition f) => f.HasConstant && f.IsStatic && f.IsLiteral));
				if (val2 != null)
				{
					SortedDictionary<int, FieldDefinition> sortedDictionary = new SortedDictionary<int, FieldDefinition>();
					if (savedValues != null)
					{
						foreach (KeyValuePair<string, int> item in savedValues.Dictionary)
						{
							if (names.Contains(item.Key))
							{
								sortedDictionary[item.Value] = new FieldDefinition(item.Key, val2.Attributes, (TypeReference)(object)val)
								{
									Constant = item.Value
								};
								bidirectionalDictionary[item.Key] = item.Value;
								names.Remove(item.Key);
							}
						}
					}
					foreach (string name in names)
					{
						while (sortedDictionary.ContainsKey(startingValue))
						{
							startingValue++;
						}
						sortedDictionary[startingValue] = new FieldDefinition(name, val2.Attributes, (TypeReference)(object)val)
						{
							Constant = startingValue
						};
						bidirectionalDictionary[name] = startingValue;
						startingValue++;
					}
					{
						foreach (KeyValuePair<int, FieldDefinition> item2 in sortedDictionary)
						{
							val.Fields.Add(item2.Value);
						}
						return bidirectionalDictionary;
					}
				}
			}
			return bidirectionalDictionary;
		}
	}
	public enum CallType
	{
		Get,
		Set,
		Count,
		None
	}
	public class ListPatcher
	{
		private static ListPatcher m_Instance;

		public static ListPatcher Instance => m_Instance ?? (m_Instance = new ListPatcher());

		private ListPatcher()
		{
		}

		public void PatchListAccessors(ModuleDefinition module)
		{
			foreach (TypeDefinition allType in ModuleDefinitionRocks.GetAllTypes(module))
			{
				foreach (MethodDefinition item in ((IEnumerable<MethodDefinition>)allType.Methods).Where((MethodDefinition m) => m.HasBody))
				{
					Logger.Debug("Processing method: " + ((MemberReference)item).FullName);
					ProcessMethod(item);
				}
			}
		}

		private void ProcessMethod(MethodDefinition method)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			MethodBodyRocks.SimplifyMacros(method.Body);
			ILContext val = new ILContext(method);
			try
			{
				ILCursor val2 = new ILCursor(val);
				MethodVariablePool methodVariablePool = new MethodVariablePool(method);
				MethodReference accessorCall = null;
				while (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[2]
				{
					(Instruction instr) => ILPatternMatchingExt.MatchCallOrCallvirt(instr, ref accessorCall),
					(Instruction _) => accessorCall?.IsListAccessor() ?? false
				}))
				{
					Logger.Debug($"Found list indexer call at {val2.Next}");
					MethodReference obj = accessorCall;
					TypeReference obj2 = ((obj != null) ? ((MemberReference)obj).DeclaringType : null);
					GenericInstanceType val3 = (GenericInstanceType)(object)((obj2 is GenericInstanceType) ? obj2 : null);
					if (val3 == null)
					{
						Logger.Debug($"Skipping indexer call at {val2.Next}. Declaring type is non-generic.");
						continue;
					}
					TypeReference val4 = val3.GenericArguments[0];
					CallType callType = GetCallType(accessorCall);
					if (DiscoverDeclaredListName(val2, val4, out var listName))
					{
						PatchListAccess(val2, accessorCall, val4, callType, listName, methodVariablePool);
					}
				}
				Logger.Debug("Method " + ((MemberReference)val2.Method).FullName + " completed");
				MethodBodyRocks.OptimizeMacros(method.Body);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		private void PatchListAccess(ILCursor cursor, MethodReference accessorCall, TypeReference itemType, CallType callType, string listName, MethodVariablePool methodVariablePool)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			GenericInstanceType val = TypeReferenceRocks.MakeGenericInstanceType(cursor.Module.ImportReference(typeof(ListInterceptor<>)), (TypeReference[])(object)new TypeReference[1] { itemType });
			string interceptorMethodName = GetInterceptorMethodName(callType);
			MethodDefinition val2 = ((IEnumerable<MethodDefinition>)((TypeReference)val).Resolve().Methods).First((MethodDefinition m) => ((MemberReference)m).Name == interceptorMethodName);
			MethodReference val3 = cursor.Module.ImportReference((MethodReference)(object)val2);
			((MemberReference)val3).DeclaringType = (TypeReference)(object)val;
			IEnumerable<Instruction> enumerable = ((IEnumerable<Instruction>)cursor.Method.Body.Instructions).Where((Instruction instr) => instr.Operand == cursor.Next);
			Instruction operand = null;
			switch (callType)
			{
			case CallType.Get:
				operand = cursor.Emit(OpCodes.Stloc, methodVariablePool.GetIndexVariable()).Previous;
				cursor.Emit(OpCodes.Stloc, methodVariablePool.GetListVariable(((MemberReference)accessorCall).DeclaringType));
				break;
			case CallType.Set:
				operand = cursor.Emit(OpCodes.Stloc, methodVariablePool.GetItemVariable(itemType)).Previous;
				cursor.Emit(OpCodes.Stloc, methodVariablePool.GetIndexVariable());
				cursor.Emit(OpCodes.Stloc, methodVariablePool.GetListVariable(((MemberReference)accessorCall).DeclaringType));
				break;
			case CallType.Count:
				operand = cursor.Emit(OpCodes.Stloc, methodVariablePool.GetListVariable(((MemberReference)accessorCall).DeclaringType)).Previous;
				break;
			}
			cursor.Emit(OpCodes.Ldloc, methodVariablePool.GetListVariable(((MemberReference)accessorCall).DeclaringType));
			if (callType != CallType.Count)
			{
				cursor.Emit(OpCodes.Ldloc, methodVariablePool.GetIndexVariable());
			}
			if (callType == CallType.Set)
			{
				cursor.Emit(OpCodes.Ldloc, methodVariablePool.GetItemVariable(itemType));
			}
			cursor.Emit(OpCodes.Ldstr, listName);
			cursor.Next.OpCode = OpCodes.Call;
			cursor.Next.Operand = val3;
			foreach (Instruction item in enumerable)
			{
				item.Operand = operand;
			}
			Logger.Debug("Patch complete");
		}

		private bool DiscoverDeclaredListName(ILCursor cursor, TypeReference elementType, out string listName)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			ILCursor walkBackCursor = cursor.Clone();
			TypeReference matchedElementType = null;
			if (walkBackCursor.TryGotoPrev((MoveType)0, new Func<Instruction, bool>[2]
			{
				(Instruction instr) => instr.MatchListLoad(walkBackCursor.Method.Body, out matchedElementType),
				(Instruction _) => matchedElementType == elementType
			}))
			{
				if (walkBackCursor.Next.OpCode.IsFieldLoad())
				{
					object operand = walkBackCursor.Next.Operand;
					object obj = ((operand is FieldReference) ? operand : null);
					listName = ((obj != null) ? ((MemberReference)obj).Name : null);
					return true;
				}
				if (walkBackCursor.Next.OpCode.IsLdloc())
				{
					Instruction instructionToCheck = walkBackCursor.Next;
					if (walkBackCursor.TryGotoPrev((MoveType)0, new Func<Instruction, bool>[1]
					{
						(Instruction instr) => instr.IsComplimentaryStOf(instructionToCheck)
					}))
					{
						if (walkBackCursor.Previous.OpCode.IsFieldLoad())
						{
							object operand2 = walkBackCursor.Previous.Operand;
							object obj2 = ((operand2 is FieldReference) ? operand2 : null);
							listName = ((obj2 != null) ? ((MemberReference)obj2).Name : null);
							return true;
						}
						return DiscoverDeclaredListName(walkBackCursor, elementType, out listName);
					}
				}
			}
			listName = "SkippedName";
			return false;
		}

		private string GetInterceptorMethodName(CallType callType)
		{
			return callType switch
			{
				CallType.Count => "InvokeCount", 
				CallType.Get => "InvokeGet", 
				CallType.Set => "InvokeSet", 
				_ => throw new ArgumentOutOfRangeException(), 
			};
		}

		private CallType GetCallType(MethodReference methodRef)
		{
			if (methodRef.IsListGetCountCall())
			{
				return CallType.Count;
			}
			if (methodRef.IsListGetItemCall())
			{
				return CallType.Get;
			}
			if (methodRef.IsListSetItemCall())
			{
				return CallType.Set;
			}
			return CallType.None;
		}
	}
	public enum LogLevel
	{
		Debug,
		Info,
		Warning,
		Error,
		None
	}
	public static class Logger
	{
		private static readonly object _lock = new object();

		public static LogLevel MinimumLevel { get; set; } = LogLevel.Info;


		public static void Debug(string message)
		{
			Log(LogLevel.Debug, message);
		}

		public static void Info(string message)
		{
			Log(LogLevel.Info, message);
		}

		public static void Warning(string message)
		{
			Log(LogLevel.Warning, message);
		}

		public static void Error(string message)
		{
			Log(LogLevel.Error, message);
		}

		private static void Log(LogLevel level, string message)
		{
			if (level < MinimumLevel)
			{
				return;
			}
			lock (_lock)
			{
				ConsoleColor foregroundColor = Console.ForegroundColor;
				try
				{
					Console.ForegroundColor = GetLevelColor(level);
					Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] [{level}] {message}");
				}
				finally
				{
					Console.ForegroundColor = foregroundColor;
				}
			}
		}

		private static ConsoleColor GetLevelColor(LogLevel level)
		{
			return level switch
			{
				LogLevel.Debug => ConsoleColor.DarkGray, 
				LogLevel.Info => ConsoleColor.White, 
				LogLevel.Warning => ConsoleColor.Yellow, 
				LogLevel.Error => ConsoleColor.Red, 
				_ => ConsoleColor.Gray, 
			};
		}
	}
	public class MethodVariablePool
	{
		private readonly MethodDefinition m_Method;

		private readonly Dictionary<TypeReference, VariableDefinition> m_Variables = new Dictionary<TypeReference, VariableDefinition>();

		public MethodVariablePool(MethodDefinition method)
		{
			m_Method = method;
		}

		public VariableDefinition GetListVariable(TypeReference type)
		{
			return GetVariableDefinition(type);
		}

		public VariableDefinition GetIndexVariable()
		{
			return GetVariableDefinition(((MemberReference)m_Method).Module.TypeSystem.UInt32);
		}

		public VariableDefinition GetItemVariable(TypeReference type)
		{
			return GetVariableDefinition(type);
		}

		private VariableDefinition GetVariableDefinition(TypeReference type)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (!m_Variables.TryGetValue(type, out var value))
			{
				value = new VariableDefinition(type);
				m_Method.Body.Variables.Add(value);
				m_Variables[type] = value;
			}
			return value;
		}
	}
	public class Patcher
	{
		public static IEnumerable<string> TargetDLLs { get; } = new <>z__ReadOnlySingleElementList<string>("Assembly-CSharp.dll");


		public static SaveManager SaveManager { get; set; } = null;


		private static string BasePatcherDirectory { get; set; } = "";


		private static ObjectTypes TypesToLoad { get; set; } = new ObjectTypes();


		public static void Initialize()
		{
			if (SaveManager == null)
			{
				SaveManager = new SaveManager();
			}
			BasePatcherDirectory = (from x in Directory.GetDirectories(Paths.PatcherPluginPath, "*", SearchOption.AllDirectories)
				where x.ToLower().EndsWith("enhancedprefabloader")
				select x).FirstOrDefault();
			Logger.Info("Loading saved enum values.");
			SaveManager.Load(BasePatcherDirectory + "/savedTypes");
			foreach (string item in from x in Directory.GetDirectories(Paths.PatcherPluginPath, "*", SearchOption.AllDirectories)
				where x.ToLower().EndsWith("prefabloader")
				select x)
			{
				foreach (string item2 in Directory.EnumerateFiles(item, "*.json", SearchOption.AllDirectories))
				{
					Logger.Info("Enhanced Prefab Loader json detected: " + item2 + ".");
					ObjectTypes objectTypes = JsonConvert.DeserializeObject<ObjectTypes>(File.ReadAllText(item2));
					TypesToLoad.FurnitureTypes.AddRange(objectTypes.FurnitureTypes);
					TypesToLoad.ItemTypes.AddRange(objectTypes.ItemTypes);
				}
			}
			Logger.Info("Object type enum values found: ");
			TypesToLoad.FurnitureTypes.ForEach(delegate(string x)
			{
				Logger.Info(x);
			});
			Logger.Info("Item type enum values found: ");
			TypesToLoad.ItemTypes.ForEach(delegate(string x)
			{
				Logger.Info(x);
			});
		}

		public static void Patch(AssemblyDefinition assembly)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Logger.MinimumLevel = LogLevel.Info;
			_ = assembly.MainModule;
			((BaseAssemblyResolver)assembly.MainModule.AssemblyResolver).AddSearchDirectory((from x in Directory.GetDirectories(Paths.PluginPath, "*", SearchOption.AllDirectories)
				where x.ToLower().EndsWith("enhancedprefabloader")
				select x).FirstOrDefault());
			Logger.Info("Enhanced Prefab Loader patching started.");
			Logger.Info("Applying patches to List accessors.");
			ListPatcher.Instance.PatchListAccessors(assembly.MainModule);
			if (TypesToLoad?.FurnitureTypes != null && TypesToLoad.FurnitureTypes.Count > 0)
			{
				Logger.Info("Loading enum patches for furniture types.");
				SaveManager.FurnitureTypes = EnumPatcher.PatchEnum(assembly, "EObjectType", TypesToLoad.FurnitureTypes, 1000, SaveManager.FurnitureTypes);
			}
			if (TypesToLoad?.ItemTypes != null && TypesToLoad.ItemTypes.Count > 0)
			{
				Logger.Info("Loading enum patches for item types");
				SaveManager.ItemTypes = EnumPatcher.PatchEnum(assembly, "EItemType", TypesToLoad.ItemTypes, 200000, SaveManager.ItemTypes);
			}
			SaveManager.Save(BasePatcherDirectory + "/savedTypes");
			Logger.Info("Enhanced Prefab Loader PrePatching complete");
		}
	}
	public class SaveManager
	{
		public BidirectionalDictionary<string, int> FurnitureTypes { get; set; } = new BidirectionalDictionary<string, int>();


		public BidirectionalDictionary<string, int> ItemTypes { get; set; } = new BidirectionalDictionary<string, int>();


		public BidirectionalDictionary<string, int> ItemCategories { get; set; } = new BidirectionalDictionary<string, int>();


		public void Load(string filePath)
		{
			if (File.Exists(filePath))
			{
				SaveData saveData = JsonConvert.DeserializeObject<SaveData>(File.ReadAllText(filePath));
				FurnitureTypes.Clear();
				ItemTypes.Clear();
				ItemCategories.Clear();
				if (saveData.FurnitureObjectTypes != null)
				{
					FurnitureTypes.AddAll(saveData.FurnitureObjectTypes);
				}
				if (saveData.ItemTypes != null)
				{
					ItemTypes.AddAll(saveData.ItemTypes);
				}
				if (saveData.ItemCategories != null)
				{
					ItemCategories.AddAll(saveData.ItemCategories);
				}
			}
		}

		public void Save(string filePath)
		{
			SaveData saveData = default(SaveData);
			saveData.FurnitureObjectTypes = FurnitureTypes.Dictionary;
			saveData.ItemTypes = ItemTypes.Dictionary;
			saveData.ItemCategories = ItemCategories.Dictionary;
			SaveData saveData2 = saveData;
			File.WriteAllText(filePath, JsonConvert.SerializeObject((object)saveData2));
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "EnhancedPrefabLoaderPrepatch";

		public const string PLUGIN_NAME = "Enhanced Prefab Loader Prepatch";

		public const string PLUGIN_VERSION = "2.0.0";
	}
}
namespace EnhancedPrefabLoaderPrepatch.Models
{
	public class ObjectTypes
	{
		public List<string> FurnitureTypes { get; set; } = new List<string>();


		public List<string> ItemTypes { get; set; } = new List<string>();


		public List<string> ItemCategoryTypes { get; set; } = new List<string>();

	}
	public struct SaveData
	{
		public Dictionary<string, int> FurnitureObjectTypes { get; set; }

		public Dictionary<string, int> ItemTypes { get; set; }

		public Dictionary<string, int> ItemCategories { get; set; }
	}
}
namespace EnhancedPrefabLoaderPrepatch.Extensions
{
	public static class CicelExtensions
	{
		public static bool IsLoadCode(this OpCode opCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!opCode.IsLdloc() && !opCode.IsLdarg() && !opCode.IsLdc() && !opCode.IsLdelem() && !opCode.IsFieldLoad() && !opCode.IsLdNullOrStr())
			{
				return opCode.IsLdind();
			}
			return true;
		}

		public static bool IsFieldLoad(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code == 120 || (int)code == 123)
			{
				return true;
			}
			return false;
		}

		public static bool IsLdloc(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if (code - 6 <= 3 || (int)code == 17 || (int)code == 202)
			{
				return true;
			}
			return false;
		}

		public static bool IsLdarg(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if (code - 2 <= 3 || code - 14 <= 1 || code - 199 <= 1)
			{
				return true;
			}
			return false;
		}

		public static bool IsLdc(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if (code - 21 <= 14)
			{
				return true;
			}
			return false;
		}

		public static bool IsLdelem(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code == 145 || (int)code == 151 || (int)code == 160)
			{
				return true;
			}
			return false;
		}

		public static bool IsLdind(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if (code - 69 <= 6 || code - 77 <= 2)
			{
				return true;
			}
			return false;
		}

		public static bool IsLdNullOrStr(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code == 20 || (int)code == 113)
			{
				return true;
			}
			return false;
		}

		public static bool IsStloc(this OpCode opCode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			Code code = ((OpCode)(ref opCode)).Code;
			if (code - 10 <= 3 || (int)code == 19 || (int)code == 204)
			{
				return true;
			}
			return false;
		}

		public static bool IsComplimentaryStOf(this Instruction stInstruction, Instruction ldInstruction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (stInstruction.OpCode.IsStloc() && ldInstruction.OpCode.IsLdloc())
			{
				return stInstruction.GetLocalCodeIndex() == ldInstruction.GetLocalCodeIndex();
			}
			return false;
		}

		public static int? GetLocalCodeIndex(this Instruction instr)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected I4, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			OpCode opCode = instr.OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			switch (code - 6)
			{
			default:
				if ((int)code != 202 && (int)code != 204)
				{
					break;
				}
				goto case 11;
			case 0:
			case 4:
				return 0;
			case 1:
			case 5:
				return 1;
			case 2:
			case 6:
				return 2;
			case 3:
			case 7:
				return 3;
			case 11:
			case 13:
			{
				object operand = instr.Operand;
				object obj = ((operand is VariableReference) ? operand : null);
				return (obj != null) ? new int?(((VariableReference)obj).Index) : null;
			}
			case 8:
			case 9:
			case 10:
			case 12:
				break;
			}
			return null;
		}

		public static bool IsListType(this TypeReference typeRef)
		{
			if (((typeRef != null) ? ((MemberReference)typeRef).Name : null) == "List`1" && ((typeRef != null) ? typeRef.Namespace : null) == "System.Collections.Generic")
			{
				if (!(typeRef is GenericInstanceType))
				{
					TypeDefinition obj = typeRef.Resolve();
					object obj2;
					if (obj == null)
					{
						obj2 = null;
					}
					else
					{
						TypeReference baseType = obj.BaseType;
						obj2 = ((baseType != null) ? ((MemberReference)baseType).Name : null);
					}
					return (string?)obj2 == "List`1";
				}
				return true;
			}
			return false;
		}

		public static bool IsListAccessor(this MethodReference methodRef)
		{
			if (methodRef != null)
			{
				if (!methodRef.IsListGetItemCall() && !methodRef.IsListSetItemCall())
				{
					return methodRef.IsListGetCountCall();
				}
				return true;
			}
			return false;
		}

		public static bool IsListGetItemCall(this MethodReference methodRef)
		{
			if (methodRef != null && ((MemberReference)methodRef).DeclaringType.IsListType())
			{
				return ((MemberReference)methodRef).Name == "get_Item";
			}
			return false;
		}

		public static bool IsListSetItemCall(this MethodReference methodRef)
		{
			if (methodRef != null && ((MemberReference)methodRef).DeclaringType.IsListType())
			{
				return ((MemberReference)methodRef).Name == "set_Item";
			}
			return false;
		}

		public static bool IsListGetCountCall(this MethodReference methodRef)
		{
			if (methodRef != null && ((MemberReference)methodRef).DeclaringType.IsListType())
			{
				return ((MemberReference)methodRef).Name == "get_Count";
			}
			return false;
		}

		public static bool MatchListLoad(this Instruction instr, MethodBody methodBody, out TypeReference elementType)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected I4, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Invalid comparison between Unknown and I4
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Invalid comparison between Unknown and I4
			elementType = null;
			if (instr != null)
			{
				_ = instr.OpCode;
				if (0 == 0 && ((methodBody != null) ? methodBody.Method : null) != null && instr.OpCode.IsLoadCode())
				{
					try
					{
						OpCode opCode = instr.OpCode;
						Code code = ((OpCode)(ref opCode)).Code;
						if ((int)code <= 120)
						{
							switch (code - 2)
							{
							case 4:
								goto IL_00bb;
							case 5:
								goto IL_00d2;
							case 6:
								goto IL_00e9;
							case 7:
								goto IL_0100;
							case 15:
								goto IL_0117;
							case 0:
								goto IL_0134;
							case 1:
								goto IL_0171;
							case 2:
								goto IL_019a;
							case 3:
								goto IL_01c3;
							case 12:
								goto IL_01ec;
							case 8:
							case 9:
							case 10:
							case 11:
							case 13:
							case 14:
								goto IL_0220;
							}
							if ((int)code == 120)
							{
								goto IL_0206;
							}
						}
						else
						{
							if ((int)code == 123)
							{
								goto IL_0206;
							}
							if ((int)code == 199)
							{
								goto IL_01ec;
							}
							if ((int)code == 202)
							{
								goto IL_0117;
							}
						}
						goto IL_0220;
						IL_0220:
						TypeReference val = null;
						goto IL_0222;
						IL_0134:
						object obj2;
						if (!((MethodReference)methodBody.Method).HasThis)
						{
							ParameterDefinition obj = ((MethodReference)methodBody.Method).Parameters[0];
							obj2 = ((obj != null) ? ((ParameterReference)obj).ParameterType : null);
						}
						else
						{
							obj2 = methodBody.Method.DeclaringType;
						}
						val = (TypeReference)obj2;
						goto IL_0222;
						IL_0100:
						val = ((VariableReference)methodBody.Variables[3]).VariableType;
						goto IL_0222;
						IL_00e9:
						val = ((VariableReference)methodBody.Variables[2]).VariableType;
						goto IL_0222;
						IL_00d2:
						val = ((VariableReference)methodBody.Variables[1]).VariableType;
						goto IL_0222;
						IL_00bb:
						val = ((VariableReference)methodBody.Variables[0]).VariableType;
						goto IL_0222;
						IL_01c3:
						val = ((ParameterReference)((MethodReference)methodBody.Method).Parameters[((MethodReference)methodBody.Method).HasThis ? 2 : 3]).ParameterType;
						goto IL_0222;
						IL_0117:
						object operand = instr.Operand;
						object obj3 = ((operand is VariableReference) ? operand : null);
						val = ((obj3 != null) ? ((VariableReference)obj3).VariableType : null);
						goto IL_0222;
						IL_0206:
						object operand2 = instr.Operand;
						object obj4 = ((operand2 is FieldReference) ? operand2 : null);
						val = ((obj4 != null) ? ((FieldReference)obj4).FieldType : null);
						goto IL_0222;
						IL_01ec:
						object operand3 = instr.Operand;
						object obj5 = ((operand3 is ParameterReference) ? operand3 : null);
						val = ((obj5 != null) ? ((ParameterReference)obj5).ParameterType : null);
						goto IL_0222;
						IL_019a:
						val = ((ParameterReference)((MethodReference)methodBody.Method).Parameters[((MethodReference)methodBody.Method).HasThis ? 1 : 2]).ParameterType;
						goto IL_0222;
						IL_0222:
						TypeReference val2 = val;
						GenericInstanceType val3 = (GenericInstanceType)(object)((val2 is GenericInstanceType) ? val2 : null);
						if (val3 != null && val2.IsListType() && val3.GenericArguments.Count > 0)
						{
							elementType = val3.GenericArguments[0];
							return true;
						}
						return false;
						IL_0171:
						val = ((ParameterReference)((MethodReference)methodBody.Method).Parameters[(!((MethodReference)methodBody.Method).HasThis) ? 1 : 0]).ParameterType;
						goto IL_0222;
					}
					catch (Exception ex) when (((ex is ArgumentOutOfRangeException || ex is NullReferenceException) ? 1 : 0) != 0)
					{
						elementType = null;
						return false;
					}
				}
			}
			return false;
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}