using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Rocks;
using Mono.Collections.Generic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("0rounds-port.AutoFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.5.1.0")]
[assembly: AssemblyInformationalVersion("1.5.1")]
[assembly: AssemblyProduct("0rounds-port.AutoFix")]
[assembly: AssemblyTitle("0rounds-port.AutoFix")]
[assembly: AssemblyVersion("1.5.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
internal sealed class AutoFix(Settings settings, ManualLogSource log)
{
	public sealed record Settings(string GameDir, string Managed, string Core, string Plugins, string Cache, string[] Exclude);

	private sealed class Entry
	{
		public long Size;

		public long Time;

		public string Sha = "";

		public string Orig = "";

		public string Result = "";

		public string Note = "";

		public bool Retry;
	}

	private const string Fixed = "fixed";

	private const string Unchanged = "unchanged";

	private const string NotMod = "not-a-mod";

	private const string Excluded = "excluded";

	private const string Error = "error";

	private const string Old = "old";

	private readonly string indexPath = Path.Combine(settings.Cache, "index.tsv");

	private readonly string originals = Path.Combine(settings.Cache, "originals");

	private readonly Curated curated = new Curated(settings.Cache, log);

	private Game? game;

	private Scanner? scanner;

	private string Key()
	{
		ModuleDefinition val = ModuleDefinition.ReadModule(Path.Combine(settings.Managed, "Assembly-CSharp.dll"));
		string text;
		try
		{
			text = val.Mvid.ToString();
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
		return string.Join(" ", typeof(AutoFix).Assembly.ManifestModule.ModuleVersionId, text, string.Join(",", settings.Exclude));
	}

	public void Run()
	{
		Stopwatch stopwatch = Stopwatch.StartNew();
		Directory.CreateDirectory(settings.Cache);
		List<(string, FileInfo)> list = PluginFiles();
		string text = Key();
		var (text2, dictionary) = ReadIndex();
		if (text2 == text + " old-game")
		{
			log.LogInfo((object)"this is the old game build (old-rounds-for-mods): mods work on it as they are");
			return;
		}
		bool flag = text2 != text;
		List<string> list2 = curated.Plan(list.Select<(string, FileInfo), string>(((string rel, FileInfo fi) f) => f.fi.FullName)).ToList();
		SortedDictionary<string, Entry> next = new SortedDictionary<string, Entry>(StringComparer.Ordinal);
		List<(string, FileInfo)> list3 = new List<(string, FileInfo)>();
		foreach (var (text3, fileInfo) in list)
		{
			if (!flag && dictionary.TryGetValue(text3, out var value) && value.Size == fileInfo.Length && value.Time == fileInfo.LastWriteTimeUtc.Ticks && (!(value.Result == "old") || list2.Count <= 0))
			{
				next[text3] = value;
			}
			else
			{
				list3.Add((text3, fileInfo));
			}
		}
		if (list3.Count > 0)
		{
			log.LogInfo((object)((flag && dictionary.Count > 0) ? $"checking {list3.Count} DLLs again (rounds-port, the game or the settings changed)" : $"checking {list3.Count} new or updated DLLs"));
			try
			{
				game = new Game(settings.GameDir, settings.Managed, settings.Core, settings.Plugins);
			}
			catch (UserError)
			{
				if (dictionary.Count > 0)
				{
					RestoreOriginals(off: false);
				}
				WriteIndex(text + " old-game", new SortedDictionary<string, Entry>());
				log.LogInfo((object)"this is the old game build (old-rounds-for-mods): mods work on it as they are");
				return;
			}
			foreach (string item in list2)
			{
				game.Resolver.Set(item);
			}
			if (game.Resolver.Path("UnboundLib") == null)
			{
				log.LogWarning((object)"UnboundLib 4 isn't installed: most mods need it (Bknibb's port, github.com/Bknibb/UnboundLib)");
			}
			scanner = new Scanner(game);
			foreach (var (text4, fileInfo2) in list3)
			{
				dictionary.TryGetValue(text4, out var value2);
				Entry entry;
				try
				{
					entry = Check(text4, fileInfo2.FullName, value2, flag);
				}
				catch (Exception ex)
				{
					entry = new Entry
					{
						Result = "error",
						Note = OneLine(ex.GetType().Name + ": " + ex.Message),
						Sha = (value2?.Sha ?? ""),
						Orig = (value2?.Orig ?? "")
					};
					log.LogWarning((object)$"couldn't check {text4}, left as it is: {ex}");
				}
				FileInfo fileInfo3 = new FileInfo(fileInfo2.FullName);
				if (fileInfo3.Exists)
				{
					entry.Size = (entry.Retry ? (-1) : fileInfo3.Length);
					entry.Time = fileInfo3.LastWriteTimeUtc.Ticks;
					next[text4] = entry;
				}
			}
			game.Resolver.Dispose();
			game = null;
			scanner = null;
			GC.Collect();
		}
		HashSet<string> hashSet = new HashSet<string>(from e in next.Values.Where(IsCopy)
			select e.Orig, StringComparer.OrdinalIgnoreCase);
		if (Directory.Exists(originals))
		{
			string[] files = Directory.GetFiles(originals, "*.dll");
			foreach (string path in files)
			{
				if (!hashSet.Contains(Path.GetFileNameWithoutExtension(path)))
				{
					TryDelete(path);
				}
			}
		}
		if (list3.Count > 0 || next.Count != dictionary.Count)
		{
			WriteIndex(text, next);
		}
		foreach (KeyValuePair<string, Entry> item2 in next.Where<KeyValuePair<string, Entry>>((KeyValuePair<string, Entry> kv) => kv.Value.Result == "old"))
		{
			log.LogWarning((object)("BepInEx/plugins/" + item2.Key + " is " + item2.Value.Note + ", which doesn't work on the current game: use Bknibb's port (github.com/Bknibb/UnboundLib, github.com/Bknibb/RoundsWithFriends). Mods aren't fixed against it"));
		}
		int num2 = next.Count - Count("not-a-mod") - Count("old");
		int num3 = next.Values.Count((Entry e) => e.Result == "fixed" && e.Note.Length > 0);
		string text5 = string.Format("{0} mods: {1} fixed", num2, Count("fixed")) + ((num3 > 0) ? $" ({num3} with problems only their authors can fix)" : "") + string.Format(", {0} need nothing", Count("unchanged"));
		if (Count("excluded") > 0)
		{
			text5 += string.Format(", {0} excluded", Count("excluded"));
		}
		if (Count("error") > 0)
		{
			text5 += string.Format(", {0} with errors", Count("error"));
		}
		if (Count("old") > 0)
		{
			text5 += string.Format("; {0} old librar{1} skipped", Count("old"), (Count("old") == 1) ? "y" : "ies");
		}
		log.LogInfo((object)$"{text5} ({stopwatch.ElapsedMilliseconds} ms)");
		if (list3.Count != 0)
		{
			return;
		}
		foreach (KeyValuePair<string, Entry> item3 in next.Where<KeyValuePair<string, Entry>>((KeyValuePair<string, Entry> kv) => kv.Value.Result == "error"))
		{
			log.LogInfo((object)("  error: " + item3.Key + ": " + item3.Value.Note));
		}
		int Count(string r)
		{
			return next.Values.Count((Entry e) => e.Result == r);
		}
	}

	private Entry Check(string rel, string path, Entry? e, bool keyChanged)
	{
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Expected O, but got Unknown
		byte[] array = ReadShared(path);
		string sha = Sha(array);
		if (e != null && !keyChanged && sha == e.Sha && e.Size >= 0)
		{
			return e;
		}
		bool ours = e != null && IsCopy(e) && sha == e.Sha;
		byte[] orig = array;
		string origSha = sha;
		if (ours)
		{
			string path2 = Path.Combine(originals, e.Orig + ".dll");
			if (File.Exists(path2))
			{
				orig = File.ReadAllBytes(path2);
				origSha = e.Orig;
			}
			else
			{
				ours = false;
				log.LogWarning((object)(rel + ": its original isn't in " + originals + " any more; checking the file as it is"));
			}
		}
		if (Matches(rel, settings.Exclude))
		{
			return Done("excluded");
		}
		byte[] array2;
		try
		{
			array2 = curated.Apply(path, orig, origSha);
		}
		catch (Exception ex)
		{
			log.LogWarning((object)(rel + ": " + ex.Message + "; fixing it without its curated patch"));
			array2 = orig;
		}
		bool flag = array2 != orig;
		ReaderParameters val = new ReaderParameters
		{
			AssemblyResolver = (IAssemblyResolver)(object)game.Resolver,
			ReadingMode = (ReadingMode)1
		};
		ModuleDefinition val3;
		try
		{
			ModuleDefinition val2 = ModuleDefinition.ReadModule((Stream)new MemoryStream(array2));
			try
			{
				if (!flag && val2.Assembly != null)
				{
					string text = Game.OldLibrary(path, val2.Assembly.Name);
					if (text != null)
					{
						return Done("old", text);
					}
				}
				if (!((IEnumerable<AssemblyNameReference>)val2.AssemblyReferences).Any(delegate(AssemblyNameReference a)
				{
					string name = a.Name;
					return (name == "Assembly-CSharp" || name == "UnboundLib") ? true : false;
				}) || ((ModuleReference)val2).Name.StartsWith("MMHOOK"))
				{
					return flag ? Save(array2, null, "fixed") : Done("not-a-mod");
				}
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
			val3 = ModuleDefinition.ReadModule((Stream)new MemoryStream(array2), val);
		}
		catch (Exception ex2)
		{
			log.LogWarning((object)("couldn't read " + rel + ", left as it is: " + ex2.GetType().Name + ": " + OneLine(ex2.Message)));
			return Done("error", OneLine(ex2.GetType().Name + ": " + ex2.Message));
		}
		scanner.Scan(val3);
		Fixer fixer = new Fixer(val3, game, scanner);
		fixer.Run();
		if (!fixer.Changed)
		{
			if (!flag)
			{
				return Done("unchanged");
			}
			return Save(array2, null, "fixed");
		}
		MemoryStream memoryStream = new MemoryStream();
		val3.Write((Stream)memoryStream);
		byte[] array3 = memoryStream.ToArray();
		List<Issue> source = scanner.Scan(ModuleDefinition.ReadModule((Stream)new MemoryStream(array3), val));
		List<Issue> list = source.Where((Issue i) => i.Fix == Fix.Manual).ToList();
		Entry entry = Save(array3, (list.Count > 0) ? $"{list.Count} MANUAL left" : null, "fixed");
		if (entry.Result == "error")
		{
			return entry;
		}
		List<string> list2 = (from i in source
			where i.Fix == Fix.Review
			select i.Kind).Distinct().ToList();
		string text2 = string.Format("fixed {0}: {1} kind{2} of change", rel, fixer.Changes.Count(), (fixer.Changes.Count() == 1) ? "" : "s") + ((list2.Count > 0) ? ("; to check in game: " + string.Join(", ", list2)) : "");
		if (list.Count == 0)
		{
			log.LogInfo((object)text2);
		}
		else
		{
			log.LogWarning((object)(text2 + string.Format("; {0} MANUAL item{1} left, which only its author can fix: ", list.Count, (list.Count == 1) ? "" : "s") + string.Join("; ", from i in list.Take(3)
				select i.What) + ((list.Count > 3) ? "; ..." : "")));
		}
		return entry;
		Entry Done(string result, string note = "")
		{
			if (ours)
			{
				Replace(path, orig);
				log.LogInfo((object)("put back the original of " + rel));
			}
			return new Entry
			{
				Sha = origSha,
				Orig = origSha,
				Result = result,
				Note = note
			};
		}
		Entry Save(byte[] bytes, string? note, string result)
		{
			string text3 = Sha(bytes);
			try
			{
				SaveOriginal(origSha, orig);
				if (text3 != sha)
				{
					Replace(path, bytes);
				}
			}
			catch (Exception ex3) when (((ex3 is IOException || ex3 is UnauthorizedAccessException) ? 1 : 0) != 0)
			{
				log.LogWarning((object)("couldn't save the fixed copy of " + rel + ", left as it is: " + ex3.Message));
				return new Entry
				{
					Sha = sha,
					Orig = origSha,
					Result = "error",
					Note = OneLine("can't write: " + ex3.Message),
					Retry = true
				};
			}
			return new Entry
			{
				Sha = text3,
				Orig = origSha,
				Result = result,
				Note = (note ?? "")
			};
		}
	}

	private static byte[] ReadShared(string path)
	{
		int num = 0;
		while (true)
		{
			try
			{
				using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
				MemoryStream memoryStream = new MemoryStream();
				fileStream.CopyTo(memoryStream);
				return memoryStream.ToArray();
			}
			catch (IOException) when (num < 10 && File.Exists(path))
			{
				Thread.Sleep(300);
			}
			num++;
		}
	}

	public void RestoreOriginals(bool off = true)
	{
		Dictionary<string, Entry> item = ReadIndex().index;
		int num = 0;
		foreach (KeyValuePair<string, Entry> item2 in item.Where<KeyValuePair<string, Entry>>((KeyValuePair<string, Entry> kv) => IsCopy(kv.Value)))
		{
			string path = Path.Combine(settings.Plugins, item2.Key);
			string path2 = Path.Combine(originals, item2.Value.Orig + ".dll");
			try
			{
				if (File.Exists(path) && File.Exists(path2) && !(Sha(File.ReadAllBytes(path)) != item2.Value.Sha))
				{
					Replace(path, File.ReadAllBytes(path2));
					num++;
				}
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("couldn't put back the original of " + item2.Key + ": " + ex.Message));
			}
		}
		TryDelete(indexPath);
		log.LogInfo((object)(string.Format("put back {0} original mod{1}", num, (num == 1) ? "" : "s") + (off ? "; AutoFix is off now (Enabled in rounds-port.autofix.cfg)" : ": this is the old game build")));
	}

	private static bool IsCopy(Entry e)
	{
		if (e.Orig.Length > 0)
		{
			return e.Sha != e.Orig;
		}
		return false;
	}

	private List<(string rel, FileInfo fi)> PluginFiles()
	{
		List<(string, FileInfo)> list = new List<(string, FileInfo)>();
		if (!Directory.Exists(settings.Plugins))
		{
			return list;
		}
		string[] files = Directory.GetFiles(settings.Plugins, "*.rpbak", SearchOption.AllDirectories);
		foreach (string text in files)
		{
			string text2 = text.Substring(0, text.Length - ".rpbak".Length);
			if (File.Exists(text2))
			{
				TryDelete(text);
			}
			else
			{
				File.Move(text, text2);
			}
		}
		files = Directory.GetFiles(settings.Plugins, "*.rptmp", SearchOption.AllDirectories);
		for (int i = 0; i < files.Length; i++)
		{
			TryDelete(files[i]);
		}
		files = Directory.GetFiles(settings.Plugins, "*.dll", SearchOption.AllDirectories);
		foreach (string text3 in files)
		{
			if (text3.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
			{
				list.Add((text3.Substring(settings.Plugins.Length).TrimStart('/', '\\'), new FileInfo(text3)));
			}
		}
		list.Sort(((string, FileInfo) a, (string, FileInfo) b) => string.CompareOrdinal(a.Item1, b.Item1));
		return list;
	}

	private static bool Matches(string rel, string[] names)
	{
		string[] parts = rel.Split('/', '\\');
		string file = parts[parts.Length - 1];
		return names.Any((string n) => parts.Any((string p) => p.Equals(n, StringComparison.OrdinalIgnoreCase)) || Path.GetFileNameWithoutExtension(file).Equals(n, StringComparison.OrdinalIgnoreCase));
	}

	private static void Replace(string path, byte[] bytes)
	{
		string text = path + ".rptmp";
		string text2 = path + ".rpbak";
		File.WriteAllBytes(text, bytes);
		if (File.Exists(text2))
		{
			File.Delete(text2);
		}
		File.Move(path, text2);
		File.Move(text, path);
		File.Delete(text2);
	}

	private void SaveOriginal(string sha, byte[] bytes)
	{
		string text = Path.Combine(originals, sha + ".dll");
		if (!File.Exists(text))
		{
			Directory.CreateDirectory(originals);
			File.WriteAllBytes(text + ".rptmp", bytes);
			File.Move(text + ".rptmp", text);
		}
	}

	private (string key, Dictionary<string, Entry> index) ReadIndex()
	{
		Dictionary<string, Entry> dictionary = new Dictionary<string, Entry>(StringComparer.Ordinal);
		if (!File.Exists(indexPath))
		{
			return (key: "", index: dictionary);
		}
		try
		{
			string[] source = File.ReadAllLines(indexPath);
			string item = source.FirstOrDefault((string l) => l.StartsWith("key\t"))?.Substring(4) ?? "";
			foreach (string[] item2 in from l in source
				where l.Length > 0 && !l.StartsWith("#") && !l.StartsWith("key\t")
				select l.Split(new char[1] { '\t' }))
			{
				if (item2.Length >= 6)
				{
					dictionary[item2[0]] = new Entry
					{
						Size = long.Parse(item2[1]),
						Time = long.Parse(item2[2]),
						Sha = item2[3],
						Orig = item2[4],
						Result = item2[5],
						Note = ((item2.Length > 6) ? item2[6] : "")
					};
				}
			}
			return (key: item, index: dictionary);
		}
		catch (Exception ex)
		{
			log.LogWarning((object)(indexPath + " is unreadable (" + ex.Message + "); checking every mod"));
			return (key: "", index: new Dictionary<string, Entry>(StringComparer.Ordinal));
		}
	}

	private void WriteIndex(string key, SortedDictionary<string, Entry> index)
	{
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append("# rounds-port AutoFix: mods checked at the last start. Delete this file to check them all again.\n");
		stringBuilder.Append("key\t").Append(key).Append('\n');
		foreach (KeyValuePair<string, Entry> item in index)
		{
			stringBuilder.Append(string.Join("\t", item.Key, item.Value.Size, item.Value.Time, item.Value.Sha, item.Value.Orig, item.Value.Result, item.Value.Note)).Append('\n');
		}
		File.WriteAllText(indexPath + ".rptmp", stringBuilder.ToString());
		if (File.Exists(indexPath))
		{
			File.Delete(indexPath);
		}
		File.Move(indexPath + ".rptmp", indexPath);
	}

	internal static string Sha(byte[] bytes)
	{
		using SHA256 sHA = SHA256.Create();
		return BitConverter.ToString(sHA.ComputeHash(bytes)).Replace("-", "").ToLowerInvariant();
	}

	private static string OneLine(string s)
	{
		return s.Replace('\t', ' ').Replace('\r', ' ').Replace('\n', ' ');
	}

	private static void TryDelete(string path)
	{
		try
		{
			File.Delete(path);
		}
		catch
		{
		}
	}
}
internal sealed class Curated(string cache, ManualLogSource log)
{
	private sealed record Port(string File, string Sha, string Package);

	private sealed record Patch(string Name, string Before, string After, string Resource);

	private static readonly Port[] Ports = new Port[3]
	{
		new Port("UnboundLib.dll", "2eecd826d889cc1dda5efc0433bc77ab9bafa85cacc00323f3a8c7de79558154", "UnboundLib 4 (https://github.com/Bknibb/UnboundLib/releases)"),
		new Port("MMHOOK_Assembly-CSharp.dll", "926b53b329d94f6a8842e6d51ca17ff96f081df59695d7862845d5ccce9e5a62", "UnboundLib 4 (https://github.com/Bknibb/UnboundLib/releases)"),
		new Port("RoundsWithFriends.dll", "1bd4d5aa47de0e04661710a77bb0b5f1214dac4b3baabc9364b3418ecbc8ab61", "RoundsWithFriends 3 (https://github.com/Bknibb/RoundsWithFriends/releases)")
	};

	private static readonly Dictionary<string, Patch> Patches = ReadPatches();

	private readonly Dictionary<string, (string Path, string From)> needed = new Dictionary<string, (string, string)>(StringComparer.OrdinalIgnoreCase);

	private static bool OnMac
	{
		get
		{
			PlatformID platform = Environment.OSVersion.Platform;
			if (platform == PlatformID.Unix || platform == PlatformID.MacOSX)
			{
				return true;
			}
			return false;
		}
	}

	public IEnumerable<string> Plan(IEnumerable<string> pluginFiles)
	{
		foreach (IGrouping<string, string> g in pluginFiles.GroupBy<string, string>(Path.GetFileName, StringComparer.OrdinalIgnoreCase))
		{
			Port port = Ports.FirstOrDefault((Port p) => p.File.Equals(g.Key, StringComparison.OrdinalIgnoreCase));
			if (port == null)
			{
				continue;
			}
			List<(string, byte[])> source = g.Select((string f) => (path: f, bytes: File.ReadAllBytes(f))).ToList();
			if (!source.Any<(string, byte[])>(((string path, byte[] bytes) c) => IsOld(c.path, c.bytes)))
			{
				continue;
			}
			(string, byte[]) tuple = (from c in source
				where !IsOld(c.path, c.bytes)
				orderby AutoFix.Sha(c.bytes) == port.Sha descending
				select c).FirstOrDefault();
			if (tuple.Item1 != null)
			{
				needed[port.File] = (tuple.Item1, Short(tuple.Item1));
				continue;
			}
			Patch value;
			List<(string, byte[], Patch)> source2 = (from c in source
				where IsOld(c.path, c.bytes)
				select (path: c.path, bytes: c.bytes, patch: Patches.TryGetValue(g.Key + "\t" + AutoFix.Sha(c.bytes), out value) ? value : null)).ToList();
			(string, byte[], Patch) tuple2 = source2.FirstOrDefault<(string, byte[], Patch)>(((string path, byte[] bytes, Patch patch) o) => o.patch != null);
			Patch item = tuple2.Item3;
			if ((object)item != null)
			{
				string text = Path.Combine(cache, "ports", item.After + ".dll");
				if (!File.Exists(text) || AutoFix.Sha(File.ReadAllBytes(text)) != item.After)
				{
					byte[] bytes = Bspatch(tuple2.Item2, Resource(item));
					if (AutoFix.Sha(bytes) != item.After)
					{
						log.LogWarning((object)("the curated patch for " + g.Key + " gave the wrong file; left as it is"));
						continue;
					}
					Directory.CreateDirectory(Path.GetDirectoryName(text));
					File.WriteAllBytes(text, bytes);
				}
				needed[port.File] = (text, "curated patch " + item.Resource.Substring("curated/".Length));
			}
			foreach (var (path, bytes2, _) in source2.Where<(string, byte[], Patch)>(((string path, byte[] bytes, Patch patch) o) => o.patch == null && !needed.ContainsKey(port.File)))
			{
				log.LogWarning((object)(Short(path) + " is " + OldName(bytes2) + ", which DuctTape can't update: update it in your mod manager (or install Bknibb's " + port.Package + "). Until then, mods that need it won't load"));
			}
		}
		return needed.Values.Select<(string, string), string>(((string Path, string From) n) => n.Path);
	}

	public byte[] Apply(string path, byte[] bytes, string sha)
	{
		string fileName = Path.GetFileName(path);
		if (needed.TryGetValue(fileName, out (string, string) value) && IsOld(path, bytes))
		{
			log.LogInfo((object)(Short(path) + ": Bknibb's port in place of the old release (" + value.Item2 + ")"));
			bytes = File.ReadAllBytes(value.Item1);
			sha = AutoFix.Sha(bytes);
		}
		for (int i = 0; i < 4; i++)
		{
			if (!Patches.TryGetValue(fileName + "\t" + sha, out Patch value2))
			{
				break;
			}
			byte[] array = Bspatch(bytes, Resource(value2));
			if (AutoFix.Sha(array) != value2.After)
			{
				throw new InvalidDataException("the curated patch for " + fileName + " gave the wrong file");
			}
			log.LogInfo((object)(Short(path) + ": curated patch (" + value2.Resource.Substring("curated/".Length) + ")"));
			bytes = array;
			sha = value2.After;
		}
		return bytes;
	}

	private static string Short(string path)
	{
		return Path.GetFileName(Path.GetDirectoryName(path)) + "/" + Path.GetFileName(path);
	}

	private static byte[] Resource(Patch patch)
	{
		using Stream stream = typeof(Curated).Assembly.GetManifestResourceStream(patch.Resource);
		MemoryStream memoryStream = new MemoryStream();
		stream.CopyTo(memoryStream);
		return memoryStream.ToArray();
	}

	private static string OldName(byte[] bytes)
	{
		try
		{
			ModuleDefinition val = ModuleDefinition.ReadModule((Stream)new MemoryStream(bytes));
			try
			{
				return ((AssemblyNameReference)val.Assembly.Name).Name + " " + ((AssemblyNameReference)val.Assembly.Name).Version.ToString(3);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch
		{
			return "an old release";
		}
	}

	private static bool IsOld(string path, byte[] bytes)
	{
		try
		{
			ModuleDefinition val = ModuleDefinition.ReadModule((Stream)new MemoryStream(bytes));
			try
			{
				return val.Assembly != null && Game.OldLibrary(path, val.Assembly.Name) != null;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch
		{
			return false;
		}
	}

	private static Dictionary<string, Patch> ReadPatches()
	{
		Dictionary<string, Patch> dictionary = new Dictionary<string, Patch>(StringComparer.OrdinalIgnoreCase);
		using Stream stream = typeof(Curated).Assembly.GetManifestResourceStream("curated/patches.tsv");
		if (stream == null)
		{
			return dictionary;
		}
		string[] array = new StreamReader(stream).ReadToEnd().Split(new char[1] { '\n' });
		for (int i = 0; i < array.Length; i++)
		{
			string[] array2 = array[i].Split(new char[1] { '\t' });
			if ((array2.Length < 5 || !(array2[4].Trim() == "macos") || OnMac) && array2.Length >= 4)
			{
				dictionary[array2[0] + "\t" + array2[1]] = new Patch(array2[0], array2[1], array2[2], "curated/" + array2[3].Trim());
			}
		}
		return dictionary;
	}

	private static byte[] Bspatch(byte[] old, byte[] patch)
	{
		if (Encoding.ASCII.GetString(patch, 0, 8) != "BSDIFFDF")
		{
			throw new InvalidDataException("not a BSDIFFDF patch");
		}
		long num = Off(patch, 8L);
		long num2 = Off(patch, 16L);
		long num3 = Off(patch, 24L);
		using DeflateStream s = Block(patch, 32L, num);
		using DeflateStream s2 = Block(patch, 32 + num, num2);
		using DeflateStream s3 = Block(patch, 32 + num + num2, patch.Length - 32 - num - num2);
		byte[] array = new byte[num3];
		byte[] array2 = new byte[24];
		long num4 = 0L;
		long num5 = 0L;
		while (num5 < num3)
		{
			Fill(s, array2, 0L, 24L);
			long num6 = Off(array2, 0L);
			long num7 = Off(array2, 8L);
			long num8 = Off(array2, 16L);
			Fill(s2, array, num5, num6);
			for (long num9 = 0L; num9 < num6; num9++)
			{
				if (num4 + num9 >= 0 && num4 + num9 < old.Length)
				{
					array[num5 + num9] += old[num4 + num9];
				}
			}
			num5 += num6;
			num4 += num6;
			Fill(s3, array, num5, num7);
			num5 += num7;
			num4 += num8;
		}
		return array;
	}

	private static DeflateStream Block(byte[] b, long at, long len)
	{
		return new DeflateStream(new MemoryStream(b, (int)at, (int)len), CompressionMode.Decompress);
	}

	private static void Fill(Stream s, byte[] into, long at, long len)
	{
		while (len > 0)
		{
			int num = s.Read(into, (int)at, (int)Math.Min(len, 2147483647L));
			if (num <= 0)
			{
				throw new InvalidDataException("the patch is cut short");
			}
			at += num;
			len -= num;
		}
	}

	private static long Off(byte[] b, long at)
	{
		long num = BitConverter.ToInt64(b, (int)at);
		if (num >= 0)
		{
			return num;
		}
		return -(num & 0x7FFFFFFFFFFFFFFFL);
	}
}
public static class AutoFixPatcher
{
	public static IEnumerable<string> TargetDLLs { get; } = new string[0];

	public static void Patch(AssemblyDefinition assembly)
	{
	}

	public static void Initialize()
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		ManualLogSource val = Logger.CreateLogSource("rounds-port");
		try
		{
			ConfigEntry<bool> val2 = ((ConfigFile)typeof(ConfigFile).GetProperty("CoreConfig", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null)).Bind<bool>("Chainloader", "HideManagerGameObject", false, (ConfigDescription)null);
			if (!val2.Value)
			{
				val2.Value = true;
				val.LogInfo((object)"turned on HideManagerGameObject in BepInEx.cfg");
			}
		}
		catch (Exception ex)
		{
			val.LogWarning((object)("couldn't turn on HideManagerGameObject: " + ex.Message));
		}
		try
		{
			Run(val);
		}
		catch (Exception arg)
		{
			val.LogError((object)$"AutoFix failed, mods are left as they are: {arg}");
		}
	}

	private static void Run(ManualLogSource log)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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)
		ConfigFile val = new ConfigFile(Path.Combine(Paths.ConfigPath, "rounds-port.autofix.cfg"), true);
		ConfigEntry<bool> val2 = val.Bind<bool>("General", "Enabled", true, "Fix mods made for the game before its 2025 update while the game starts (rounds-port's fix, applied in place).");
		ConfigEntry<string> val3 = val.Bind<string>("General", "Exclude", "", "Mods never to touch, comma-separated: DLL names (MapsExtended.dll) or folder names (olavim-MapsExtended). A mod fixed earlier gets its original back.");
		ConfigEntry<bool> val4 = val.Bind<bool>("General", "RestoreOriginals", false, "Put back the original of every mod AutoFix changed, then turn AutoFix off (Enabled = false).");
		AutoFix autoFix = new AutoFix(new AutoFix.Settings(Paths.GameRootPath, Paths.ManagedPath, Paths.BepInExAssemblyDirectory, Paths.PluginPath, Path.Combine(Paths.CachePath, "rounds-port"), List(val3.Value)), log);
		if (val4.Value)
		{
			autoFix.RestoreOriginals();
			val4.Value = false;
			val2.Value = false;
		}
		else if (!val2.Value)
		{
			log.LogInfo((object)"AutoFix is off (Enabled in rounds-port.autofix.cfg)");
		}
		else
		{
			autoFix.Run();
		}
	}

	private static string[] List(string s)
	{
		return (from x in s.Split(new char[1] { ',' })
			select x.Trim() into x
			where x.Length > 0
			select x).ToArray();
	}
}
internal static class NetFrameworkPolyfills
{
	public static IEnumerable<(A First, B Second)> Zip<A, B>(this IEnumerable<A> a, IEnumerable<B> b)
	{
		return a.Zip(b, (A x, B y) => (x: x, y: y));
	}

	public static bool TryAdd<K, V>(this Dictionary<K, V> d, K key, V value)
	{
		if (d.ContainsKey(key))
		{
			return false;
		}
		d.Add(key, value);
		return true;
	}

	public static bool Remove<K, V>(this Dictionary<K, V> d, K key, out V value)
	{
		if (d.TryGetValue(key, out value))
		{
			d.Remove(key);
			return true;
		}
		return false;
	}
}
internal enum Fix
{
	Auto,
	Review,
	Manual
}
internal sealed record Issue(Fix Fix, string Kind, string What, string Detail);
internal sealed class Scanner(Game game)
{
	public sealed record RpcSite(Instruction Newarr, Instruction Call, string Name, int Args, List<MethodDefinition> Targets);

	public sealed record ReflectSite(Instruction Ldstr, string Call, string Name, string? Problem, string? FixTo)
	{
		public bool Unsure { get; init; }
	}

	private readonly MapResolver resolver = game.Resolver;

	private readonly MetadataResolver md = new MetadataResolver((IAssemblyResolver)(object)game.Resolver);

	public readonly SortedSet<string> Unchecked = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

	private static readonly HashSet<string> ObjectLookups = new HashSet<string> { "FindObjectOfType", "FindObjectsOfType", "FindFirstObjectByType", "FindAnyObjectByType", "FindObjectsByType" };

	private static readonly HashSet<string> GameObjectLookups = new HashSet<string> { "Find", "FindWithTag", "FindGameObjectWithTag", "FindGameObjectsWithTag" };

	public const string DisabledPatch = "__RoundsCompat_Disabled_";

	private bool MissingModDependency(TypeReference t)
	{
		string text = TypeProblem(t);
		if (text == null || !text.StartsWith("assembly "))
		{
			return false;
		}
		string text2 = Scope(t);
		bool flag = text2.StartsWith("Sirenix.");
		if (!flag)
		{
			bool flag2;
			switch (text2)
			{
			case "UnboundLib":
			case "MMHOOK_Assembly-CSharp":
			case "Assembly-CSharp-firstpass":
			case "UnityEngine.TextCoreModule":
				flag2 = true;
				break;
			default:
				flag2 = false;
				break;
			}
			flag = flag2;
		}
		if (flag || File.Exists(Path.Combine(game.Managed, text2 + ".dll")))
		{
			return false;
		}
		Unchecked.Add(text2);
		return true;
	}

	public List<Issue> Scan(ModuleDefinition module)
	{
		//IL_066d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0672: Unknown result type (might be due to invalid IL or missing references)
		//IL_07b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_07c2: Invalid comparison between Unknown and I4
		//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e0: Invalid comparison between Unknown and I4
		List<Issue> issues = new List<Issue>();
		Unchecked.Clear();
		foreach (TypeReference typeReference in module.GetTypeReferences())
		{
			if (!MissingModDependency(typeReference))
			{
				string text = TypeProblem(typeReference);
				if (text != null)
				{
					Add(Known.Type(typeReference, Scope(typeReference), text, MovedTextCore(typeReference)));
				}
			}
		}
		foreach (MemberReference memberReference in module.GetMemberReferences())
		{
			if (memberReference.DeclaringType is ArrayType)
			{
				continue;
			}
			string text2 = null;
			TypeDefinition val = null;
			try
			{
				val = Resolve(memberReference.DeclaringType.GetElementType());
				if (val == null)
				{
					continue;
				}
				MethodReference val2 = (MethodReference)(object)((memberReference is MethodReference) ? memberReference : null);
				IMemberDefinition val4;
				if (val2 == null)
				{
					FieldReference val3 = (FieldReference)(object)((memberReference is FieldReference) ? memberReference : null);
					val4 = (IMemberDefinition)(object)((val3 == null) ? null : ResolveF(val3));
				}
				else
				{
					val4 = (IMemberDefinition)(object)ResolveM(val2);
				}
				if (val4 == null)
				{
					text2 = "not found" + Hints(val, memberReference.Name);
				}
				goto IL_013d;
			}
			catch (Exception ex)
			{
				text2 = ex.GetType().Name + ": " + ex.Message;
				goto IL_013d;
			}
			IL_013d:
			if (text2 != null)
			{
				TypeDefinition dt = val;
				string why = text2;
				MethodReference val5 = (MethodReference)(object)((memberReference is MethodReference) ? memberReference : null);
				Add(Known.Member(memberReference, dt, why, val5 != null && ResultDropped(module, val5)));
			}
		}
		foreach (TypeDefinition item in AllTypes(module))
		{
			Inheritance(module, item, Add);
			MethodDefinition val6 = PluginAwake(item);
			if (val6 != null)
			{
				string text3 = SceneLookupAtLoad(val6);
				if (text3 != null)
				{
					Add(new Issue(Fix.Auto, "behaviour", ((MemberReference)item).FullName + "::Awake finds scene objects at plugin load", text3 + ": BepInEx now starts plugins before the game has loaded any scene (on the old game the first scene was there), so this finds nothing. fix runs this Awake once the first scene has loaded"));
				}
			}
			foreach (var (harmonyInfo, list) in HarmonyPatches(item))
			{
				if (harmonyInfo.Type != null && MissingModDependency(harmonyInfo.Type))
				{
					continue;
				}
				string text4 = TargetProblem(harmonyInfo);
				if (text4 != null)
				{
					Add(Known.HarmonyTarget(harmonyInfo, text4, DamageSourceOverload(harmonyInfo) != null, TargetInPortedCode(harmonyInfo)));
					continue;
				}
				foreach (MethodDefinition item2 in list)
				{
					foreach (var (text5, text6, text7) in PatchParamProblems(harmonyInfo, item2))
					{
						Add(new Issue((text7 != null) ? Fix.Review : Fix.Manual, "harmony param", $"{((MemberReference)item).FullName}::{((MemberReference)item2).Name} ({text5}) -> {harmonyInfo}", text6 + ((text7 != null) ? ("; fix renames it to " + text7) : "")));
					}
				}
			}
			foreach (MethodDefinition item3 in ((IEnumerable<MethodDefinition>)item.Methods).Where((MethodDefinition m) => m.HasBody))
			{
				foreach (ReflectSite item4 in ReflectSites(item3))
				{
					if (item4.Problem != null)
					{
						Add(new Issue((item4.FixTo != null || item4.Unsure) ? Fix.Review : Fix.Manual, "reflection", ((MemberReference)item).FullName + "::" + ((MemberReference)item3).Name + " " + item4.Call + "(\"" + item4.Name + "\")", item4.Problem + ((item4.FixTo != null) ? ("; fix changes it to \"" + item4.FixTo + "\"") : "")));
					}
				}
				foreach (RpcSite r in RpcSites(item3))
				{
					if (r.Targets.Any((MethodDefinition x) => ((MethodReference)x).Parameters.Count == r.Args))
					{
						continue;
					}
					Add(new Issue((!OnlyMissingDamageSource(r)) ? Fix.Manual : Fix.Auto, "rpc", string.Format("{0}::{1} RPC(\"{2}\") with {3} argument{4}", ((MemberReference)item).FullName, ((MemberReference)item3).Name, r.Name, r.Args, (r.Args == 1) ? "" : "s"), "the game's version takes " + string.Join(" | ", r.Targets.Select((MethodDefinition x) => "(" + string.Join(", ", ((IEnumerable<ParameterDefinition>)((MethodReference)x).Parameters).Select((ParameterDefinition p) => ((MemberReference)((ParameterReference)p).ParameterType).Name)) + ")")) + ", and PUN drops RPCs with the wrong argument count" + (OnlyMissingDamageSource(r) ? "; fix appends DamageSource.Player" : Known.RpcNote(r))));
				}
				if (((MemberReference)item3).Name.StartsWith("__RoundsCompat_Disabled_"))
				{
					Add(new Issue(Fix.Review, "harmony", ((MemberReference)item).FullName + "::" + ((MemberReference)item3).Name, "rounds-port disabled this Harmony patch: its target is gone in the current game, and HarmonyX would have thrown on it and stopped PatchAll. " + (((MemberReference)item3).Name.StartsWith("__RoundsCompat_Disabled_CardBar_Update_") ? "rounds-port Runtime calls it every frame for each active CardBar, as CardBar.Update did" : "What it did is lost")));
				}
				Enumerator<Instruction> enumerator10 = item3.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator10.MoveNext())
					{
						Instruction current7 = enumerator10.Current;
						object operand = current7.Operand;
						FieldReference val7 = (FieldReference)((operand is FieldReference) ? operand : null);
						OpCode opCode;
						if (val7 != null && ((MemberReference)val7).Name == "cardName" && ((MemberReference)((MemberReference)val7).DeclaringType).FullName == "CardInfo" && IsGame(((MemberReference)val7).DeclaringType))
						{
							opCode = current7.OpCode;
							Add(((int)((OpCode)(ref opCode)).Code == 122) ? new Issue(Fix.Review, "behaviour", "CardInfo.cardName (write)", "private now. fix writes the private field, so name lookups still find it, but the title the game shows comes from localization: set that through UnboundLib's CustomCard") : new Issue(Fix.Auto, "behaviour", "CardInfo.cardName (read)", "private now, and empty for UnboundLib 4 cards (names moved to localization). fix reads it through a helper that falls back to the localized key, CardName, then the GameObject name"));
						}
						object operand2 = current7.Operand;
						FieldReference val8 = (FieldReference)((operand2 is FieldReference) ? operand2 : null);
						if (val8 != null)
						{
							FieldDefinition val9 = NowPrivate(val8);
							if (val9 != null)
							{
								Add(new Issue(Fix.Auto, "access", ((MemberReference)val9.DeclaringType).Name + "." + ((MemberReference)val9).Name + " (private now)", "the runtime throws FieldAccessException on it. fix reads and writes it through reflection"));
							}
						}
						if (IsDontDestroyOnLoad(current7) && RunsAtPluginLoad(item3))
						{
							Add(new Issue(Fix.Auto, "behaviour", ((MemberReference)item).FullName + "::" + ((MemberReference)item3).Name + " DontDestroyOnLoad at plugin load", "BepInEx starts plugins before the game loads its first scene, and that load destroys every object made earlier, DontDestroyOnLoad or not (MapsExtended's map object manager dies this way). fix also sets hideFlags DontSave on it, which keeps it"));
						}
						opCode = current7.OpCode;
						if ((int)((OpCode)(ref opCode)).Code == 113 && (string)current7.Operand == "GetRanomCard")
						{
							Add(new Issue(Fix.Auto, "reflection", ((MemberReference)item).FullName + "::" + ((MemberReference)item3).Name + " \"GetRanomCard\"", "the typo was fixed: CardChoice.GetRandomCard"));
						}
					}
				}
				finally
				{
					((IDisposable)enumerator10/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}
		return issues;
		void Add(Issue i)
		{
			if (!issues.Contains(i))
			{
				issues.Add(i);
			}
		}
	}

	private void Inheritance(ModuleDefinition module, TypeDefinition t, Action<Issue> add)
	{
		if (t.BaseType == null || t.IsInterface)
		{
			return;
		}
		List<TypeDefinition> list = new List<TypeDefinition>();
		for (TypeDefinition val = Resolve(t.BaseType); val != null; val = ((val.BaseType == null) ? null : Resolve(val.BaseType)))
		{
			list.Add(val);
		}
		if (!list.Any((TypeDefinition val2) => ((AssemblyNameReference)((MemberReference)val2).Module.Assembly.Name).Name != ((AssemblyNameReference)module.Assembly.Name).Name && !((AssemblyNameReference)((MemberReference)val2).Module.Assembly.Name).Name.StartsWith("UnityEngine") && ((AssemblyNameReference)((MemberReference)val2).Module.Assembly.Name).Name != "mscorlib"))
		{
			return;
		}
		List<TypeDefinition> list2 = new List<TypeDefinition> { t };
		list2.AddRange(list);
		if (!t.IsAbstract)
		{
			foreach (TypeDefinition b in list)
			{
				foreach (MethodDefinition am in ((IEnumerable<MethodDefinition>)b.Methods).Where((MethodDefinition x) => x.IsAbstract))
				{
					if (!list2.TakeWhile((TypeDefinition x) => x != b).Any((TypeDefinition x) => ((IEnumerable<MethodDefinition>)x.Methods).Any((MethodDefinition val2) => ((MemberReference)val2).Name == ((MemberReference)am).Name && !val2.IsAbstract && SigEq(val2, am))))
					{
						add(new Issue(Fix.Manual, "override", ((MemberReference)t).FullName + " doesn't implement " + ((MemberReference)am).FullName, "TypeLoadException when the type loads: the base method changed (e.g. the damage methods gained a HealthHandler.DamageSource parameter). Update your override"));
					}
				}
			}
		}
		foreach (MethodDefinition m in ((IEnumerable<MethodDefinition>)t.Methods).Where((MethodDefinition val2) => val2.IsVirtual && !val2.IsNewSlot && !val2.IsAbstract))
		{
			if (list.Any((TypeDefinition val2) => ((IEnumerable<MethodDefinition>)val2.Methods).Any((MethodDefinition x) => x.IsVirtual && ((MemberReference)x).Name == ((MemberReference)m).Name && SigEq(m, x))) || !list.Any((TypeDefinition val2) => IsGame(val2) && ((IEnumerable<MethodDefinition>)val2.Methods).Any((MethodDefinition x) => ((MemberReference)x).Name == ((MemberReference)m).Name)))
			{
				continue;
			}
			add(new Issue(Fix.Manual, "override", ((MemberReference)t).FullName + "::" + ((MemberReference)m).Name, "no longer overrides anything; the game now has: " + string.Join(" | ", from x in list.SelectMany((TypeDefinition val2) => ((IEnumerable<MethodDefinition>)val2.Methods).Where((MethodDefinition x) => ((MemberReference)x).Name == ((MemberReference)m).Name))
				select ((MemberReference)x).FullName)));
		}
	}

	public IEnumerable<(HarmonyInfo info, List<MethodDefinition> methods)> HarmonyPatches(TypeDefinition t)
	{
		if (((IEnumerable<MethodDefinition>)t.Methods).Any(delegate(MethodDefinition m)
		{
			string name = ((MemberReference)m).Name;
			return (name == "TargetMethod" || name == "TargetMethods") ? true : false;
		}))
		{
			yield break;
		}
		HarmonyInfo classAttr = HarmonyInfo.From((IEnumerable<CustomAttribute>)t.CustomAttributes);
		List<MethodDefinition> own = ((IEnumerable<MethodDefinition>)t.Methods).Where((MethodDefinition m) => ((IEnumerable<CustomAttribute>)m.CustomAttributes).Any((CustomAttribute a) => ((MemberReference)a.AttributeType).Name == "HarmonyPatch")).ToList();
		if (classAttr != null && own.Count == 0)
		{
			yield return (info: classAttr, methods: ((IEnumerable<MethodDefinition>)t.Methods).Where(IsPatchMethod).ToList());
		}
		bool classType = classAttr?.Type != null || classAttr?.TypeName != null;
		foreach (MethodDefinition pm in own)
		{
			List<HarmonyInfo> each = (from a in (IEnumerable<CustomAttribute>)pm.CustomAttributes
				where ((MemberReference)a.AttributeType).Name == "HarmonyPatch"
				select HarmonyInfo.From((IEnumerable<CustomAttribute>)(object)new CustomAttribute[1] { a })).ToList();
			List<HarmonyInfo> list = each.Where(Complete).ToList();
			IEnumerable<HarmonyInfo> enumerable2;
			if (list.Count <= 1)
			{
				IEnumerable<HarmonyInfo> enumerable = new HarmonyInfo[1] { HarmonyInfo.From((IEnumerable<CustomAttribute>)pm.CustomAttributes) };
				enumerable2 = enumerable;
			}
			else
			{
				enumerable2 = list.Select((HarmonyInfo c) => each.Where((HarmonyInfo x) => !Complete(x)).Append(c).Aggregate(HarmonyInfo.Merge));
			}
			IEnumerable<HarmonyInfo> enumerable3 = enumerable2;
			foreach (HarmonyInfo item in enumerable3)
			{
				yield return (info: (classAttr != null) ? HarmonyInfo.Merge(classAttr, item) : item, methods: new List<MethodDefinition> { pm });
			}
		}
		bool Complete(HarmonyInfo x)
		{
			if (x.Method != null)
			{
				if (!classType && x.Type == null)
				{
					return x.TypeName != null;
				}
				return true;
			}
			return false;
		}
		static bool IsPatchMethod(MethodDefinition m)
		{
			bool flag;
			switch (((MemberReference)m).Name)
			{
			case "Prefix":
			case "Postfix":
			case "Finalizer":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (!flag)
			{
				return ((IEnumerable<CustomAttribute>)m.CustomAttributes).Any(delegate(CustomAttribute a)
				{
					switch (((MemberReference)a.AttributeType).Name)
					{
					case "HarmonyPrefix":
					case "HarmonyPostfix":
					case "HarmonyFinalizer":
						return true;
					default:
						return false;
					}
				});
			}
			return true;
		}
	}

	public TypeDefinition? TargetType(HarmonyInfo h)
	{
		if (h.Type == null)
		{
			if (h.TypeName == null)
			{
				return null;
			}
			return FindType(h.TypeName);
		}
		return Resolve(h.Type);
	}

	public string? TargetProblem(HarmonyInfo h)
	{
		if (h.Type == null && h.TypeName == null)
		{
			return null;
		}
		TypeDefinition val = TargetType(h);
		if (val == null)
		{
			return "target type not found";
		}
		int valueOrDefault = h.MethodType.GetValueOrDefault();
		switch (valueOrDefault)
		{
		case 3:
			if (!((IEnumerable<MethodDefinition>)val.Methods).Any((MethodDefinition m) => m.IsConstructor && !m.IsStatic && ArgsMatch(m, h.ArgTypes)))
			{
				return "constructor with those arguments not found";
			}
			return null;
		case 4:
			if (!((IEnumerable<MethodDefinition>)val.Methods).Any((MethodDefinition m) => m.IsConstructor && m.IsStatic))
			{
				return "static constructor not found";
			}
			return null;
		default:
			if (h.Method == null)
			{
				return null;
			}
			switch (valueOrDefault)
			{
			case 1:
				if (!HasMember(val, h.Method, "Getter"))
				{
					return "property getter not found" + Hints(val, h.Method);
				}
				return null;
			case 2:
				if (!HasMember(val, h.Method, "Setter"))
				{
					return "property setter not found" + Hints(val, h.Method);
				}
				return null;
			default:
			{
				for (TypeDefinition val2 = val; val2 != null; val2 = ((val2.BaseType == null) ? null : Resolve(val2.BaseType)))
				{
					List<MethodDefinition> list = ((IEnumerable<MethodDefinition>)val2.Methods).Where((MethodDefinition m) => ((MemberReference)m).Name == h.Method).ToList();
					if (list.Count != 0)
					{
						if (h.ArgTypes == null)
						{
							if (list.Count <= 1 || list.Any((MethodDefinition c) => ((MethodReference)c).Parameters.Count == 0))
							{
								return null;
							}
							return "ambiguous: Harmony throws AmbiguousMatchException. Add argumentTypes, one of: " + string.Join(" | ", list.Select((MethodDefinition c) => ((MemberReference)c).FullName));
						}
						if (list.Any((MethodDefinition m) => ArgsMatch(m, h.ArgTypes)))
						{
							return null;
						}
						return "no overload with those argumentTypes; the game has: " + string.Join(" | ", list.Select((MethodDefinition c) => ((MemberReference)c).FullName));
					}
				}
				return "method not found" + Hints(val, h.Method);
			}
			}
		}
	}

	public bool TargetInPortedCode(HarmonyInfo h)
	{
		TypeDefinition? obj = TargetType(h);
		object obj2 = ((obj != null) ? ((AssemblyNameReference)((MemberReference)obj).Module.Assembly.Name).Name : null);
		if (obj2 == null)
		{
			TypeReference? type = h.Type;
			if (type == null)
			{
				obj2 = null;
			}
			else
			{
				IMetadataScope scope = type.Scope;
				obj2 = ((scope != null) ? scope.Name : null);
			}
		}
		string text = (string)obj2;
		if (text != null)
		{
			TypeReference? type2 = h.Type;
			if (!(((type2 != null) ? type2.Scope : null) is ModuleDefinition))
			{
				bool flag = text.StartsWith("Assembly-CSharp") || text.StartsWith("UnityEngine") || text.StartsWith("Unity.") || text.StartsWith("Photon");
				if (!flag)
				{
					bool flag2;
					switch (text)
					{
					case "UnboundLib":
					case "RoundsWithFriends":
					case "MMHOOK_Assembly-CSharp":
						flag2 = true;
						break;
					default:
						flag2 = false;
						break;
					}
					flag = flag2;
				}
				return flag;
			}
		}
		return false;
	}

	public MethodDefinition? DamageSourceOverload(HarmonyInfo h)
	{
		if (h.ArgTypes != null && h.Method != null && h.MethodType.GetValueOrDefault() == 0)
		{
			TypeDefinition val = TargetType(h);
			if (val != null && IsGame(val))
			{
				List<MethodDefinition> list = ((IEnumerable<MethodDefinition>)val.Methods).Where((MethodDefinition m) => ((MemberReference)m).Name == h.Method).ToList();
				if (list.Count == 0 || list.Any((MethodDefinition m) => ArgsMatch(m, h.ArgTypes)))
				{
					return null;
				}
				return ((IEnumerable<MethodDefinition>)list).FirstOrDefault((Func<MethodDefinition, bool>)delegate(MethodDefinition m)
				{
					if (((MethodReference)m).Parameters.Count == h.ArgTypes.Count + 1)
					{
						Collection<ParameterDefinition> parameters = ((MethodReference)m).Parameters;
						if (((MemberReference)((ParameterReference)parameters[parameters.Count - 1]).ParameterType).FullName == "HealthHandler/DamageSource")
						{
							List<TypeReference>? argTypes = h.ArgTypes;
							Collection<ParameterDefinition> parameters2 = ((MethodReference)m).Parameters;
							return ArgsMatch(m, argTypes.Append(((ParameterReference)parameters2[parameters2.Count - 1]).ParameterType).ToList());
						}
					}
					return false;
				});
			}
		}
		return null;
	}

	public bool OnHoverAmbiguous(HarmonyInfo h)
	{
		if (h.ArgTypes == null && h.Method == "OnHover" && h.MethodType.GetValueOrDefault() == 0)
		{
			TypeDefinition val = TargetType(h);
			if (val != null && ((MemberReference)val).FullName == "CardBar")
			{
				return ((IEnumerable<MethodDefinition>)val.Methods).Count((MethodDefinition m) => ((MemberReference)m).Name == "OnHover") > 1;
			}
		}
		return false;
	}

	public IEnumerable<(string param, string problem, string? fixTo)> PatchParamProblems(HarmonyInfo h, MethodDefinition patch)
	{
		TypeDefinition td = TargetType(h);
		if (td == null || ((MemberReference)patch).Name == "Transpiler" || ((IEnumerable<CustomAttribute>)patch.CustomAttributes).Any((CustomAttribute a) => ((MemberReference)a.AttributeType).Name == "HarmonyTranspiler"))
		{
			yield break;
		}
		int valueOrDefault = h.MethodType.GetValueOrDefault();
		List<MethodDefinition> list = new List<MethodDefinition>();
		TypeDefinition val = td;
		while (val != null && list.Count == 0)
		{
			switch (valueOrDefault)
			{
			case 3:
				list.AddRange(((IEnumerable<MethodDefinition>)val.Methods).Where((MethodDefinition m) => m.IsConstructor && !m.IsStatic && ArgsMatch(m, h.ArgTypes)));
				break;
			case 1:
				list.AddRange(from p in (IEnumerable<PropertyDefinition>)val.Properties
					where ((MemberReference)p).Name == h.Method && p.GetMethod != null
					select p.GetMethod);
				break;
			case 2:
				list.AddRange(from p in (IEnumerable<PropertyDefinition>)val.Properties
					where ((MemberReference)p).Name == h.Method && p.SetMethod != null
					select p.SetMethod);
				break;
			default:
				if (h.Method != null)
				{
					list.AddRange(((IEnumerable<MethodDefinition>)val.Methods).Where((MethodDefinition m) => ((MemberReference)m).Name == h.Method && ArgsMatch(m, h.ArgTypes)));
				}
				break;
			}
			val = ((val.BaseType == null) ? null : Resolve(val.BaseType));
		}
		if (list.Count != 1)
		{
			yield break;
		}
		MethodDefinition target = list[0];
		string fullName = ((MemberReference)((MethodReference)patch).ReturnType).FullName;
		bool flag = ((fullName == "System.Void" || fullName == "System.Boolean") ? true : false);
		bool flag2 = !flag && ((MethodReference)patch).Parameters.Count > 0 && ((MemberReference)((ParameterReference)((MethodReference)patch).Parameters[0]).ParameterType).FullName == ((MemberReference)((MethodReference)patch).ReturnType).FullName;
		foreach (ParameterDefinition item in ((IEnumerable<ParameterDefinition>)((MethodReference)patch).Parameters).Skip(flag2 ? 1 : 0))
		{
			string n = ((ParameterReference)item).Name;
			if (((IEnumerable<CustomAttribute>)item.CustomAttributes).Any((CustomAttribute a) => ((MemberReference)a.AttributeType).Name == "HarmonyArgument"))
			{
				continue;
			}
			if (n.StartsWith("___"))
			{
				fullName = n;
				string text = fullName.Substring(3, fullName.Length - 3);
				if (FieldOn(td, text) == null)
				{
					yield return (param: n, problem: "field '" + text + "' isn't on " + ((MemberReference)td).Name + Hints(td, text), fixTo: (FieldOn(td, "m_" + text) != null) ? ("___m_" + text) : null);
				}
				continue;
			}
			switch (n)
			{
			case "__instance":
			case "__result":
			case "__state":
			case "__originalMethod":
			case "__args":
			case "__runOriginal":
			case "__exception":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag)
			{
				continue;
			}
			if (n.StartsWith("__"))
			{
				fullName = n;
				if (int.TryParse(fullName.Substring(2, fullName.Length - 2), out var _))
				{
					continue;
				}
			}
			ParameterDefinition val2 = ((IEnumerable<ParameterDefinition>)((MethodReference)target).Parameters).FirstOrDefault((Func<ParameterDefinition, bool>)((ParameterDefinition x) => ((ParameterReference)x).Name == n));
			if (val2 == null && n == "card" && ((MemberReference)((ParameterReference)item).ParameterType).FullName == "CardInfo" && IsHoverByButton(target))
			{
				yield return (param: n, problem: "OnHover takes the hovered CardBarButton (cardButton) now, and its m_cardInfo is the card; fix reads that wherever the patch used card. The game's OnHover now also sets DoesHover and moves the selection marker, which a prefix returning false skips", fixTo: "cardButton");
				continue;
			}
			if (val2 == null)
			{
				yield return (param: n, problem: "the target has no parameter with that name; it has (" + string.Join(", ", ((IEnumerable<ParameterDefinition>)((MethodReference)target).Parameters).Select((ParameterDefinition x) => ((MemberReference)((ParameterReference)x).ParameterType).Name + " " + ((ParameterReference)x).Name)) + ")", fixTo: null);
				continue;
			}
			TypeReference parameterType = ((ParameterReference)item).ParameterType;
			ByReferenceType val3 = (ByReferenceType)(object)((parameterType is ByReferenceType) ? parameterType : null);
			TypeReference val4 = ((val3 != null) ? ((TypeSpecification)val3).ElementType : ((ParameterReference)item).ParameterType);
			TypeReference parameterType2 = ((ParameterReference)val2).ParameterType;
			ByReferenceType val5 = (ByReferenceType)(object)((parameterType2 is ByReferenceType) ? parameterType2 : null);
			TypeReference val6 = ((val5 != null) ? ((TypeSpecification)val5).ElementType : ((ParameterReference)val2).ParameterType);
			if (((MemberReference)val4).FullName != ((MemberReference)val6).FullName && ((MemberReference)val4).FullName != "System.Object")
			{
				yield return (param: n, problem: "type " + ((MemberReference)val4).Name + " doesn't match the target's " + ((MemberReference)val6).Name, fixTo: null);
			}
		}
	}

	public static bool IsHoverByButton(MethodDefinition m)
	{
		if (((MemberReference)m).Name == "OnHover" && ((MemberReference)m.DeclaringType).FullName == "CardBar" && ((MethodReference)m).Parameters.Count == 1)
		{
			return ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType).FullName == "CardBarButton";
		}
		return false;
	}

	private static bool ResultDropped(ModuleDefinition module, MethodReference m)
	{
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: 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_00a0: Invalid comparison between Unknown and I4
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Invalid comparison between Unknown and I4
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Invalid comparison between Unknown and I4
		if (((MemberReference)m.ReturnType).FullName == "System.Void")
		{
			return false;
		}
		int num = 0;
		foreach (TypeDefinition item in AllTypes(module))
		{
			foreach (MethodDefinition item2 in ((IEnumerable<MethodDefinition>)item.Methods).Where((MethodDefinition x) => x.HasBody))
			{
				Enumerator<Instruction> enumerator3 = item2.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						Instruction current = enumerator3.Current;
						OpCode opCode = current.OpCode;
						Code code = ((OpCode)(ref opCode)).Code;
						if (((int)code != 39 && (int)code != 110) || 1 == 0)
						{
							continue;
						}
						object operand = current.Operand;
						MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
						if (val == null || !(((MemberReference)val).FullName == ((MemberReference)m).FullName))
						{
							continue;
						}
						Instruction next = current.Next;
						if (next != null)
						{
							opCode = next.OpCode;
							if ((int)((OpCode)(ref opCode)).Code == 37)
							{
								num++;
								continue;
							}
						}
						return false;
					}
				}
				finally
				{
					((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}
		return num > 0;
	}

	public string? MovedTextCore(TypeReference t)
	{
		if (((MemberReference)t).DeclaringType == null)
		{
			IMetadataScope scope = t.Scope;
			if (!(((scope != null) ? scope.Name : null) != "UnityEngine.TextCoreModule"))
			{
				string[] array = new string[2] { "UnityEngine.TextCoreFontEngineModule", "UnityEngine.TextCoreTextEngineModule" };
				foreach (string text in array)
				{
					AssemblyDefinition val = resolver.Get(text);
					if (val != null && val.MainModule.GetType(((MemberReference)t).FullName) != null)
					{
						return text;
					}
				}
				return null;
			}
		}
		return null;
	}

	public IEnumerable<RpcSite> RpcSites(MethodDefinition m)
	{
		foreach (Instruction item in ((IEnumerable<Instruction>)m.Body.Instructions).Where(delegate(Instruction i)
		{
			//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_0012: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			OpCode opCode2 = i.OpCode;
			Code code = ((OpCode)(ref opCode2)).Code;
			if (((int)code == 39 || (int)code == 110) ? true : false)
			{
				object operand = i.Operand;
				MethodReference val3 = (MethodReference)((operand is MethodReference) ? operand : null);
				if (val3 != null && ((MemberReference)val3).Name == "RPC")
				{
					return ((MemberReference)((MemberReference)val3).DeclaringType).Name == "PhotonView";
				}
			}
			return false;
		}))
		{
			Instruction val = null;
			Instruction val2 = null;
			for (Instruction previous = item.Previous; previous != null; previous = previous.Previous)
			{
				OpCode opCode = previous.OpCode;
				if ((int)((OpCode)(ref opCode)).Code == 138)
				{
					val2 = previous;
				}
				opCode = previous.OpCode;
				if ((int)((OpCode)(ref opCode)).Code == 113)
				{
					val = previous;
					break;
				}
			}
			if (val == null || val2 == null)
			{
				continue;
			}
			int? num = IntValue(val2.Previous);
			if (num.HasValue)
			{
				int valueOrDefault = num.GetValueOrDefault();
				string name = (string)val.Operand;
				List<MethodDefinition> list = (from x in AllTypes(game.AssemblyCSharp).SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
					where ((MemberReference)x).Name == name
					select x).ToList();
				if (list.Count > 0)
				{
					yield return new RpcSite(val2, item, name, valueOrDefault, list);
				}
			}
		}
	}

	public static int? IntValue(Instruction? i)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: 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_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected I4, but got Unknown
		Code? obj;
		if (i == null)
		{
			obj = null;
		}
		else
		{
			OpCode opCode = i.OpCode;
			obj = ((OpCode)(ref opCode)).Code;
		}
		return obj switch
		{
			(Code)0L => 0, 
			(Code)1L => 1, 
			(Code)2L => 2, 
			(Code)3L => 3, 
			(Code)4L => 4, 
			(Code)5L => 5, 
			(Code)6L => 6, 
			(Code)7L => 7, 
			(Code)8L => 8, 
			(Code)9L => (sbyte)i.Operand, 
			(Code)10L => (int)i.Operand, 
			_ => null, 
		};
	}

	public static bool OnlyMissingDamageSource(RpcSite s)
	{
		if (s.Targets.Count == 1 && ((MethodReference)s.Targets[0]).Parameters.Count == s.Args + 1)
		{
			Collection<ParameterDefinition> parameters = ((MethodReference)s.Targets[0]).Parameters;
			return ((MemberReference)((ParameterReference)parameters[parameters.Count - 1]).ParameterType).FullName == "HealthHandler/DamageSource";
		}
		return false;
	}

	public IEnumerable<ReflectSite> ReflectSites(MethodDefinition m)
	{
		Collection<Instruction> ins = m.Body.Instructions;
		for (int i = 0; i < ins.Count; i++)
		{
			OpCode opCode = ins[i].OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			if (((int)code != 39 && (int)code != 110) || 1 == 0)
			{
				continue;
			}
			object operand = ins[i].Operand;
			MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
			if (val == null)
			{
				continue;
			}
			string name = ((MemberReference)((MemberReference)val).DeclaringType).Name;
			string name2 = ((MemberReference)val).Name;
			bool flag = name == "AccessTools";
			if (flag)
			{
				bool flag2;
				switch (name2)
				{
				case "DeclaredMethod":
				case "PropertySetter":
				case "FieldRefAccess":
				case "PropertyGetter":
				case "DeclaredPropertyGetter":
				case "DeclaredPropertySetter":
				case "Method":
				case "Field":
				case "Property":
				case "DeclaredField":
				case "DeclaredProperty":
				case "StaticFieldRefAccess":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				flag = flag2;
			}
			bool flag3 = flag;
			flag = ((MemberReference)((MemberReference)val).DeclaringType).FullName == "System.Type";
			if (flag)
			{
				bool flag2;
				switch (name2)
				{
				case "GetMethod":
				case "GetField":
				case "GetProperty":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				flag = flag2;
			}
			bool flag4 = flag;
			flag = name == "Traverse";
			if (flag)
			{
				bool flag2;
				switch (name2)
				{
				case "Field":
				case "Method":
				case "Property":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				flag = flag2;
			}
			bool flag5 = flag;
			flag = ((MemberReference)((MemberReference)val).DeclaringType).FullName == "UnboundLib.ExtensionMethods";
			if (flag)
			{
				bool flag2;
				switch (name2)
				{
				case "GetFieldValue":
				case "SetFieldValue":
				case "GetPropertyValue":
				case "SetPropertyValue":
				case "InvokeMethod":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				flag = flag2;
			}
			bool flag6 = flag;
			if (!(flag3 || flag4 || flag5 || flag6))
			{
				continue;
			}
			Instruction val2 = FindLdstr(ins, i, 8);
			if (val2 == null)
			{
				continue;
			}
			string name3 = (string)val2.Operand;
			string kind = (name2.Contains("Field") ? "Field" : (name2.Contains("Propert") ? "Property" : "Method"));
			if (flag6)
			{
				int num = ins.IndexOf(val2);
				if (num < 1)
				{
					continue;
				}
				TypeReference val3 = PushedType(m, ins[num - 1]);
				if (val3 == null || ((MemberReference)val3).FullName == "System.Object" || val3.IsGenericParameter)
				{
					continue;
				}
				TypeDefinition val4 = Resolve(val3);
				if (val4 != null && !HasMember(val4, name3, kind))
				{
					string text = ((kind == "Field") ? (Renamed(((MemberReference)val4).Name, name3) ?? (HasMember(val4, "m_" + name3, "Field") ? ("m_" + name3) : null)) : null);
					if (text != null)
					{
						yield return new ReflectSite(val2, name + "." + name2, name3, kind.ToLower() + " " + ((MemberReference)val4).Name + "." + name3 + " not found", text);
					}
				}
				continue;
			}
			string call = name + "." + name2;
			if (name == "AccessTools" && name2 == "Method" && Enumerable.Contains(name3, ':'))
			{
				string[] array = name3.Split(new char[1] { ':' });
				TypeDefinition val5 = FindType(array[0]);
				yield return new ReflectSite(val2, call, name3, (val5 == null) ? "type not found" : (HasMember(val5, array[1], "Method") ? null : ("method not found" + Hints(val5, array[1]))), null);
				continue;
			}
			GenericInstanceMethod val6 = (GenericInstanceMethod)(object)((val is GenericInstanceMethod) ? val : null);
			TypeReference val7 = (TypeReference)((val6 != null && name2.Contains("FieldRefAccess")) ? ((object)val6.GenericArguments[0]) : ((object)FindLdtoken(ins, ins.IndexOf(val2), 6)));
			if (val7 == null)
			{
				if (!AnyGameTypeHas(name3, kind) && !AllTypes(((MemberReference)m).Module).Any((TypeDefinition t) => Has(t, name3, kind)))
				{
					string text2 = GameTypeWith("m_" + name3, "Field");
					yield return (text2 != null) ? new ReflectSite(val2, call, name3, "no " + kind.ToLower() + " named '" + name3 + "' anywhere; " + text2 + " has m_" + name3 + " (renamed?)", null) : new ReflectSite(val2, call, name3, "no game or mod type has a " + kind.ToLower() + " named '" + name3 + "'. The target type isn't known statically: if it's another mod's type this is fine, if it's the game's it was removed", null)
					{
						Unsure = true
					};
				}
			}
			else if (!val7.IsGenericParameter)
			{
				TypeDefinition val8 = Resolve(val7);
				if (val8 == null)
				{
					yield return new ReflectSite(val2, call, name3, "type " + ((MemberReference)val7).FullName + " not found", null);
				}
				else if (!HasMember(val8, name3, kind))
				{
					string fixTo = ((kind == "Field" && HasMember(val8, "m_" + name3, "Field")) ? ("m_" + name3) : null);
					yield return new ReflectSite(val2, call, name3, kind.ToLower() + " " + ((MemberReference)val8).Name + "." + name3 + " not found" + Hints(val8, name3), fixTo);
				}
			}
		}
	}

	public MethodDefinition? PluginAwake(TypeDefinition t)
	{
		return ((IEnumerable<MethodDefinition>)t.Methods).FirstOrDefault((Func<MethodDefinition, bool>)((MethodDefinition m) => ((MemberReference)m).Name == "Awake" && !m.IsStatic && !m.IsVirtual && ((MethodReference)m).Parameters.Count == 0 && m.HasBody && RunsAtPluginLoad(m)));
	}

	public string? SceneLookupAtLoad(MethodDefinition awake)
	{
		HashSet<MethodDefinition> seen = new HashSet<MethodDefinition>();
		return Walk(awake, ((MemberReference)awake.DeclaringType).Name + ".Awake", 0);
		string? Walk(MethodDefinition m, string path, int depth)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//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_004c: Invalid comparison between Unknown and I4
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			if (!seen.Add(m) || !m.HasBody)
			{
				return null;
			}
			Enumerator<Instruction> enumerator = m.Body.Instructions.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					OpCode opCode = current.OpCode;
					Code code = ((OpCode)(ref opCode)).Code;
					if (((int)code == 39 || (int)code == 110 || (int)code == 114) ? true : false)
					{
						object operand = current.Operand;
						MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
						if (val != null)
						{
							string fullName = ((MemberReference)((MemberReference)val).DeclaringType).FullName;
							if ((fullName == "UnityEngine.Object" && ObjectLookups.Contains(((MemberReference)val).Name)) || (fullName == "UnityEngine.GameObject" && GameObjectLookups.Contains(((MemberReference)val).Name)) || (fullName == "UnityEngine.Camera" && ((MemberReference)val).Name == "get_main"))
							{
								return path + " -> " + ((MemberReference)((MemberReference)val).DeclaringType).Name + "." + ((MemberReference)val).Name;
							}
							if (depth < 4)
							{
								MethodDefinition val2 = ResolveM(val);
								if (val2 != null && ((MemberReference)val2).Module == ((MemberReference)m).Module)
								{
									string text = Walk(val2, path + " > " + ((MemberReference)val2).Name, depth + 1);
									if (text != null)
									{
										return text;
									}
								}
							}
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			return null;
		}
	}

	public static bool IsDontDestroyOnLoad(Instruction ins)
	{
		//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_0012: Invalid comparison between Unknown and I4
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Invalid comparison between Unknown and I4
		OpCode opCode = ins.OpCode;
		Code code = ((OpCode)(ref opCode)).Code;
		if (((int)code == 39 || (int)code == 110) ? true : false)
		{
			object operand = ins.Operand;
			MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
			if (val != null && ((MemberReference)val).Name == "DontDestroyOnLoad")
			{
				return ((MemberReference)((MemberReference)val).DeclaringType).FullName == "UnityEngine.Object";
			}
		}
		return false;
	}

	public bool RunsAtPluginLoad(MethodDefinition m)
	{
		string name = ((MemberReference)m).Name;
		if ((!(name == "Awake") && !(name == ".ctor")) || 1 == 0)
		{
			return false;
		}
		for (TypeDefinition val = Resolve((TypeReference)(((object)m.DeclaringType.BaseType) ?? ((object)m.DeclaringType))); val != null; val = ((val.BaseType == null) ? null : Resolve(val.BaseType)))
		{
			if (((MemberReference)val).FullName == "BepInEx.BaseUnityPlugin")
			{
				return true;
			}
		}
		return false;
	}

	public TypeDefinition? Resolve(TypeReference t)
	{
		try
		{
			return t.Resolve();
		}
		catch
		{
			return null;
		}
	}

	private MethodDefinition? ResolveM(MethodReference m)
	{
		try
		{
			return md.Resolve(m);
		}
		catch
		{
			return null;
		}
	}

	private FieldDefinition? ResolveF(FieldReference f)
	{
		try
		{
			return md.Resolve(f);
		}
		catch
		{
			return null;
		}
	}

	public static FieldDefinition? NowPrivate(FieldReference f)
	{
		bool flag = !IsGame(((MemberReference)f).DeclaringType) || ((MemberReference)f).DeclaringType is GenericInstanceType;
		if (!flag)
		{
			string name = ((MemberReference)f).Name;
			bool flag2 = ((name == "cardName" || name == "cardDestription") ? true : false);
			flag = flag2;
		}
		if (flag)
		{
			return null;
		}
		FieldDefinition val;
		try
		{
			val = f.Resolve();
		}
		catch (AssemblyResolutionException)
		{
			return null;
		}
		if (val == null || ((TypeReference)val.DeclaringType).IsValueType || (!val.IsPrivate && !val.IsAssembly && !val.IsFamilyAndAssembly))
		{
			return null;
		}
		return val;
	}

	private static bool IsGame(TypeReference t)
	{
		while (((MemberReference)t).DeclaringType != null)
		{
			t = ((MemberReference)t).DeclaringType;
		}
		IMetadataScope scope = t.Scope;
		if (scope == null)
		{
			return false;
		}
		return scope.Name?.StartsWith("Assembly-CSharp") == true;
	}

	private static bool IsGame(TypeDefinition t)
	{
		return ((AssemblyNameReference)((MemberReference)t).Module.Assembly.Name).Name == "Assembly-CSharp";
	}

	private static string Scope(TypeReference t)
	{
		while (((MemberReference)t).DeclaringType != null)
		{
			t = ((MemberReference)t).DeclaringType;
		}
		IMetadataScope scope = t.Scope;
		return ((scope != null) ? scope.Name : null) ?? "?";
	}

	private string? TypeProblem(TypeReference t)
	{
		//IL_001f: Expected O, but got Unknown
		try
		{
			return (t.Resolve() == null) ? ("not in " + Scope(t)) : null;
		}
		catch (AssemblyResolutionException ex)
		{
			AssemblyResolutionException ex2 = ex;
			return "assembly " + ex2.AssemblyReference.Name + " not found";
		}
		catch (Exception ex3)
		{
			return ex3.Message;
		}
	}

	private FieldDefinition? FieldOn(TypeDefinition td, string name)
	{
		for (TypeDefinition val = td; val != null; val = ((val.BaseType == null) ? null : Resolve(val.BaseType)))
		{
			FieldDefinition val2 = ((IEnumerable<FieldDefinition>)val.Fields).FirstOrDefault((Func<FieldDefinition, bool>)((FieldDefinition f) => ((MemberReference)f).Name == name));
			if (val2 != null)
			{
				return val2;
			}
		}
		return null;
	}

	public string Hints(TypeDefinition td, string name)
	{
		List<string> list = new List<string>();
		for (TypeDefinition val = td; val != null; val = ((val.BaseType == null) ? null : Resolve(val.BaseType)))
		{
			list.AddRange(from x in (IEnumerable<MethodDefinition>)val.Methods
				where ((MemberReference)x).Name.Equals(name, StringComparison.OrdinalIgnoreCase) || ((MemberReference)x).Name == "get_" + name
				select ((MemberReference)x).FullName);
			list.AddRange(from x in (IEnumerable<FieldDefinition>)val.Fields
				where ((MemberReference)x).Name.Equals(name, StringComparison.OrdinalIgnoreCase) || ((MemberReference)x).Name.Equals("m_" + name, StringComparison.OrdinalIgnoreCase)
				select "field " + ((MemberReference)x).FullName);
			list.AddRange(from x in (IEnumerable<PropertyDefinition>)val.Properties
				where ((MemberReference)x).Name.Equals(name, StringComparison.OrdinalIgnoreCase)
				select "property " + ((MemberReference)x).FullName);
			if (((AssemblyNameReference)((MemberReference)val).Module.Assembly.Name).Name != ((AssemblyNameReference)((MemberReference)td).Module.Assembly.Name).Name)
			{
				break;
			}
		}
		if (list.Count != 0)
		{
			return " (the game has: " + string.Join("; ", list.Distinct()) + ")";
		}
		return "";
	}

	private bool HasMember(TypeDefinition td, string name, string kind)
	{
		for (TypeDefinition val = td; val != null; val = ((val.BaseType == null) ? null : Resolve(val.BaseType)))
		{
			if (Has(val, name, kind))
			{
				return true;
			}
			if (kind == "Getter" && ((IEnumerable<PropertyDefinition>)val.Properties).Any((PropertyDefinition p) => ((MemberReference)p).Name == name && p.GetMethod != null))
			{
				return true;
			}
			if (kind == "Setter" && ((IEnumerable<PropertyDefinition>)val.Properties).Any((PropertyDefinition p) => ((MemberReference)p).Name == name && p.SetMethod != null))
			{
				return true;
			}
		}
		return false;
	}

	private static bool Has(TypeDefinition t, string name, string kind)
	{
		if ((!(kind == "Field") || !((IEnumerable<FieldDefinition>)t.Fields).Any((FieldDefinition f) => ((MemberReference)f).Name == name)) && (!(kind == "Property") || !((IEnumerable<PropertyDefinition>)t.Properties).Any((PropertyDefinition p) => ((MemberReference)p).Name == name)))
		{
			if (kind == "Method")
			{
				return ((IEnumerable<MethodDefinition>)t.Methods).Any((MethodDefinition p) => ((MemberReference)p).Name == name);
			}
			return false;
		}
		return true;
	}

	public static IEnumerable<TypeDefinition> AllTypes(ModuleDefinition m)
	{
		Enumerator<TypeDefinition> enumerator = m.Types.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				TypeDefinition t = enumerator.Current;
				yield return t;
				foreach (TypeDefinition item in Nested(t))
				{
					yield return item;
				}
			}
		}
		finally
		{
			((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
		}
		static IEnumerable<TypeDefinition> Nested(TypeDefinition val)
		{
			Enumerator<TypeDefinition> enumerator3 = val.NestedTypes.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					TypeDefinition n = enumerator3.Current;
					yield return n;
					foreach (TypeDefinition item2 in Nested(n))
					{
						yield return item2;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
		}
	}

	private static Instruction? FindLdstr(Collection<Instruction> ins, int i, int back)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Invalid comparison between Unknown and I4
		int num = i - 1;
		while (num >= 0 && num >= i - back)
		{
			OpCode opCode = ins[num].OpCode;
			if ((int)((OpCode)(ref opCode)).Code == 113)
			{
				return ins[num];
			}
			num--;
		}
		return null;
	}

	private static string? Renamed(string type, string field)
	{
		if (type == "CardBarButton" && field == "card")
		{
			return "m_cardInfo";
		}
		return null;
	}

	private static TypeReference? PushedType(MethodDefinition m, Instruction p)
	{
		//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_000a: 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_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Invalid comparison between Unknown and I4
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Invalid comparison between Unknown and I4
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Invalid comparison between Unknown and I4
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Invalid comparison between Unknown and I4
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Invalid comparison between Unknown and I4
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Expected I4, but got Unknown
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Invalid comparison between Unknown and I4
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Invalid comparison between Unknown and I4
		//IL_015a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Expected O, but got Unknown
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Invalid comparison between Unknown and I4
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Expected I4, but got Unknown
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Expected I4, but got Unknown
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Invalid comparison between Unknown and I4
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Expected O, but got Unknown
		OpCode opCode = p.OpCode;
		Code code = ((OpCode)(ref opCode)).Code;
		if ((int)code <= 116)
		{
			if ((int)code <= 39)
			{
				switch (code - 2)
				{
				case 4:
				case 5:
				case 6:
				case 7:
				{
					Collection<VariableDefinition> variables = m.Body.Variables;
					opCode = p.OpCode;
					return ((VariableReference)variables[((OpCode)(ref opCode)).Code - 6]).VariableType;
				}
				case 15:
					goto IL_00dc;
				case 0:
				case 1:
				case 2:
				case 3:
					goto IL_00ed;
				case 12:
					goto IL_0126;
				case 8:
				case 9:
				case 10:
				case 11:
				case 13:
				case 14:
					goto IL_0199;
				}
				if ((int)code == 39)
				{
					goto IL_0154;
				}
			}
			else
			{
				if ((int)code == 110)
				{
					goto IL_0154;
				}
				if (code - 115 <= 1)
				{
					return (TypeReference)p.Operand;
				}
			}
		}
		else if ((int)code <= 123)
		{
			if ((int)code == 120 || (int)code == 123)
			{
				return ((FieldReference)p.Operand).FieldType;
			}
		}
		else
		{
			if ((int)code == 199)
			{
				goto IL_0126;
			}
			if ((int)code == 202)
			{
				goto IL_00dc;
			}
		}
		goto IL_0199;
		IL_00dc:
		return ((VariableReference)(VariableDefinition)p.Operand).VariableType;
		IL_0126:
		return ((ParameterReference)(ParameterDefinition)p.Operand).ParameterType;
		IL_00ed:
		opCode = p.OpCode;
		int num = ((OpCode)(ref opCode)).Code - 2 - ((MethodReference)m).HasThis;
		if (num >= 0)
		{
			return ((ParameterReference)((MethodReference)m).Parameters[num]).ParameterType;
		}
		return (TypeReference?)(object)m.DeclaringType;
		IL_0154:
		MethodReference val = (MethodReference)p.Operand;
		GenericInstanceMethod val2 = (GenericInstanceMethod)(object)((val is GenericInstanceMethod) ? val : null);
		if (val2 != null && val.ReturnType.IsGenericParameter && val2.GenericArguments.Count == 1)
		{
			return val2.GenericArguments[0];
		}
		return val.ReturnType;
		IL_0199:
		return null;
	}

	private static TypeReference? FindLdtoken(Collection<Instruction> ins, int i, int back)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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_0022: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: 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_005b: Invalid comparison between Unknown and I4
		int num = i - 1;
		MethodReference val2 = default(MethodReference);
		while (num >= 0 && num >= i - back)
		{
			OpCode opCode = ins[num].OpCode;
			if ((int)((OpCode)(ref opCode)).Code == 174)
			{
				object operand = ins[num].Operand;
				TypeReference val = (TypeReference)((operand is TypeReference) ? operand : null);
				if (val != null)
				{
					return val;
				}
			}
			opCode = ins[num].OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			int num2;
			if (((int)code == 39 || (int)code == 110) ? true : false)
			{
				object operand2 = ins[num].Operand;
				val2 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
				num2 = ((val2 != null) ? 1 : 0);
			}
			else
			{
				num2 = 0;
			}
			bool flag = (byte)num2 != 0;
			if (flag)
			{
				bool flag2;
				switch (((MemberReference)val2).Name)
				{
				case "GetMethod":
				case "GetField":
				case "GetProperty":
				case "Method":
				case "Field":
				case "Property":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				flag = flag2;
			}
			if (flag)
			{
				return null;
			}
			num--;
		}
		return null;
	}

	private TypeDefinition? FindType(string n)
	{
		foreach (AssemblyDefinition item in resolver.Loaded())
		{
			TypeDefinition type = item.MainModule.GetType(n);
			if (type != null)
			{
				return type;
			}
		}
		return ((IEnumerable<TypeDefinition>)game.AssemblyCSharp.Types).FirstOrDefault((Func<TypeDefinition, bool>)((TypeDefinition t) => ((MemberReference)t).Name == n));
	}

	private string? GameTypeWith(string name, string kind)
	{
		TypeDefinition? obj = AllTypes(game.AssemblyCSharp).FirstOrDefault((Func<TypeDefinition, bool>)((TypeDefinition t) => Has(t, name, kind)));
		if (obj == null)
		{
			return null;
		}
		return ((MemberReference)obj).FullName;
	}

	private bool AnyGameTypeHas(string name, string kind)
	{
		string[] array = new string[8] { "Assembly-CSharp", "UnityEngine.CoreModule", "UnityEngine.PhysicsModule", "UnityEngine.Physics2DModule", "UnityEngine.UI", "Unity.TextMeshPro", "PhotonUnityNetworking", "PhotonRealtime" };
		foreach (string name2 in array)
		{
			AssemblyDefinition val = resolver.Get(name2);
			if (val != null && AllTypes(val.MainModule).Any((TypeDefinition t) => Has(t, name, kind)))
			{
				return true;
			}
		}
		return false;
	}

	private static bool SigEq(MethodDefinition a, MethodDefinition b)
	{
		if (((MethodReference)a).Parameters.Count != ((MethodReference)b).Parameters.Count)
		{
			return false;
		}
		for (int i = 0; i < ((MethodReference)a).Parameters.Count; i++)
		{
			if (!Same(((ParameterReference)((MethodReference)a).Parameters[i]).ParameterType, ((ParameterReference)((MethodReference)b).Parameters[i]).ParameterType))
			{
				return false;
			}
		}
		return Same(((MethodReference)a).ReturnType, ((MethodReference)b).ReturnType);
		static bool Same(TypeReference x, TypeReference y)
		{
			if (!(((MemberReference)x).FullName == ((MemberReference)y).FullName) && !((MemberReference)x).ContainsGenericParameter)
			{
				return ((MemberReference)y).ContainsGenericParameter;
			}
			return true;
		}
	}

	private static bool ArgsMatch(MethodDefinition m, List<TypeReference>? args)
	{
		if (args == null)
		{
			return true;
		}
		if (((MethodReference)m).Parameters.Count != args.Count)
		{
			return false;
		}
		for (int i = 0; i < args.Count; i++)
		{
			TypeReference parameterType = ((ParameterReference)((MethodReference)m).Parameters[i]).ParameterType;
			ByReferenceType val = (ByReferenceType)(object)((parameterType is ByReferenceType) ? parameterType : null);
			if (((val != null) ? ((MemberReference)((TypeSpecification)val).ElementType).FullName : ((MemberReference)parameterType).FullName) != ((MemberReference)args[i]).FullName && ((MemberReference)parameterType).Name.TrimEnd(new char[1] { '&' }) != ((MemberReference)args[i]).Name)
			{
				return false;
			}
		}
		return true;
	}
}
internal sealed class HarmonyInfo
{
	public TypeReference? Type;

	public string? TypeName;

	public string? Method;

	public int? MethodType;

	public List<TypeReference>? ArgTypes;

	public override string ToString()
	{
		string[] array = new string[5];
		TypeReference? type = Type;
		array[0] = ((type != null) ? ((MemberReference)type).FullName : null) ?? TypeName ?? "?";
		array[1] = "::";
		array[2] = Method ?? "?";
		int? methodType = MethodType;
		object obj;
		if (methodType.HasValue)
		{
			int valueOrDefault = methodType.GetValueOrDefault();
			if (valueOrDefault != 0)
			{
				obj = $" [MethodType {valueOrDefault}]";
				goto IL_007c;
			}
		}
		obj = "";
		goto IL_007c;
		IL_007c:
		array[3] = (string)obj;
		array[4] = ((ArgTypes != null) ? ("(" + string.Join(",", ArgTypes.Select((TypeReference a) => ((MemberReference)a).Name)) + ")") : "");
		return string.Concat(array);
	}

	public static HarmonyInfo Merge(HarmonyInfo a, HarmonyInfo b)
	{
		return new HarmonyInfo
		{
			Type = (b.Type ?? a.Type),
			TypeName = (b.TypeName ?? a.TypeName),
			Method = (b.Method ?? a.Method),
			MethodType = (b.MethodType ?? a.MethodType),
			ArgTypes = (b.ArgTypes ?? a.ArgTypes)
		};
	}

	public static HarmonyInfo? From(IEnumerable<CustomAttribute> attrs)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		HarmonyInfo harmonyInfo = null;
		foreach (CustomAttribute item in attrs.Where((CustomAttribute a) => ((MemberReference)a.AttributeType).Name == "HarmonyPatch"))
		{
			if (harmonyInfo == null)
			{
				harmonyInfo = new HarmonyInfo();
			}
			bool flag = true;
			Enumerator<CustomAttributeArgument> enumerator2 = item.ConstructorArguments.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					CustomAttributeArgument current2 = enumerator2.Current;
					object value = ((CustomAttributeArgument)(ref current2)).Value;
					TypeReference val = (TypeReference)((value is TypeReference) ? value : null);
					if (val != null)
					{
						harmonyInfo.Type = val;
						continue;
					}
					if (value is string text)
					{
						CustomAttributeArgument val2;
						int num;
						if (item.ConstructorArguments.Count >= 2)
						{
							val2 = item.ConstructorArguments[0];
							num = ((((CustomAttributeArgument)(ref val2)).Value is string) ? 1 : 0);
						}
						else
						{
							num = 0;
						}
						if (((uint)num & (flag ? 1u : 0u)) != 0)
						{
							val2 = item.ConstructorArguments[1];
							if (((CustomAttributeArgument)(ref val2)).Value is string)
							{
								harmonyInfo.TypeName = text;
								goto IL_00ef;
							}
						}
						harmonyInfo.Method = text;
						goto IL_00ef;
					}
					if (((MemberReference)((CustomAttributeArgument)(ref current2)).Type).Name == "MethodType")
					{
						harmonyInfo.MethodType = Convert.ToInt32(value);
					}
					else if (value is CustomAttributeArgument[] array && array.Length != 0 && ((CustomAttributeArgument)(ref array[0])).Value is TypeReference)
					{
						harmonyInfo.ArgTypes = ((IEnumerable<CustomAttributeArgument>)array).Select((Func<CustomAttributeArgument, TypeReference>)((CustomAttributeArgument x) => (TypeReference)((CustomAttributeArgument)(ref x)).Value)).ToList();
					}
					else if (value is CustomAttributeArgument[] array2 && array2.Length == 0 && ((MemberReference)((CustomAttributeArgument)(ref current2)).Type.GetElementType()).FullName == "System.Type")
					{
						harmonyInfo.ArgTypes = new List<TypeReference>();
					}
					continue;
					IL_00ef:
					flag = false;
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
		}
		return harmonyInfo;
	}
}
internal sealed class Fixer
{
	private readonly ModuleDefinition M;

	private readonly ModuleDefinition Game;

	private readonly Scanner scanner;

	private readonly TypeDefinition HelperSrc;

	public readonly List<string> Notes = new List<string>();

	private readonly SortedDictionary<string, int> counts = new SortedDictionary<string, int>();

	private TypeDefinition? helper;

	private readonly Dictionary<string, MethodDefinition> helperMethods = new Dictionary<string, MethodDefinition>();

	public IEnumerable<string> Changes => counts.Select<KeyValuePair<string, int>, string>((KeyValuePair<string, int> kv) => (kv.Value <= 1) ? kv.Key : $"{kv.Key}  (x{kv.Value})");

	public bool Changed => counts.Count > 0;

	public Fixer(ModuleDefinition module, Game game, Scanner scanner)
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Expected O, but got Unknown
		M = module;
		Game = game.AssemblyCSharp;
		this.scanner = scanner;
		using Stream stream = typeof(Fixer).Assembly.GetManifestResourceStream("compathelpers.dll");
		MemoryStream memoryStream = new MemoryStream();
		stream.CopyTo(memoryStream);
		memoryStream.Position = 0L;
		HelperSrc = ModuleDefinition.ReadModule((Stream)memoryStream, new ReaderParameters
		{
			AssemblyResolver = (IAssemblyResolver)(object)game.Resolver
		}).GetType("__RoundsCompat");
	}

	public void Run()
	{
		Generic();
		RpcArgs();
		Renames();
		PluginLoad();
		SpawnObjectResults();
	}

	private void SpawnObjectResults()
	{
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Expected O, but got Unknown
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		foreach (MethodDefinition item in Bodies(M).ToList())
		{
			ParameterDefinition p = ((IEnumerable<ParameterDefinition>)((MethodReference)item).Parameters).FirstOrDefault((Func<ParameterDefinition, bool>)((ParameterDefinition x) => ((ParameterReference)x).Name == "__result"));
			if (p == null || !TargetsSpawnObject(item))
			{
				continue;
			}
			bool byRef = ((ParameterReference)p).ParameterType is ByReferenceType;
			if (((MemberReference)(byRef ? ((TypeSpecification)(ByReferenceType)((ParameterReference)p).ParameterType).ElementType : ((ParameterReference)p).ParameterType)).FullName != "UnityEngine.GameObject[]")
			{
				continue;
			}
			ArrayType val = new ArrayType(M.ImportReference((TypeReference)(object)GT("FriendlyFoe.PoolableWrapper")));
			MethodBody body = item.Body;
			ILProcessor iLProcessor = body.GetILProcessor();
			MethodBodyRocks.SimplifyMacros(body);
			List<Instruction> list = ((IEnumerable<Instruction>)body.Instructions).Where((Instruction i) => i.Operand == p).ToList();
			if (!list.All(delegate(Instruction i)
			{
				//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_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				if (i.OpCode == OpCodes.Ldarg)
				{
					if (byRef)
					{
						Instruction next = i.Next;
						OpCode? val2 = ((next != null) ? new OpCode?(next.OpCode) : ((OpCode?)null));
						OpCode ldind_Ref = OpCodes.Ldind_Ref;
						if (!val2.HasValue)
						{
							return false;
						}
						return val2.GetValueOrDefault() == ldind_Ref;
					}
					return true;
				}
				return false;
			}))
			{
				MethodBodyRocks.OptimizeMacros(body);
				Notes.Add("MANUAL " + ((MemberReference)item).FullName + ": writes SpawnObject's result (PoolableWrapper[] now); left as is");
				continue;
			}
			((ParameterReference)p).ParameterType = (TypeReference)((!byRef) ? ((object)val) : ((object)new ByReferenceType((TypeReference)(object)val)));
			foreach (Instruction item2 in list)
			{
				iLProcessor.InsertAfter(byRef ? item2.Next : item2, Instruction.Create(OpCodes.Call, Helper("PooledObjects")));
			}
			MethodBodyRocks.OptimizeMacros(body);
			Count(((MemberReference)item.DeclaringType).Name + "." + ((MemberReference)item).Name + ": SpawnObject result GameObject[] -> PoolableWrapper[] (reads get the objects)");
		}
	}

	private static bool TargetsSpawnObject(MethodDefinition md)
	{
		return ((IEnumerable<CustomAttribute>)md.CustomAttributes).Concat((IEnumerable<CustomAttribute>)md.DeclaringType.CustomAttributes).Any((CustomAttribute a) => ((MemberReference)a.AttributeType).Name == "HarmonyPatch" && ((IEnumerable<CustomAttributeArgument>)a.ConstructorArguments).Any(delegate(CustomAttributeArgument x)
		{
			object value = ((CustomAttributeArgument)(ref x)).Value;
			TypeReference val = (TypeReference)((value is TypeReference) ? value : null);
			return val != null && ((MemberReference)val).FullName == "ObjectsToSpawn";
		}) && ((IEnumerable<CustomAttributeArgument>)a.ConstructorArguments).Any((CustomAttributeArgument x) => ((CustomAttributeArgument)(ref x)).Value is string text && text == "SpawnObject"));
	}

	private void Count(string what)
	{
		counts.TryGetValue(what, out var value);
		counts[what] = value + 1;
	}

	private TypeDefinition GT(string full)
	{
		return Game.GetType(full) ?? throw new Exception("game type missing " + full);
	}

	private MethodReference GM(string type, string name, int pc = -1)
	{
		return M.ImportReference((MethodReference)(object)((IEnumerable<MethodDefinition>)GT(type).Methods).Single((MethodDefinition x) => ((MemberReference)x).Name == name && (pc < 0 || ((MethodReference)x).Parameters.Count == pc)));
	}

	private static bool IsGameField(FieldReference f, string type, string name)
	{
		if (((MemberReference)f).Name == name && ((MemberReference)((MemberReference)f).DeclaringType).FullName == type)
		{
			return ((MemberReference)f).DeclaringType.Scope.Name.StartsWith("Assembly-CSharp");
		}
		return false;
	}

	private static IEnumerable<MethodDefinition> Bodies(ModuleDefinition m)
	{
		return from md in m.GetTypes().SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods)
			where md.HasBody
			select md;
	}

	private MethodReference Helper(string name)
	{
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Expected O, but got Unknown
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got