using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("RepoRPG RU - patcher")]
[assembly: AssemblyVersion("0.2.1.0")]
namespace RepoRPG_RU;

internal enum Use
{
	Unknown,
	Display,
	Keep,
	Id
}
internal struct Consumer
{
	public Instruction Ins;

	public int FromTop;

	public int Pops;

	public bool IsCall
	{
		get
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			if (Ins == null)
			{
				return false;
			}
			OpCode opCode = Ins.OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code != 39 && (int)code != 110)
			{
				return (int)code == 114;
			}
			return true;
		}
	}

	public MethodReference Method
	{
		get
		{
			if (!IsCall)
			{
				return null;
			}
			object operand = Ins.Operand;
			return (MethodReference)((operand is MethodReference) ? operand : null);
		}
	}

	public int Param
	{
		get
		{
			//IL_0033: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			MethodReference method = Method;
			if (method == null)
			{
				return -2;
			}
			int num = Pops - 1 - FromTop;
			if (method.HasThis && !method.ExplicitThis)
			{
				OpCode opCode = Ins.OpCode;
				if ((int)((OpCode)(ref opCode)).Code != 114)
				{
					return num - 1;
				}
			}
			return num;
		}
	}
}
internal enum ProbeKind
{
	Prefix,
	Suffix,
	Inside
}
internal sealed class Probe
{
	public string Text;

	public ProbeKind Kind;

	public bool IgnoreCase;

	public string Where;

	public string Key
	{
		get
		{
			int kind = (int)Kind;
			return kind + (IgnoreCase ? "i" : "c") + Text;
		}
	}

	public bool Hits(string s)
	{
		if (s == null || s.Length < Text.Length)
		{
			return false;
		}
		StringComparison comparisonType = (IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
		return Kind switch
		{
			ProbeKind.Prefix => s.StartsWith(Text, comparisonType), 
			ProbeKind.Suffix => s.EndsWith(Text, comparisonType), 
			_ => s.IndexOf(Text, comparisonType) >= 0, 
		};
	}

	public override string ToString()
	{
		return ((Kind == ProbeKind.Prefix) ? "StartsWith" : ((Kind == ProbeKind.Suffix) ? "EndsWith" : "Contains")) + "(\"" + Builder.Escape(Text) + "\")";
	}
}
internal static class Analysis
{
	public static bool IsProbe(Consumer c, out ProbeKind kind, out bool ignoreCase)
	{
		kind = ProbeKind.Inside;
		ignoreCase = false;
		MethodReference method = c.Method;
		if (method == null || c.Param != 0 || method.Parameters.Count == 0)
		{
			return false;
		}
		if (TypeName(((MemberReference)method).DeclaringType) != "System.String" || ((MemberReference)((ParameterReference)method.Parameters[0]).ParameterType).FullName != "System.String")
		{
			return false;
		}
		switch (((MemberReference)method).Name)
		{
		case "StartsWith":
			kind = ProbeKind.Prefix;
			break;
		case "EndsWith":
			kind = ProbeKind.Suffix;
			break;
		case "Contains":
		case "IndexOf":
		case "LastIndexOf":
			kind = ProbeKind.Inside;
			break;
		case "Replace":
			kind = ProbeKind.Inside;
			break;
		default:
			return false;
		}
		if (!method.HasThis)
		{
			return false;
		}
		for (int i = 1; i < method.Parameters.Count; i++)
		{
			string fullName = ((MemberReference)((ParameterReference)method.Parameters[i]).ParameterType).FullName;
			if (fullName == "System.StringComparison" && i == method.Parameters.Count - 1)
			{
				if (c.Ins != null && Constant(c.Ins.Previous, out var value))
				{
					if ((value & 1) != 0)
					{
						ignoreCase = true;
					}
				}
				else
				{
					ignoreCase = true;
				}
			}
			else
			{
				switch (fullName)
				{
				case "System.StringComparison":
				case "System.Boolean":
				case "System.Globalization.CultureInfo":
					ignoreCase = true;
					break;
				}
			}
		}
		return true;
	}

	private static bool Constant(Instruction ins, out int value)
	{
		//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_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected I4, but got Unknown
		value = 0;
		if (ins == null)
		{
			return false;
		}
		OpCode opCode = ins.OpCode;
		Code code = ((OpCode)(ref opCode)).Code;
		switch (code - 21)
		{
		case 0:
			value = -1;
			return true;
		case 1:
			value = 0;
			return true;
		case 2:
			value = 1;
			return true;
		case 3:
			value = 2;
			return true;
		case 4:
			value = 3;
			return true;
		case 5:
			value = 4;
			return true;
		case 6:
			value = 5;
			return true;
		case 7:
			value = 6;
			return true;
		case 8:
			value = 7;
			return true;
		case 9:
			value = 8;
			return true;
		case 10:
			value = (sbyte)ins.Operand;
			return true;
		case 11:
			value = (int)ins.Operand;
			return true;
		default:
			return false;
		}
	}

	public static bool ProbeMatters(Probe p, Rules rules)
	{
		if (rules.ProbeIgnore.Contains(p.Text))
		{
			return false;
		}
		if (rules.ProbeProtect.Contains(p.Text))
		{
			return true;
		}
		if (p.Text.Length >= 3 && p.Text[0] == '{' && p.Text[p.Text.Length - 1] == '}')
		{
			return false;
		}
		bool flag = false;
		bool flag2 = true;
		string text = p.Text;
		foreach (char c in text)
		{
			if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
			{
				flag = true;
			}
			else if (c < '0' || c > '9')
			{
				flag2 = false;
			}
		}
		if (!flag)
		{
			return false;
		}
		if (p.Kind == ProbeKind.Inside && flag2)
		{
			return false;
		}
		return true;
	}

	public static string TypeKey(TypeDefinition t)
	{
		List<string> list = new List<string>();
		for (TypeDefinition val = t; val != null; val = val.DeclaringType)
		{
			string text = ((MemberReference)val).Name;
			if (text.Length <= 0 || text[0] != '<')
			{
				int num = text.IndexOf('`');
				if (num > 0)
				{
					text = text.Substring(0, num);
				}
				list.Add(text);
			}
		}
		list.Reverse();
		return string.Join(".", list.ToArray());
	}

	public static string MemberName(MethodDefinition m)
	{
		string text = Angle(((MemberReference)m).Name);
		if (text == null)
		{
			TypeDefinition declaringType = m.DeclaringType;
			while (declaringType != null && ((MemberReference)declaringType).Name.Length > 0 && ((MemberReference)declaringType).Name[0] == '<')
			{
				string text2 = Angle(((MemberReference)declaringType).Name);
				if (!string.IsNullOrEmpty(text2))
				{
					text = text2;
					break;
				}
				declaringType = declaringType.DeclaringType;
			}
		}
		if (text == null)
		{
			text = ((MemberReference)m).Name;
		}
		if (text != ".ctor" && text != ".cctor")
		{
			int num = text.LastIndexOf('.');
			if (num >= 0 && num + 1 < text.Length)
			{
				text = text.Substring(num + 1);
			}
		}
		if (text.StartsWith("get_", StringComparison.Ordinal) || text.StartsWith("set_", StringComparison.Ordinal))
		{
			text = text.Substring(4);
		}
		else if (text.StartsWith("add_", StringComparison.Ordinal))
		{
			text = text.Substring(4);
		}
		else if (text.StartsWith("remove_", StringComparison.Ordinal))
		{
			text = text.Substring(7);
		}
		return text;
	}

	private static string Angle(string n)
	{
		if (n.Length < 3 || n[0] != '<')
		{
			return null;
		}
		int num = n.IndexOf('>');
		if (num <= 1)
		{
			return null;
		}
		return n.Substring(1, num - 1);
	}

	public static string Scope(MethodDefinition m)
	{
		return TypeKey(m.DeclaringType) + "::" + MemberName(m);
	}

	public static string TypeName(TypeReference t)
	{
		if (t == null)
		{
			return "";
		}
		return ((MemberReference)t.GetElementType()).FullName.Replace('/', '.');
	}

	private static bool Effect(MethodDefinition owner, Instruction ins, out int pop, out int push)
	{
		//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_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_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Expected I4, but got Unknown
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Invalid comparison between Unknown and I4
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_016b: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Expected I4, but got Unknown
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Invalid comparison between Unknown and I4
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Invalid comparison between Unknown and I4
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Invalid comparison between Unknown and I4
		OpCode opCode = ins.OpCode;
		pop = 0;
		push = 0;
		StackBehaviour stackBehaviourPop = ((OpCode)(ref opCode)).StackBehaviourPop;
		switch ((int)stackBehaviourPop)
		{
		case 0:
			pop = 0;
			break;
		case 1:
		case 3:
		case 10:
			pop = 1;
			break;
		case 2:
		case 4:
		case 5:
		case 6:
		case 8:
		case 9:
		case 11:
		case 12:
			pop = 2;
			break;
		case 7:
		case 13:
		case 14:
		case 15:
		case 16:
		case 17:
			pop = 3;
			break;
		case 18:
			return false;
		case 27:
		{
			if ((int)((OpCode)(ref opCode)).Code == 41)
			{
				pop = ((!(((MemberReference)((MethodReference)owner).ReturnType).FullName == "System.Void")) ? 1 : 0);
				break;
			}
			if ((int)((OpCode)(ref opCode)).Code == 40)
			{
				object operand = ins.Operand;
				CallSite val = (CallSite)((operand is CallSite) ? operand : null);
				if (val == null)
				{
					return false;
				}
				pop = val.Parameters.Count + 1 + ((val.HasThis && !val.ExplicitThis) ? 1 : 0);
				break;
			}
			object operand2 = ins.Operand;
			MethodReference val2 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
			if (val2 == null)
			{
				return false;
			}
			pop = val2.Parameters.Count;
			if (val2.HasThis && !val2.ExplicitThis && (int)((OpCode)(ref opCode)).Code != 114)
			{
				pop++;
			}
			break;
		}
		default:
			return false;
		}
		stackBehaviourPop = ((OpCode)(ref opCode)).StackBehaviourPush;
		switch (stackBehaviourPop - 19)
		{
		case 0:
			push = 0;
			break;
		case 1:
		case 3:
		case 4:
		case 5:
		case 6:
		case 7:
			push = 1;
			break;
		case 2:
			push = 2;
			break;
		case 9:
			if ((int)((OpCode)(ref opCode)).Code == 40)
			{
				object operand3 = ins.Operand;
				CallSite val3 = (CallSite)((operand3 is CallSite) ? operand3 : null);
				if (val3 == null)
				{
					return false;
				}
				push = ((!(((MemberReference)val3.ReturnType).FullName == "System.Void")) ? 1 : 0);
			}
			else
			{
				object operand4 = ins.Operand;
				MethodReference val4 = (MethodReference)((operand4 is MethodReference) ? operand4 : null);
				if (val4 == null)
				{
					return false;
				}
				push = ((!(((MemberReference)val4.ReturnType).FullName == "System.Void")) ? 1 : 0);
			}
			break;
		default:
			return false;
		}
		return true;
	}

	public static Consumer Find(MethodDefinition owner, Instruction start)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Invalid comparison between Unknown and I4
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Invalid comparison between Unknown and I4
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Invalid comparison between Unknown and I4
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Invalid comparison between Unknown and I4
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Invalid comparison between Unknown and I4
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Invalid comparison between Unknown and I4
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		Consumer result = default(Consumer);
		Instruction val = start;
		int num = 0;
		int num2 = 0;
		while (val != null && num2 < 4000)
		{
			OpCode opCode = val.OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code == 187 || (int)code == 188 || (int)code == 186 || (int)code == 206 || (int)code == 215)
			{
				return result;
			}
			if (!Effect(owner, val, out var pop, out var push))
			{
				return result;
			}
			if (num < pop)
			{
				return new Consumer
				{
					Ins = val,
					FromTop = num,
					Pops = pop
				};
			}
			num += push - pop;
			if ((int)code == 41 || (int)code == 119)
			{
				return result;
			}
			opCode = val.OpCode;
			val = (Instruction)(((int)((OpCode)(ref opCode)).FlowControl != 0) ? ((object)val.Next) : ((object)/*isinst with value type is only supported in some contexts*/));
			num2++;
		}
		return result;
	}

	public static Consumer Final(MethodDefinition owner, Instruction afterValue, Rules rules)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Invalid comparison between Unknown and I4
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Invalid comparison between Unknown and I4
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Invalid comparison between Unknown and I4
		Consumer result = Find(owner, afterValue);
		for (int i = 0; i < 12; i++)
		{
			if (result.Ins == null)
			{
				break;
			}
			OpCode opCode = result.Ins.OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code == 115 || (int)code == 116)
			{
				result = Find(owner, result.Ins.Next);
				continue;
			}
			if ((int)code != 39 && (int)code != 110)
			{
				break;
			}
			MethodReference method = result.Method;
			if (method == null || !(((MemberReference)method.ReturnType).FullName != "System.Void") || !IsThrough(method, result.Param, rules))
			{
				break;
			}
			result = Find(owner, result.Ins.Next);
		}
		return result;
	}

	private static bool IsThrough(MethodReference m, int param, Rules rules)
	{
		string text = TypeName(((MemberReference)m).DeclaringType);
		string name = ((MemberReference)m).Name;
		if (text == "System.String")
		{
			switch (name)
			{
			case "Concat":
			case "Format":
			case "Join":
				return true;
			case "ToUpper":
			case "ToUpperInvariant":
			case "ToLower":
			case "ToLowerInvariant":
			case "Trim":
			case "TrimStart":
			case "TrimEnd":
			case "PadLeft":
			case "PadRight":
			case "Substring":
			case "Insert":
			case "Remove":
			case "Replace":
			case "ToString":
			case "Normalize":
				return param == -1;
			default:
				return false;
			}
		}
		if (text == "System.Object" && name == "ToString")
		{
			return param == -1;
		}
		for (int i = 0; i < rules.Through.Count; i++)
		{
			if (Match(rules.Through[i], m, text, name, param))
			{
				return true;
			}
		}
		return false;
	}

	public static bool Match(CallRule rule, MethodReference m, string dt, string name, int param)
	{
		if (rule.Args != null && Array.IndexOf(rule.Args, param) < 0)
		{
			return false;
		}
		if (!Rules.Glob(rule.Method, name))
		{
			return false;
		}
		if (rule.External)
		{
			return Rules.Glob(rule.Type, dt);
		}
		if (!(((MemberReference)m).DeclaringType.GetElementType() is TypeDefinition))
		{
			return false;
		}
		return TypeMatches(rule.Type, dt);
	}

	public static bool TypeMatches(string pattern, string fullName)
	{
		if (pattern == "*")
		{
			return true;
		}
		if (Rules.Glob(pattern, fullName))
		{
			return true;
		}
		if (pattern.IndexOf('*') < 0)
		{
			if (fullName.Length > pattern.Length && fullName.EndsWith(pattern, StringComparison.Ordinal))
			{
				return fullName[fullName.Length - pattern.Length - 1] == '.';
			}
			return false;
		}
		return Rules.Glob("*." + pattern, fullName);
	}

	public static Use Classify(MethodDefinition owner, Consumer c, Rules rules, Dictionary<MethodDefinition, HashSet<int>> hooked, int depth, out string why)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		why = null;
		if (c.Ins == null)
		{
			return Use.Unknown;
		}
		OpCode opCode = c.Ins.OpCode;
		Code code = ((OpCode)(ref opCode)).Code;
		int num = LocalIndex(c.Ins, store: true);
		if (num >= 0)
		{
			if (depth > 0)
			{
				return Use.Unknown;
			}
			bool flag = false;
			bool flag2 = true;
			string text = null;
			Enumerator<Instruction> enumerator = owner.Body.Instructions.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					if (LocalIndex(current, store: false) != num)
					{
						continue;
					}
					flag = true;
					string why2;
					Use use = Classify(owner, Final(owner, current.Next, rules), rules, hooked, depth + 1, out why2);
					switch (use)
					{
					case Use.Id:
						why = "local -> " + why2;
						return Use.Id;
					case Use.Keep:
						if (text == null)
						{
							text = why2;
						}
						break;
					}
					if (use != Use.Display)
					{
						flag2 = false;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			if (text != null)
			{
				why = "local -> " + text;
				return Use.Keep;
			}
			if (!(flag && flag2))
			{
				return Use.Unknown;
			}
			return Use.Display;
		}
		if (!c.IsCall)
		{
			return Use.Unknown;
		}
		MethodReference method = c.Method;
		if (method == null)
		{
			return Use.Unknown;
		}
		string text2 = TypeName(((MemberReference)method).DeclaringType);
		string name = ((MemberReference)method).Name;
		int param = c.Param;
		MethodReference elementMethod = method.GetElementMethod();
		MethodDefinition val = (MethodDefinition)(object)((elementMethod is MethodDefinition) ? elementMethod : null);
		if (val != null && hooked != null && hooked.TryGetValue(val, out var value) && value.Contains(param))
		{
			return Use.Display;
		}
		for (int i = 0; i < rules.Display.Count; i++)
		{
			if (Match(rules.Display[i], method, text2, name, param))
			{
				return Use.Display;
			}
		}
		for (int j = 0; j < rules.Keep.Count; j++)
		{
			if (Match(rules.Keep[j], method, text2, name, param))
			{
				why = text2 + "::" + name;
				return Use.Keep;
			}
		}
		for (int k = 0; k < rules.Veto.Count; k++)
		{
			if (Match(rules.Veto[k], method, text2, name, param))
			{
				why = text2 + "::" + name;
				return Use.Id;
			}
		}
		Use use2 = Builtin(method, text2, name, param, code);
		if (use2 == Use.Id || use2 == Use.Keep)
		{
			why = text2 + "::" + name;
		}
		return use2;
	}

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

	private static int Index(object operand)
	{
		VariableDefinition val = (VariableDefinition)((operand is VariableDefinition) ? operand : null);
		if (val != null)
		{
			return ((VariableReference)val).Index;
		}
		return -1;
	}

	private static Use Builtin(MethodReference m, string dt, string name, int param, Code code)
	{
		//IL_0530: Unknown result type (might be due to invalid IL or missing references)
		//IL_0534: Invalid comparison between Unknown and I4
		if (dt == "System.String")
		{
			switch (name)
			{
			case "op_Equality":
			case "op_Inequality":
			case "Equals":
			case "StartsWith":
			case "EndsWith":
			case "Contains":
			case "IndexOf":
			case "LastIndexOf":
			case "IndexOfAny":
			case "Compare":
			case "CompareOrdinal":
			case "CompareTo":
			case "Split":
			case "IsNullOrEmpty":
			case "IsNullOrWhiteSpace":
			case "Intern":
				return Use.Id;
			case "Replace":
				if (param != 0)
				{
					return Use.Unknown;
				}
				return Use.Id;
			case "Trim":
			case "TrimStart":
			case "TrimEnd":
				if (param < 0)
				{
					return Use.Unknown;
				}
				return Use.Id;
			default:
				return Use.Unknown;
			}
		}
		if (dt.StartsWith("System.Collections.", StringComparison.Ordinal))
		{
			switch (name)
			{
			case "ContainsKey":
			case "TryGetValue":
			case "get_Item":
			case "Contains":
			case "IndexOf":
			case "LastIndexOf":
			case "Remove":
			case "TryRemove":
			case "GetValueOrDefault":
			case "ContainsValue":
				return Use.Id;
			case "set_Item":
			case "Add":
			case "TryAdd":
			case ".ctor":
				if (dt.IndexOf("Dictionary", StringComparison.Ordinal) >= 0 || dt.IndexOf("SortedList", StringComparison.Ordinal) >= 0 || dt.IndexOf("Hashtable", StringComparison.Ordinal) >= 0 || dt.IndexOf("KeyValuePair", StringComparison.Ordinal) >= 0)
				{
					if (param != 0)
					{
						return Use.Unknown;
					}
					return Use.Id;
				}
				if (dt.IndexOf("Set`", StringComparison.Ordinal) >= 0)
				{
					return Use.Id;
				}
				return Use.Unknown;
			default:
				return Use.Unknown;
			}
		}
		if (dt.StartsWith("System.", StringComparison.Ordinal))
		{
			if ((int)code == 114 && dt.EndsWith("Exception", StringComparison.Ordinal))
			{
				return Use.Keep;
			}
			switch (dt)
			{
			case "System.Array":
			case "System.Linq.Enumerable":
				switch (name)
				{
				default:
					return Use.Unknown;
				case "IndexOf":
				case "LastIndexOf":
				case "Contains":
				case "BinarySearch":
					return Use.Id;
				}
			case "System.Console":
				return Use.Keep;
			case "System.Enum":
			case "System.Type":
			case "System.Activator":
			case "System.Convert":
			case "System.Environment":
			case "System.Guid":
			case "System.Version":
			case "System.Uri":
			case "System.AppDomain":
			case "System.Text.Encoding":
			case "System.StringComparer":
			case "System.Int16":
			case "System.Int32":
			case "System.Int64":
			case "System.UInt16":
			case "System.UInt32":
			case "System.UInt64":
			case "System.Byte":
			case "System.SByte":
			case "System.Single":
			case "System.Double":
			case "System.Decimal":
			case "System.Boolean":
			case "System.Char":
			case "System.DateTime":
			case "System.TimeSpan":
			case "System.Math":
				return Use.Id;
			case "System.Text.StringBuilder":
				if (!(name == "Replace") || param != 0)
				{
					return Use.Unknown;
				}
				return Use.Id;
			default:
				if (dt.StartsWith("System.Diagnostics.", StringComparison.Ordinal))
				{
					return Use.Keep;
				}
				if (dt.StartsWith("System.Reflection.", StringComparison.Ordinal) || dt.StartsWith("System.IO.", StringComparison.Ordinal) || dt.StartsWith("System.Text.RegularExpressions.", StringComparison.Ordinal) || dt.StartsWith("System.Net.", StringComparison.Ordinal) || dt.StartsWith("System.Threading.", StringComparison.Ordinal) || dt.StartsWith("System.Globalization.", StringComparison.Ordinal) || dt.StartsWith("System.Runtime.", StringComparison.Ordinal) || dt.StartsWith("System.Security.", StringComparison.Ordinal) || dt.StartsWith("System.Xml.", StringComparison.Ordinal))
				{
					return Use.Id;
				}
				return Use.Unknown;
			}
		}
		if (dt.StartsWith("BepInEx.Configuration.", StringComparison.Ordinal))
		{
			if (name == "Bind")
			{
				if (m.Parameters.Count != 4 || param != 3 || !(((MemberReference)((ParameterReference)m.Parameters[3]).ParameterType).FullName == "System.String"))
				{
					return Use.Id;
				}
				return Use.Display;
			}
			if (dt == "BepInEx.Configuration.ConfigDescription" && name == ".ctor")
			{
				if (param != 0)
				{
					return Use.Id;
				}
				return Use.Display;
			}
			return Use.Id;
		}
		if (dt.StartsWith("BepInEx.Logging.", StringComparison.Ordinal))
		{
			return Use.Keep;
		}
		if (dt.StartsWith("BepInEx.", StringComparison.Ordinal))
		{
			return Use.Id;
		}
		if (dt.StartsWith("HarmonyLib.", StringComparison.Ordinal) || dt.StartsWith("MonoMod.", StringComparison.Ordinal) || dt.StartsWith("Mono.", StringComparison.Ordinal) || dt.StartsWith("Photon.", StringComparison.Ordinal) || dt.StartsWith("ExitGames.", StringComparison.Ordinal) || dt.StartsWith("Steamworks.", StringComparison.Ordinal))
		{
			return Use.Id;
		}
		if (dt.StartsWith("UnityEngine.", StringComparison.Ordinal))
		{
			if (IsUnityText(dt, name))
			{
				return Use.Display;
			}
			switch (dt)
			{
			case "UnityEngine.Debug":
			case "UnityEngine.Logger":
				return Use.Keep;
			case "UnityEngine.GUIUtility":
				if (name == "set_systemCopyBuffer")
				{
					return Use.Keep;
				}
				break;
			}
			return Use.Id;
		}
		if (dt.StartsWith("TMPro.", StringComparison.Ordinal))
		{
			if (!(name == "set_text") && !(name == "SetText"))
			{
				return Use.Id;
			}
			return Use.Display;
		}
		return Use.Unknown;
	}

	private static bool IsUnityText(string dt, string name)
	{
		switch (dt)
		{
		case "UnityEngine.GUI":
		case "UnityEngine.GUILayout":
			return true;
		case "UnityEngine.GUIContent":
			if (!(name == ".ctor") && !(name == "set_text"))
			{
				return name == "set_tooltip";
			}
			return true;
		case "UnityEngine.TextMesh":
		case "UnityEngine.UI.Text":
			return name == "set_text";
		default:
			return false;
		}
	}

	public static bool IsTokenLike(string s)
	{
		if (s.Length == 0 || s.Length > 40)
		{
			return false;
		}
		bool result = false;
		foreach (char c in s)
		{
			if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
			{
				result = true;
			}
			else if ((c < '0' || c > '9') && c != '_' && c != '.' && c != '-' && c != '+' && c != '/' && c != ':' && c != '#' && c != '%')
			{
				return false;
			}
		}
		return result;
	}

	public static string Describe(Consumer c)
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		if (c.Ins == null)
		{
			return "?";
		}
		MethodReference method = c.Method;
		if (method != null)
		{
			return TypeName(((MemberReference)method).DeclaringType) + "::" + ((MemberReference)method).Name + "#" + c.Param;
		}
		OpCode opCode = c.Ins.OpCode;
		return ((OpCode)(ref opCode)).Name;
	}
}
internal sealed class Report
{
	public string OriginalVersion = "?";

	public string NewVersion = "?";

	public int Methods;

	public int Literals;

	public int Replaced;

	public int ReplacedScoped;

	public int SkippedVeto;

	public int SkippedToken;

	public int SkippedType;

	public int SkippedProbe;

	public int SkippedSentence;

	public int Probes;

	public int HooksApplied;

	public int CallHooks;

	public int HookRulesMissed;

	public int FontHooks;

	public int FontRulesMissed;

	public int DataReplaced;

	public int DataFiles;

	public int EnumsKnown;

	public int EnumsAnswered;

	public int AssemblyRequests;

	public readonly HashSet<string> UsedGlobal = new HashSet<string>(StringComparer.Ordinal);

	public readonly HashSet<string> UsedScoped = new HashSet<string>(StringComparer.Ordinal);

	public readonly HashSet<string> UsedData = new HashSet<string>(StringComparer.Ordinal);

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

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

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

	public readonly Dictionary<string, byte[]> Resources = new Dictionary<string, byte[]>(StringComparer.Ordinal);
}
internal sealed class BuildOptions
{
	public Settings Settings;

	public Lang Lang;

	public Rules Rules;

	public string RuntimeAssemblyName = "RepoRPG_RU";

	public Version RuntimeVersion = new Version(0, 0, 0, 0);

	public bool HaveRuntime;

	public bool Dump;

	public string Stamp;

	public bool RequirePlugin = true;

	public List<string> SearchDirs = new List<string>();
}
internal static class Builder
{
	private sealed class Edit
	{
		public int Index;

		public string Value;
	}

	private sealed class Plan
	{
		public readonly Dictionary<uint, List<Edit>> Edits = new Dictionary<uint, List<Edit>>();

		public readonly Dictionary<uint, List<int>> Hooks = new Dictionary<uint, List<int>>();

		public readonly Dictionary<uint, List<int>> Shims = new Dictionary<uint, List<int>>();

		public readonly Dictionary<uint, int> Fonts = new Dictionary<uint, int>();

		public readonly Dictionary<uint, int> FontAdded = new Dictionary<uint, int>();

		public readonly Dictionary<uint, int> Counts = new Dictionary<uint, int>();

		public readonly Dictionary<uint, string> Names = new Dictionary<uint, string>();

		public readonly List<Probe> Probes = new List<Probe>();

		public HashSet<string> Free;
	}

	private sealed class Occurrence
	{
		public uint Token;

		public int Index;

		public string Scope;

		public string TypeKey;

		public string Value;

		public string Translated;

		public string Why;

		public bool Scoped;

		public bool Skipped;

		public Use Use;
	}

	private sealed class Expect
	{
		public int Count;

		public int Shift;

		public int Font;

		public List<int> Shims;

		public List<Edit> Edits;

		public bool Seen;

		public int Moved(int index)
		{
			int num = index + Shift;
			if (Shims != null)
			{
				for (int i = 0; i < Shims.Count; i++)
				{
					if (Shims[i] < index)
					{
						num++;
					}
				}
			}
			return num;
		}
	}

	private const string GuardType = "<RepoRPG_RU>";

	public static byte[] Build(byte[] original, BuildOptions o, Report report)
	{
		Plan plan = MakePlan(original, o, report);
		byte[] result = Apply(original, o, plan, report);
		Verify(result, plan, report);
		return result;
	}

	private static AssemblyDefinition Read(byte[] bytes)
	{
		return Read(bytes, null, null);
	}

	private static AssemblyDefinition Read(byte[] bytes, IAssemblyResolver assemblies, IMetadataResolver metadata)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		ReaderParameters val = new ReaderParameters();
		val.ReadingMode = (ReadingMode)2;
		val.InMemory = true;
		val.ReadSymbols = false;
		if (assemblies != null)
		{
			val.AssemblyResolver = assemblies;
		}
		if (metadata != null)
		{
			val.MetadataResolver = metadata;
		}
		return AssemblyDefinition.ReadAssembly((Stream)new MemoryStream(bytes, writable: false), val);
	}

	private static IEnumerable<TypeDefinition> AllTypes(ModuleDefinition module)
	{
		Stack<TypeDefinition> todo = new Stack<TypeDefinition>();
		for (int num = module.Types.Count - 1; num >= 0; num--)
		{
			todo.Push(module.Types[num]);
		}
		while (todo.Count > 0)
		{
			TypeDefinition t = todo.Pop();
			yield return t;
			if (t.HasNestedTypes)
			{
				for (int num2 = t.NestedTypes.Count - 1; num2 >= 0; num2--)
				{
					todo.Push(t.NestedTypes[num2]);
				}
			}
		}
	}

	private static Plan MakePlan(byte[] original, BuildOptions o, Report report)
	{
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_029c: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_032b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0330: Unknown result type (might be due to invalid IL or missing references)
		//IL_0504: Unknown result type (might be due to invalid IL or missing references)
		//IL_0509: Unknown result type (might be due to invalid IL or missing references)
		//IL_053e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0543: Unknown result type (might be due to invalid IL or missing references)
		//IL_068e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0693: Unknown result type (might be due to invalid IL or missing references)
		//IL_0697: Unknown result type (might be due to invalid IL or missing references)
		//IL_069e: Invalid comparison between Unknown and I4
		//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cc: Invalid comparison between Unknown and I4
		//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e0: Invalid comparison between Unknown and I4
		//IL_0606: Unknown result type (might be due to invalid IL or missing references)
		//IL_060b: Unknown result type (might be due to invalid IL or missing references)
		//IL_060f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0615: Invalid comparison between Unknown and I4
		Plan plan = new Plan();
		plan.Free = ((o.Rules != null) ? o.Rules.ProbeFree : null);
		AssemblyDefinition val = Read(original);
		try
		{
			ModuleDefinition mainModule = val.MainModule;
			Rules rules = o.Rules;
			Lang lang = o.Lang;
			Dictionary<MethodDefinition, HashSet<int>> dictionary = new Dictionary<MethodDefinition, HashSet<int>>();
			foreach (HookRule hook in rules.Hooks)
			{
				int num = 0;
				foreach (TypeDefinition item in AllTypes(mainModule))
				{
					if (!Analysis.TypeMatches(hook.Type, ((MemberReference)item).FullName.Replace('/', '.')))
					{
						continue;
					}
					Enumerator<MethodDefinition> enumerator3 = item.Methods.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							MethodDefinition current3 = enumerator3.Current;
							if (((MemberReference)current3).Name != hook.Method || !current3.HasBody)
							{
								continue;
							}
							Enumerator<ParameterDefinition> enumerator4 = ((MethodReference)current3).Parameters.GetEnumerator();
							try
							{
								while (enumerator4.MoveNext())
								{
									ParameterDefinition current4 = enumerator4.Current;
									if (Array.IndexOf(hook.Params, ((ParameterReference)current4).Name) >= 0 && !(((MemberReference)((ParameterReference)current4).ParameterType).FullName != "System.String"))
									{
										if (!dictionary.TryGetValue(current3, out var value))
										{
											value = (dictionary[current3] = new HashSet<int>());
										}
										if (value.Add(((ParameterReference)current4).Index))
										{
											num++;
										}
									}
								}
							}
							finally
							{
								((IDisposable)enumerator4/*cast due to .constrained prefix*/).Dispose();
							}
						}
					}
					finally
					{
						((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				if (num == 0)
				{
					report.HookRulesMissed++;
					report.Notes.Add("hook not found: " + hook.Type + "::" + hook.Method + "(" + string.Join(", ", hook.Params) + ")  [" + hook.Source + "]");
				}
			}
			bool flag = o.Settings.DisplayHooks && o.HaveRuntime;
			MetadataToken metadataToken;
			if (flag)
			{
				foreach (KeyValuePair<MethodDefinition, HashSet<int>> item2 in dictionary)
				{
					List<int> list = new List<int>(item2.Value);
					list.Sort();
					Dictionary<uint, List<int>> hooks = plan.Hooks;
					metadataToken = ((MemberReference)item2.Key).MetadataToken;
					hooks[((MetadataToken)(ref metadataToken)).ToUInt32()] = list;
				}
			}
			foreach (HookRule font in rules.Fonts)
			{
				int num2 = 0;
				foreach (TypeDefinition item3 in AllTypes(mainModule))
				{
					if (!Analysis.TypeMatches(font.Type, ((MemberReference)item3).FullName.Replace('/', '.')))
					{
						continue;
					}
					Enumerator<MethodDefinition> enumerator3 = item3.Methods.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							MethodDefinition current8 = enumerator3.Current;
							if (!(((MemberReference)current8).Name != font.Method) && current8.HasBody && !((MethodReference)current8).HasParameters && current8.Body.Instructions.Count != 0 && !(((MemberReference)((MethodReference)current8).ReturnType).FullName != "UnityEngine.Font"))
							{
								num2++;
								if (flag)
								{
									int num3 = FontSetting(current8.Body);
									Dictionary<uint, int> fonts = plan.Fonts;
									metadataToken = ((MemberReference)current8).MetadataToken;
									fonts[((MetadataToken)(ref metadataToken)).ToUInt32()] = num3;
									Dictionary<uint, int> fontAdded = plan.FontAdded;
									metadataToken = ((MemberReference)current8).MetadataToken;
									fontAdded[((MetadataToken)(ref metadataToken)).ToUInt32()] = FontAdded(current8.Body, 0, num3);
								}
							}
						}
					}
					finally
					{
						((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				if (num2 == 0)
				{
					report.FontRulesMissed++;
					report.Notes.Add("font method not found: " + font.Type + "::" + font.Method + "  [" + font.Source + "]");
				}
			}
			bool translateStrings = o.Settings.TranslateStrings;
			List<Occurrence> list2 = new List<Occurrence>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			foreach (TypeDefinition item4 in AllTypes(mainModule))
			{
				string text = Analysis.TypeKey(item4);
				Enumerator<MethodDefinition> enumerator3 = item4.Methods.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						MethodDefinition current10 = enumerator3.Current;
						if (!current10.HasBody)
						{
							continue;
						}
						report.Methods++;
						MethodBody body = current10.Body;
						metadataToken = ((MemberReference)current10).MetadataToken;
						uint num4 = ((MetadataToken)(ref metadataToken)).ToUInt32();
						plan.Counts[num4] = body.Instructions.Count;
						plan.Names[num4] = ((MemberReference)current10).FullName;
						string text2 = null;
						Dictionary<string, string> value2 = null;
						Dictionary<string, string> value3 = null;
						bool skipped = false;
						OpCode opCode;
						if (flag && rules.Calls.Count > 0)
						{
							List<int> list3 = null;
							for (int i = 0; i < body.Instructions.Count; i++)
							{
								Instruction val2 = body.Instructions[i];
								opCode = val2.OpCode;
								if ((int)((OpCode)(ref opCode)).Code != 39)
								{
									opCode = val2.OpCode;
									if ((int)((OpCode)(ref opCode)).Code != 110)
									{
										continue;
									}
								}
								object operand = val2.Operand;
								if (!IsCallHook(rules, (MethodReference)((operand is MethodReference) ? operand : null)))
								{
									continue;
								}
								if (val2.Previous != null)
								{
									opCode = val2.Previous.OpCode;
									if ((int)((OpCode)(ref opCode)).OpCodeType == 4)
									{
										continue;
									}
								}
								if (list3 == null)
								{
									if (IsSkipped(rules, text, text + "::" + Analysis.MemberName(current10)))
									{
										break;
									}
									list3 = new List<int>();
								}
								list3.Add(i);
							}
							if (list3 != null)
							{
								plan.Shims[num4] = list3;
							}
						}
						for (int j = 0; j < body.Instructions.Count; j++)
						{
							Instruction val3 = body.Instructions[j];
							opCode = val3.OpCode;
							if ((int)((OpCode)(ref opCode)).Code != 113 || !(val3.Operand is string text3))
							{
								continue;
							}
							report.Literals++;
							if (text3.Length == 0)
							{
								continue;
							}
							if (text2 == null)
							{
								text2 = text + "::" + Analysis.MemberName(current10);
								lang.Scoped.TryGetValue(text2, out value2);
								lang.Scoped.TryGetValue(text + "::*", out value3);
								skipped = IsSkipped(rules, text, text2);
							}
							string value4 = null;
							bool flag2 = (value2 != null && value2.TryGetValue(text3, out value4)) || (value3?.TryGetValue(text3, out value4) ?? false);
							bool flag3 = !flag2 && lang.Global.TryGetValue(text3, out value4);
							Consumer c = Analysis.Final(current10, val3.Next, rules);
							if (Analysis.IsProbe(c, out var kind, out var ignoreCase))
							{
								Probe probe = new Probe();
								probe.Text = text3;
								probe.Kind = kind;
								probe.IgnoreCase = ignoreCase;
								probe.Where = text2;
								if (hashSet3.Add(probe.Key) && Analysis.ProbeMatters(probe, rules))
								{
									plan.Probes.Add(probe);
								}
							}
							if (o.Dump || flag2 || flag3 || lang.Terms.ContainsKey(text3))
							{
								string why;
								Use use = Analysis.Classify(current10, c, rules, dictionary, 0, out why);
								if (use == Use.Id)
								{
									hashSet2.Add(text3);
								}
								if (o.Dump)
								{
									report.Dump.Add(text2 + "\t" + use.ToString() + "\t" + Analysis.Describe(c) + "\t" + Escape(text3));
								}
								if (flag2 || flag3)
								{
									Occurrence occurrence = new Occurrence();
									occurrence.Token = num4;
									occurrence.Index = j;
									occurrence.Scope = text2;
									occurrence.TypeKey = text;
									occurrence.Value = text3;
									occurrence.Translated = value4;
									occurrence.Scoped = flag2;
									occurrence.Skipped = skipped;
									occurrence.Use = use;
									occurrence.Why = why ?? Analysis.Describe(c);
									list2.Add(occurrence);
								}
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
				}
			}
			report.Probes = plan.Probes.Count;
			if (!translateStrings)
			{
				return plan;
			}
			List<Occurrence> list4 = new List<Occurrence>();
			Dictionary<string, HashSet<string>> dictionary2 = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, HashSet<string>> item5 in lang.Unsafe)
			{
				dictionary2[item5.Key] = new HashSet<string>(item5.Value, StringComparer.Ordinal);
			}
			foreach (Occurrence item6 in list2)
			{
				string text4 = Refusal(item6, plan, hashSet2, report);
				if (text4 == null)
				{
					list4.Add(item6);
					continue;
				}
				report.Notes.Add(text4 + ": " + item6.Scope + "  \"" + Escape(item6.Value) + "\"");
				if (item6.Scoped)
				{
					if (!dictionary2.TryGetValue(item6.Scope, out var value5))
					{
						value5 = new HashSet<string>(StringComparer.Ordinal);
						dictionary2[item6.Scope] = value5;
					}
					value5.Add(item6.Value);
				}
			}
			foreach (KeyValuePair<string, HashSet<string>> item7 in dictionary2)
			{
				if (!lang.Sentences.TryGetValue(item7.Key, out var value6))
				{
					continue;
				}
				HashSet<string> value7 = item7.Value;
				bool flag4 = true;
				while (flag4)
				{
					flag4 = false;
					foreach (List<string> value9 in value6.Values)
					{
						bool flag5 = false;
						foreach (string item8 in value9)
						{
							if (value7.Contains(item8))
							{
								flag5 = true;
								break;
							}
						}
						if (!flag5)
						{
							continue;
						}
						foreach (string item9 in value9)
						{
							if (value7.Add(item9))
							{
								flag4 = true;
							}
						}
					}
				}
			}
			foreach (Occurrence item10 in list4)
			{
				if (item10.Scoped && dictionary2.TryGetValue(item10.Scope, out var value8) && value8.Contains(item10.Value))
				{
					report.SkippedSentence++;
					report.Notes.Add("left to display time (another piece of the same sentence stays as it is): " + item10.Scope + "  \"" + Escape(item10.Value) + "\"");
				}
				else
				{
					AddEdit(plan, item10.Token, item10.Index, item10.Translated);
					report.Replaced++;
					if (item10.Scoped)
					{
						report.ReplacedScoped++;
						report.UsedScoped.Add(item10.Scope + "\n" + item10.Value);
						report.UsedScoped.Add(item10.TypeKey + "::*\n" + item10.Value);
					}
					else
					{
						report.UsedGlobal.Add(item10.Value);
					}
				}
			}
			return plan;
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	private static string Refusal(Occurrence occ, Plan plan, HashSet<string> usedAsId, Report report)
	{
		if (occ.Skipped)
		{
			report.SkippedType++;
			return "skipped (excluded type)";
		}
		if (occ.Use == Use.Id || occ.Use == Use.Keep)
		{
			report.SkippedVeto++;
			return (occ.Scoped ? "scoped entry ignored, " : "kept, ") + ((occ.Use == Use.Id) ? "used as id" : "log/network") + " (" + occ.Why + ")";
		}
		if (!occ.Scoped && occ.Use != Use.Display)
		{
			bool flag = Analysis.IsTokenLike(occ.Value);
			if (flag || usedAsId.Contains(occ.Value))
			{
				report.SkippedToken++;
				return "left to display time (" + (flag ? "single word" : "also used as id") + ", " + occ.Why + ")";
			}
		}
		Probe probe = BrokenProbe(plan.Probes, plan.Free, occ.Value, occ.Translated);
		if (probe != null)
		{
			report.SkippedProbe++;
			return "left to display time (the mod tests texts with " + probe?.ToString() + " in " + probe.Where + ")";
		}
		return null;
	}

	private static Probe BrokenProbe(List<Probe> probes, HashSet<string> free, string original, string translated)
	{
		if (free != null && free.Contains(original))
		{
			return null;
		}
		for (int i = 0; i < probes.Count; i++)
		{
			Probe probe = probes[i];
			if (probe.Hits(original) != probe.Hits(translated))
			{
				return probe;
			}
		}
		return null;
	}

	private static bool IsCallHook(Rules rules, MethodReference target)
	{
		if (target == null || !target.HasParameters)
		{
			return false;
		}
		int num = target.Parameters.Count - 1;
		if (((MemberReference)((ParameterReference)target.Parameters[num]).ParameterType).FullName != "System.String")
		{
			return false;
		}
		string dt = Analysis.TypeName(((MemberReference)target).DeclaringType);
		for (int i = 0; i < rules.Calls.Count; i++)
		{
			if (Analysis.Match(rules.Calls[i], target, dt, ((MemberReference)target).Name, num))
			{
				return true;
			}
		}
		return false;
	}

	private static bool IsSkipped(Rules rules, string typeKey, string scope)
	{
		for (int i = 0; i < rules.Skip.Count; i++)
		{
			string text = rules.Skip[i];
			if (text.IndexOf("::", StringComparison.Ordinal) >= 0)
			{
				if (Rules.Glob(text, scope))
				{
					return true;
				}
			}
			else if (Rules.Glob(text, typeKey) || typeKey.StartsWith(text + ".", StringComparison.Ordinal))
			{
				return true;
			}
		}
		return false;
	}

	private static void AddEdit(Plan plan, uint token, int index, string value)
	{
		if (!plan.Edits.TryGetValue(token, out var value2))
		{
			value2 = new List<Edit>();
			plan.Edits[token] = value2;
		}
		Edit edit = new Edit();
		edit.Index = index;
		edit.Value = value;
		value2.Add(edit);
	}

	private static byte[] Apply(byte[] original, BuildOptions o, Plan plan, Report report)
	{
		DirectoryResolver directoryResolver = new DirectoryResolver(o.SearchDirs);
		EnumResolver enumResolver = (EnumResolver)(object)(directoryResolver.Metadata = (IMetadataResolver)(object)new EnumResolver((IAssemblyResolver)(object)directoryResolver));
		try
		{
			return Apply(original, o, plan, report, directoryResolver, enumResolver);
		}
		finally
		{
			report.EnumsKnown = enumResolver.Count;
			report.EnumsAnswered = enumResolver.Answered;
			report.AssemblyRequests = directoryResolver.Requests;
			directoryResolver.Dispose();
		}
	}

	private static byte[] Apply(byte[] original, BuildOptions o, Plan plan, Report report, DirectoryResolver directories, EnumResolver enums)
	{
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0828: Unknown result type (might be due to invalid IL or missing references)
		//IL_082d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0818: Unknown result type (might be due to invalid IL or missing references)
		//IL_0822: Expected O, but got Unknown
		//IL_0534: Unknown result type (might be due to invalid IL or missing references)
		//IL_0539: Unknown result type (might be due to invalid IL or missing references)
		//IL_053d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0601: Unknown result type (might be due to invalid IL or missing references)
		//IL_061b: Unknown result type (might be due to invalid IL or missing references)
		//IL_062e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0643: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Unknown result type (might be due to invalid IL or missing references)
		//IL_022a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0231: Invalid comparison between Unknown and I4
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_023a: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Invalid comparison between Unknown and I4
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_029c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03db: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0408: Unknown result type (might be due to invalid IL or missing references)
		AssemblyDefinition val = Read(original, (IAssemblyResolver)(object)directories, (IMetadataResolver)(object)enums);
		try
		{
			ModuleDefinition mainModule = val.MainModule;
			OpCode opCode;
			foreach (KeyValuePair<uint, List<Edit>> edit in plan.Edits)
			{
				IMetadataTokenProvider obj = mainModule.LookupToken((int)edit.Key);
				MethodDefinition val2 = (MethodDefinition)(object)((obj is MethodDefinition) ? obj : null);
				if (val2 == null || !val2.HasBody)
				{
					throw new InvalidOperationException("method token " + edit.Key.ToString("x8") + " vanished");
				}
				MethodBody body = val2.Body;
				foreach (Edit item in edit.Value)
				{
					Instruction obj2 = body.Instructions[item.Index];
					opCode = obj2.OpCode;
					if ((int)((OpCode)(ref opCode)).Code != 113)
					{
						throw new InvalidOperationException("instruction mismatch in " + ((MemberReference)val2).FullName);
					}
					obj2.Operand = item.Value;
				}
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			Enumerator<AssemblyNameReference> enumerator3 = mainModule.AssemblyReferences.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					AssemblyNameReference current3 = enumerator3.Current;
					hashSet.Add(current3.Name);
				}
			}
			finally
			{
				((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
			MethodDefinition val3 = null;
			foreach (KeyValuePair<uint, List<int>> shim in plan.Shims)
			{
				IMetadataTokenProvider obj3 = mainModule.LookupToken((int)shim.Key);
				MethodDefinition val4 = (MethodDefinition)(object)((obj3 is MethodDefinition) ? obj3 : null);
				if (val4 == null || !val4.HasBody)
				{
					throw new InvalidOperationException("call hook target " + shim.Key.ToString("x8") + " vanished");
				}
				MethodBody body2 = val4.Body;
				ILProcessor iLProcessor = body2.GetILProcessor();
				int num = shim.Value.Count - 1;
				while (num >= 0)
				{
					Instruction val5 = body2.Instructions[shim.Value[num]];
					object operand = val5.Operand;
					MethodReference val6 = (MethodReference)((operand is MethodReference) ? operand : null);
					if (val6 != null)
					{
						opCode = val5.OpCode;
						if ((int)((OpCode)(ref opCode)).Code != 39)
						{
							opCode = val5.OpCode;
							if ((int)((OpCode)(ref opCode)).Code != 110)
							{
								goto IL_0247;
							}
						}
						if (val3 == null)
						{
							val3 = AddGuard(mainModule, o, ((ParameterReference)val6.Parameters[val6.Parameters.Count - 1]).ParameterType);
						}
						Instruction val7 = iLProcessor.Create(val5.OpCode, val6);
						val5.OpCode = OpCodes.Call;
						val5.Operand = val3;
						iLProcessor.InsertAfter(val5, val7);
						report.CallHooks++;
						num--;
						continue;
					}
					goto IL_0247;
					IL_0247:
					throw new InvalidOperationException("instruction mismatch in " + ((MemberReference)val4).FullName);
				}
			}
			if (plan.Hooks.Count > 0)
			{
				foreach (KeyValuePair<uint, List<int>> hook in plan.Hooks)
				{
					IMetadataTokenProvider obj4 = mainModule.LookupToken((int)hook.Key);
					MethodDefinition val8 = (MethodDefinition)(object)((obj4 is MethodDefinition) ? obj4 : null);
					if (val8 == null || !val8.HasBody)
					{
						throw new InvalidOperationException("hook target " + hook.Key.ToString("x8") + " vanished");
					}
					MethodBody body3 = val8.Body;
					if (body3.Instructions.Count == 0)
					{
						continue;
					}
					ILProcessor iLProcessor2 = body3.GetILProcessor();
					Instruction val9 = body3.Instructions[0];
					foreach (int item2 in hook.Value)
					{
						ParameterDefinition val10 = ((MethodReference)val8).Parameters[item2];
						if (val3 == null)
						{
							val3 = AddGuard(mainModule, o, ((ParameterReference)val10).ParameterType);
						}
						iLProcessor2.InsertBefore(val9, iLProcessor2.Create(OpCodes.Ldarg, val10));
						iLProcessor2.InsertBefore(val9, iLProcessor2.Create(OpCodes.Call, (MethodReference)(object)val3));
						iLProcessor2.InsertBefore(val9, iLProcessor2.Create(OpCodes.Starg, val10));
						report.HooksApplied++;
					}
				}
			}
			foreach (KeyValuePair<uint, int> item3 in new List<KeyValuePair<uint, int>>(plan.Fonts))
			{
				IMetadataTokenProvider obj5 = mainModule.LookupToken((int)item3.Key);
				MethodDefinition val11 = (MethodDefinition)(object)((obj5 is MethodDefinition) ? obj5 : null);
				if (val11 == null || !val11.HasBody)
				{
					throw new InvalidOperationException("font method " + item3.Key.ToString("x8") + " vanished");
				}
				MethodBody body4 = val11.Body;
				ILProcessor iLProcessor3 = body4.GetILProcessor();
				List<Instruction> list = new List<Instruction>();
				Instruction val12;
				try
				{
					int num2 = 0;
					if (plan.Hooks.TryGetValue(item3.Key, out var value))
					{
						num2 = value.Count * 3;
					}
					val12 = body4.Instructions[num2];
					TypeReference val13 = null;
					for (int i = 0; i < item3.Value; i++)
					{
						Instruction val14 = body4.Instructions[num2 + i];
						opCode = val14.OpCode;
						if ((int)((OpCode)(ref opCode)).Code != 0)
						{
							list.Add(Copy(iLProcessor3, val14));
							object operand2 = val14.Operand;
							MethodReference val15 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
							if (val15 != null && ((MemberReference)((MemberReference)val15).DeclaringType).FullName == "System.String")
							{
								val13 = ((MemberReference)val15).DeclaringType;
							}
						}
					}
					if (val13 == null)
					{
						val13 = mainModule.TypeSystem.String;
					}
					if (list.Count == 0)
					{
						list.Add(iLProcessor3.Create(OpCodes.Ldnull));
					}
					if (val3 == null)
					{
						val3 = AddGuard(mainModule, o, val13);
					}
					Instruction val16 = iLProcessor3.Create(OpCodes.Pop);
					list.Add(iLProcessor3.Create(OpCodes.Call, (MethodReference)(object)AddFontGuard(mainModule, o, val3, val13)));
					list.Add(iLProcessor3.Create(OpCodes.Isinst, ((MethodReference)val11).ReturnType));
					list.Add(iLProcessor3.Create(OpCodes.Dup));
					list.Add(iLProcessor3.Create(OpCodes.Brfalse, val16));
					list.Add(iLProcessor3.Create(OpCodes.Ret));
					list.Add(val16);
					if (list.Count != FontAdded(body4, num2, item3.Value))
					{
						throw new InvalidOperationException("plan and result differ");
					}
				}
				catch (Exception ex)
				{
					plan.Fonts.Remove(item3.Key);
					plan.FontAdded.Remove(item3.Key);
					report.FontRulesMissed++;
					report.Notes.Add("font method " + ((MemberReference)val11.DeclaringType).Name + "::" + ((MemberReference)val11).Name + " left as it is: " + ex.Message);
					continue;
				}
				foreach (Instruction item4 in list)
				{
					iLProcessor3.InsertBefore(val12, item4);
				}
				report.FontHooks++;
				if (item3.Value == 0)
				{
					report.Notes.Add("font method " + ((MemberReference)val11.DeclaringType).Name + "::" + ((MemberReference)val11).Name + ": does not begin by reading its setting the way 1.0.100 does - the add-on reads the setting from the mod's config file instead");
				}
			}
			if (o.RequirePlugin)
			{
				BumpVersion(mainModule, report);
			}
			if (o.Settings.TranslateData || o.Dump)
			{
				TranslateData(mainModule, o, report, plan.Probes);
			}
			if (o.Stamp != null)
			{
				mainModule.Resources.Add((Resource)new EmbeddedResource("RepoRPG_RU.stamp", (ManifestResourceAttributes)2, Encoding.UTF8.GetBytes(o.Stamp)));
			}
			enumerator3 = mainModule.AssemblyReferences.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					AssemblyNameReference current9 = enumerator3.Current;
					if (!hashSet.Contains(current9.Name) && current9.Name != o.RuntimeAssemblyName)
					{
						throw new InvalidOperationException("unexpected new assembly reference: " + current9.Name);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
			enums.Learn(mainModule, AllTypes(mainModule));
			MemoryStream memoryStream = new MemoryStream(original.Length + 65536);
			val.Write((Stream)memoryStream);
			return memoryStream.ToArray();
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	private static int FontSetting(MethodBody body)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Invalid comparison between Unknown and I4
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Invalid comparison between Unknown and I4
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Invalid comparison between Unknown and I4
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Invalid comparison between Unknown and I4
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Invalid comparison between Unknown and I4
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Invalid comparison between Unknown and I4
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Invalid comparison between Unknown and I4
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Invalid comparison between Unknown and I4
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Invalid comparison between Unknown and I4
		for (int i = 0; i < body.Instructions.Count && i < 10; i++)
		{
			Instruction val = body.Instructions[i];
			OpCode opCode = val.OpCode;
			Code code = ((OpCode)(ref opCode)).Code;
			if ((int)code <= 39)
			{
				if ((int)code == 0 || (int)code == 2)
				{
					continue;
				}
				if ((int)code == 39)
				{
					goto IL_0059;
				}
			}
			else
			{
				if ((int)code == 110)
				{
					goto IL_0059;
				}
				if ((int)code == 120 || (int)code == 123)
				{
					continue;
				}
			}
			return 0;
			IL_0059:
			object operand = val.Operand;
			MethodReference val2 = (MethodReference)((operand is MethodReference) ? operand : null);
			if (val2 == null)
			{
				return 0;
			}
			if (((MemberReference)val2).Name == "Trim" && !val2.HasParameters && ((MemberReference)((MemberReference)val2).DeclaringType).FullName == "System.String")
			{
				Instruction next = val.Next;
				if (next == null)
				{
					return 0;
				}
				opCode = next.OpCode;
				Code code2 = ((OpCode)(ref opCode)).Code;
				if ((int)code2 != 10 && (int)code2 != 11 && (int)code2 != 12 && (int)code2 != 13 && (int)code2 != 19 && (int)code2 != 204)
				{
					return 0;
				}
				return i + 1;
			}
			if (val2.HasParameters || ((MemberReference)val2.ReturnType).FullName == "System.Void")
			{
				return 0;
			}
		}
		return 0;
	}

	private static int FontAdded(MethodBody body, int at, int setting)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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)
		int num = 0;
		for (int i = 0; i < setting; i++)
		{
			OpCode opCode = body.Instructions[at + i].OpCode;
			if ((int)((OpCode)(ref opCode)).Code != 0)
			{
				num++;
			}
		}
		return ((num == 0) ? 1 : num) + 6;
	}

	private static Instruction Copy(ILProcessor il, Instruction ins)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (ins.Operand == null)
		{
			return il.Create(ins.OpCode);
		}
		object operand = ins.Operand;
		FieldReference val = (FieldReference)((operand is FieldReference) ? operand : null);
		if (val != null)
		{
			return il.Create(ins.OpCode, val);
		}
		object operand2 = ins.Operand;
		MethodReference val2 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
		if (val2 != null)
		{
			return il.Create(ins.OpCode, val2);
		}
		OpCode opCode = ins.OpCode;
		throw new InvalidOperationException("font method: cannot repeat " + ((OpCode)(ref opCode)).Name);
	}

	private static MethodDefinition AddFontGuard(ModuleDefinition module, BuildOptions o, MethodDefinition guard, TypeReference stringType)
	{
		//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_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Expected O, but got Unknown
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Expected O, but got Unknown
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Expected O, but got Unknown
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Expected O, but got Unknown
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_017e: Expected O, but got Unknown
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Expected O, but got Unknown
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Expected O, but got Unknown
		//IL_0218: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Expected O, but got Unknown
		//IL_0233: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Unknown result type (might be due to invalid IL or missing references)
		//IL_024d: Unknown result type (might be due to invalid IL or missing references)
		//IL_025a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0296: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0314: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_033c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0343: Expected O, but got Unknown
		TypeDefinition declaringType = guard.DeclaringType;
		Enumerator<MethodDefinition> enumerator = declaringType.Methods.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				MethodDefinition current = enumerator.Current;
				if (((MemberReference)current).Name == "F")
				{
					return current;
				}
			}
		}
		finally
		{
			((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
		}
		TypeReference val = module.TypeSystem.Object;
		TypeReference val2 = null;
		enumerator = declaringType.Methods.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				MethodDefinition current2 = enumerator.Current;
				if (((MemberReference)current2).Name != "Call")
				{
					continue;
				}
				Enumerator<Instruction> enumerator2 = current2.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						object operand = enumerator2.Current.Operand;
						MethodReference val3 = (MethodReference)((operand is MethodReference) ? operand : null);
						if (val3 != null)
						{
							val2 = ((MemberReference)val3).DeclaringType;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}
		finally
		{
			((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
		}
		if (val2 == null)
		{
			throw new InvalidOperationException("the guard class has no reference to the runtime");
		}
		MethodReference val4 = new MethodReference("MenuFont", val, val2);
		val4.HasThis = false;
		val4.Parameters.Add(new ParameterDefinition(stringType));
		FieldDefinition val5 = new FieldDefinition("offF", (FieldAttributes)17, module.TypeSystem.Boolean);
		declaringType.Fields.Add(val5);
		MethodDefinition val6 = new MethodDefinition("CallF", (MethodAttributes)145, val);
		val6.ImplAttributes = (MethodImplAttributes)8;
		((MethodReference)val6).Parameters.Add(new ParameterDefinition("s", (ParameterAttributes)0, stringType));
		declaringType.Methods.Add(val6);
		ILProcessor iLProcessor = val6.Body.GetILProcessor();
		iLProcessor.Append(iLProcessor.Create(OpCodes.Ldarg_0));
		iLProcessor.Append(iLProcessor.Create(OpCodes.Call, val4));
		iLProcessor.Append(iLProcessor.Create(OpCodes.Ret));
		MethodDefinition val7 = new MethodDefinition("F", (MethodAttributes)147, val);
		val7.ImplAttributes = (MethodImplAttributes)0;
		((MethodReference)val7).Parameters.Add(new ParameterDefinition("s", (ParameterAttributes)0, stringType));
		declaringType.Methods.Add(val7);
		MethodBody body = val7.Body;
		body.InitLocals = true;
		VariableDefinition val8 = new VariableDefinition(val);
		body.Variables.Add(val8);
		ILProcessor iLProcessor2 = body.GetILProcessor();
		Instruction val9 = iLProcessor2.Create(OpCodes.Ldnull);
		Instruction val10 = iLProcessor2.Create(OpCodes.Ldarg_0);
		Instruction val11 = iLProcessor2.Create(OpCodes.Pop);
		Instruction val12 = iLProcessor2.Create(OpCodes.Ldloc_0);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ldsfld, (FieldReference)(object)val5));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Brtrue, val9));
		iLProcessor2.Append(val10);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Call, (MethodReference)(object)val6));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Stloc_0));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Leave, val12));
		iLProcessor2.Append(val11);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ldc_I4_1));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Stsfld, (FieldReference)(object)val5));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Leave, val9));
		iLProcessor2.Append(val12);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ret));
		iLProcessor2.Append(val9);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ret));
		ExceptionHandler val13 = new ExceptionHandler((ExceptionHandlerType)0);
		val13.CatchType = val;
		val13.TryStart = val10;
		val13.TryEnd = val11;
		val13.HandlerStart = val11;
		val13.HandlerEnd = val12;
		body.ExceptionHandlers.Add(val13);
		return val7;
	}

	private static MethodDefinition AddGuard(ModuleDefinition module, BuildOptions o, TypeReference stringType)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: 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_0097: Expected O, but got Unknown
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Expected O, but got Unknown
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Expected O, but got Unknown
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Expected O, but got Unknown
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Expected O, but got Unknown
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Expected O, but got Unknown
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Expected O, but got Unknown
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Expected O, but got Unknown
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Expected O, but got Unknown
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Expected O, but got Unknown
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0232: Unknown result type (might be due to invalid IL or missing references)
		//IL_024d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Unknown result type (might be due to invalid IL or missing references)
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fa: Expected O, but got Unknown
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Expected O, but got Unknown
		TypeReference val = module.TypeSystem.Object;
		TypeReference boolean = module.TypeSystem.Boolean;
		AssemblyNameReference val2 = null;
		Enumerator<AssemblyNameReference> enumerator = module.AssemblyReferences.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				AssemblyNameReference current = enumerator.Current;
				if (current.Name == o.RuntimeAssemblyName)
				{
					val2 = current;
					break;
				}
			}
		}
		finally
		{
			((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
		}
		if (val2 == null)
		{
			val2 = new AssemblyNameReference(o.RuntimeAssemblyName, o.RuntimeVersion);
			module.AssemblyReferences.Add(val2);
		}
		TypeReference val3 = new TypeReference("RepoRPG_RU", "Loc", module, (IMetadataScope)(object)val2);
		MethodReference val4 = new MethodReference("T", stringType, val3);
		val4.HasThis = false;
		val4.Parameters.Add(new ParameterDefinition(stringType));
		TypeDefinition val5 = new TypeDefinition("", "<RepoRPG_RU>", (TypeAttributes)1048960, val);
		module.Types.Add(val5);
		FieldDefinition val6 = new FieldDefinition("off", (FieldAttributes)17, boolean);
		val5.Fields.Add(val6);
		MethodDefinition val7 = new MethodDefinition("Call", (MethodAttributes)145, stringType);
		val7.ImplAttributes = (MethodImplAttributes)8;
		((MethodReference)val7).Parameters.Add(new ParameterDefinition("s", (ParameterAttributes)0, stringType));
		val5.Methods.Add(val7);
		ILProcessor iLProcessor = val7.Body.GetILProcessor();
		iLProcessor.Append(iLProcessor.Create(OpCodes.Ldarg_0));
		iLProcessor.Append(iLProcessor.Create(OpCodes.Call, val4));
		iLProcessor.Append(iLProcessor.Create(OpCodes.Ret));
		MethodDefinition val8 = new MethodDefinition("T", (MethodAttributes)147, stringType);
		val8.ImplAttributes = (MethodImplAttributes)0;
		((MethodReference)val8).Parameters.Add(new ParameterDefinition("s", (ParameterAttributes)0, stringType));
		val5.Methods.Add(val8);
		MethodBody body = val8.Body;
		body.InitLocals = true;
		VariableDefinition val9 = new VariableDefinition(stringType);
		body.Variables.Add(val9);
		ILProcessor iLProcessor2 = body.GetILProcessor();
		Instruction val10 = iLProcessor2.Create(OpCodes.Ldarg_0);
		Instruction val11 = iLProcessor2.Create(OpCodes.Ldarg_0);
		Instruction val12 = iLProcessor2.Create(OpCodes.Pop);
		Instruction val13 = iLProcessor2.Create(OpCodes.Ldloc_0);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ldsfld, (FieldReference)(object)val6));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Brtrue, val10));
		iLProcessor2.Append(val11);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Call, (MethodReference)(object)val7));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Stloc_0));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Leave, val13));
		iLProcessor2.Append(val12);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ldc_I4_1));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Stsfld, (FieldReference)(object)val6));
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Leave, val10));
		iLProcessor2.Append(val13);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ret));
		iLProcessor2.Append(val10);
		iLProcessor2.Append(iLProcessor2.Create(OpCodes.Ret));
		ExceptionHandler val14 = new ExceptionHandler((ExceptionHandlerType)0);
		val14.CatchType = val;
		val14.TryStart = val11;
		val14.TryEnd = val12;
		val14.HandlerStart = val12;
		val14.HandlerEnd = val13;
		body.ExceptionHandlers.Add(val14);
		return val8;
	}

	private static void BumpVersion(ModuleDefinition module, Report report)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_00d1: Unknown result type (might be due to invalid IL or missing references)
		foreach (TypeDefinition item in AllTypes(module))
		{
			if (!item.HasCustomAttributes)
			{
				continue;
			}
			Enumerator<CustomAttribute> enumerator2 = item.CustomAttributes.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					CustomAttribute current2 = enumerator2.Current;
					if (!(((MemberReference)current2.AttributeType).FullName != "BepInEx.BepInPlugin") && current2.ConstructorArguments.Count == 3)
					{
						CustomAttributeArgument val = current2.ConstructorArguments[0];
						if (string.Equals(((CustomAttributeArgument)(ref val)).Value as string, "rpgmod.semibotrpg", StringComparison.Ordinal))
						{
							val = current2.ConstructorArguments[2];
							string text = ((CustomAttributeArgument)(ref val)).Value as string;
							string text2 = Bump(text);
							Collection<CustomAttributeArgument> constructorArguments = current2.ConstructorArguments;
							val = current2.ConstructorArguments[2];
							constructorArguments[2] = new CustomAttributeArgument(((CustomAttributeArgument)(ref val)).Type, (object)text2);
							report.OriginalVersion = text;
							report.NewVersion = text2;
							return;
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
		}
		throw new InvalidOperationException("[BepInPlugin(\"rpgmod.semibotrpg\", ...)] not found - is this really RepoRPG?");
	}

	internal static string Bump(string version)
	{
		Version version2 = new Version(version);
		int num = ((version2.Build >= 0) ? version2.Build : 0);
		int num2 = ((version2.Revision < 0) ? 1 : (version2.Revision + 1));
		return version2.Major + "." + version2.Minor + "." + num + "." + num2;
	}

	public static string ReadPluginVersion(ModuleDefinition module)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		foreach (TypeDefinition item in AllTypes(module))
		{
			if (!item.HasCustomAttributes)
			{
				continue;
			}
			Enumerator<CustomAttribute> enumerator2 = item.CustomAttributes.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					CustomAttribute current2 = enumerator2.Current;
					if (!(((MemberReference)current2.AttributeType).FullName != "BepInEx.BepInPlugin") && current2.ConstructorArguments.Count == 3)
					{
						CustomAttributeArgument val = current2.ConstructorArguments[0];
						if (string.Equals(((CustomAttributeArgument)(ref val)).Value as string, "rpgmod.semibotrpg", StringComparison.Ordinal))
						{
							val = current2.ConstructorArguments[2];
							return ((CustomAttributeArgument)(ref val)).Value as string;
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
		}
		return null;
	}

	private static void TranslateData(ModuleDefinition module, BuildOptions o, Report report, List<Probe> probes)
	{
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Expected O, but got Unknown
		for (int i = 0; i < module.Resources.Count; i++)
		{
			Resource obj = module.Resources[i];
			EmbeddedResource val = (EmbeddedResource)(object)((obj is EmbeddedResource) ? obj : null);
			if (val == null || !((Resource)val).Name.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
			{
				continue;
			}
			byte[] resourceData = val.GetResourceData();
			if (o.Dump)
			{
				report.Resources[((Resource)val).Name] = resourceData;
			}
			bool translate = o.Settings.TranslateData;
			string text = ((Resource)val).Name.Substring(0, ((Resource)val).Name.Length - 5);
			int num = text.LastIndexOf('.');
			if (num >= 0)
			{
				text = text.Substring(num + 1);
			}
			bool flag = resourceData.Length >= 3 && resourceData[0] == 239 && resourceData[1] == 187 && resourceData[2] == 191;
			string json = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false).GetString(resourceData, flag ? 3 : 0, resourceData.Length - (flag ? 3 : 0));
			o.Lang.Data.TryGetValue(text, out var own);
			o.Lang.Data.TryGetValue("", out var any);
			string stemCopy = text;
			Rules rules = o.Rules;
			bool dump = o.Dump;
			int replaced;
			string s = JsonText.Translate(json, delegate(string path, string property, string value)
			{
				bool flag2 = rules.DataAllowed(stemCopy, property, path);
				if (dump)
				{
					report.DataDump.Add(stemCopy + "\t" + path + "\t" + (flag2 ? "+" : "-") + "\t" + Escape(value));
				}
				if (!flag2 || !translate)
				{
					return (string)null;
				}
				string value2;
				bool flag3 = own != null && own.TryGetValue(value, out value2);
				if (!flag3)
				{
					if (any == null || !any.TryGetValue(value, out value2))
					{
						return (string)null;
					}
				}
				else
				{
					value2 = own[value];
				}
				Probe probe = (rules.ProbeFreeData.Contains(stemCopy) ? null : BrokenProbe(probes, rules.ProbeFree, value, value2));
				if (probe != null)
				{
					report.SkippedProbe++;
					report.Notes.Add("data left as is (the mod tests texts with " + probe?.ToString() + " in " + probe.Where + "): " + stemCopy + " " + path + "  \"" + Escape(value) + "\"");
					return (string)null;
				}
				report.UsedData.Add((flag3 ? stemCopy : "") + "\n" + value);
				return value2;
			}, out replaced);
			if (replaced != 0)
			{
				byte[] bytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(s);
				byte[] array = bytes;
				if (flag)
				{
					array = new byte[bytes.Length + 3];
					array[0] = 239;
					array[1] = 187;
					array[2] = 191;
					Buffer.BlockCopy(bytes, 0, array, 3, bytes.Length);
				}
				module.Resources[i] = (Resource)new EmbeddedResource(((Resource)val).Name, ((Resource)val).Attributes, array);
				report.DataReplaced += replaced;
				report.DataFiles++;
			}
		}
	}

	private static void Verify(byte[] result, Plan plan, Report report)
	{
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_055a: Unknown result type (might be due to invalid IL or missing references)
		//IL_055f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		//IL_027d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Invalid comparison between Unknown and I4
		//IL_0341: Unknown result type (might be due to invalid IL or missing references)
		//IL_0346: Unknown result type (might be due to invalid IL or missing references)
		//IL_034a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0351: Invalid comparison between Unknown and I4
		//IL_041b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0420: Unknown result type (might be due to invalid IL or missing references)
		//IL_0424: Unknown result type (might be due to invalid IL or missing references)
		//IL_042b: Invalid comparison between Unknown and I4
		//IL_037f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0384: Unknown result type (might be due to invalid IL or missing references)
		//IL_0388: Unknown result type (might be due to invalid IL or missing references)
		//IL_038f: Invalid comparison between Unknown and I4
		//IL_0398: Unknown result type (might be due to invalid IL or missing references)
		//IL_039d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a8: Invalid comparison between Unknown and I4
		Dictionary<string, Expect> dictionary = new Dictionary<string, Expect>(StringComparer.Ordinal);
		HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
		foreach (KeyValuePair<uint, int> count in plan.Counts)
		{
			string text = plan.Names[count.Key];
			Expect expect = new Expect();
			expect.Count = count.Value;
			expect.Shift = (plan.Hooks.TryGetValue(count.Key, out var value) ? (value.Count * 3) : 0);
			if (plan.FontAdded.TryGetValue(count.Key, out expect.Font))
			{
				expect.Shift += expect.Font;
			}
			plan.Shims.TryGetValue(count.Key, out expect.Shims);
			plan.Edits.TryGetValue(count.Key, out expect.Edits);
			if (dictionary.ContainsKey(text))
			{
				hashSet.Add(text);
			}
			else
			{
				dictionary[text] = expect;
			}
		}
		AssemblyDefinition val = Read(result);
		try
		{
			ModuleDefinition mainModule = val.MainModule;
			int num = 0;
			foreach (TypeDefinition item in AllTypes(mainModule))
			{
				Enumerator<MethodDefinition> enumerator3 = item.Methods.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						MethodDefinition current3 = enumerator3.Current;
						if (!current3.HasBody)
						{
							continue;
						}
						MethodBody body = current3.Body;
						num++;
						string fullName = ((MemberReference)current3).FullName;
						if (((MemberReference)item).Name == "<RepoRPG_RU>" && ((TypeReference)item).Namespace.Length == 0)
						{
							num--;
						}
						else
						{
							if (hashSet.Contains(fullName))
							{
								continue;
							}
							if (!dictionary.TryGetValue(fullName, out var value2))
							{
								throw new InvalidOperationException("verification: unexpected method " + fullName);
							}
							value2.Seen = true;
							if (body.Instructions.Count != value2.Count + value2.Shift + ((value2.Shims != null) ? value2.Shims.Count : 0))
							{
								throw new InvalidOperationException("verification: instruction count changed in " + fullName);
							}
							OpCode opCode;
							if (value2.Font > 0)
							{
								bool flag = false;
								for (int i = 0; i < value2.Shift && i < body.Instructions.Count; i++)
								{
									object operand = body.Instructions[i].Operand;
									MethodReference val2 = (MethodReference)((operand is MethodReference) ? operand : null);
									opCode = body.Instructions[i].OpCode;
									if ((int)((OpCode)(ref opCode)).Code == 39 && val2 != null && ((MemberReference)((MemberReference)val2).DeclaringType).Name == "<RepoRPG_RU>" && ((MemberReference)val2).Name == "F")
									{
										flag = true;
									}
								}
								if (!flag)
								{
									throw new InvalidOperationException("verification: font hook not written in " + fullName);
								}
							}
							if (value2.Shims != null)
							{
								foreach (int shim in value2.Shims)
								{
									Instruction val3 = body.Instructions[value2.Moved(shim)];
									object operand2 = val3.Operand;
									MethodReference val4 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
									opCode = val3.OpCode;
									if ((int)((OpCode)(ref opCode)).Code == 39 && val4 != null && !(((MemberReference)((MemberReference)val4).DeclaringType).Name != "<RepoRPG_RU>") && val3.Next != null)
									{
										opCode = val3.Next.OpCode;
										if ((int)((OpCode)(ref opCode)).Code == 39)
										{
											continue;
										}
										opCode = val3.Next.OpCode;
										if ((int)((OpCode)(ref opCode)).Code == 110)
										{
											continue;
										}
									}
									throw new InvalidOperationException("verification: call hook not written in " + fullName);
								}
							}
							if (value2.Edits == null)
							{
								continue;
							}
							foreach (Edit edit in value2.Edits)
							{
								Instruction val5 = body.Instructions[value2.Moved(edit.Index)];
								opCode = val5.OpCode;
								if ((int)((OpCode)(ref opCode)).Code != 113 || !string.Equals(val5.Operand as string, edit.Value, StringComparison.Ordinal))
								{
									throw new InvalidOperationException("verification: literal not written in " + fullName);
								}
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
				}
			}
			if (num != plan.Counts.Count)
			{
				throw new InvalidOperationException("verification: method count changed (" + num + " vs " + plan.Counts.Count + ")");
			}
			foreach (KeyValuePair<string, Expect> item2 in dictionary)
			{
				if (!item2.Value.Seen)
				{
					throw new InvalidOperationException("verification: method lost: " + item2.Key);
				}
			}
			Enumerator<Resource> enumerator7 = mainModule.Resources.GetEnumerator();
			try
			{
				while (enumerator7.MoveNext())
				{
					Resource current7 = enumerator7.Current;
					EmbeddedResource val6 = (EmbeddedResource)(object)((current7 is EmbeddedResource) ? current7 : null);
					if (val6 != null)
					{
						val6.GetResourceData();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator7/*cast due to .constrained prefix*/).Dispose();
			}
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	internal static string Escape(string s)
	{
		StringBuilder stringBuilder = new StringBuilder(s.Length + 8);
		foreach (char c in s)
		{
			switch (c)
			{
			case '\\':
				stringBuilder.Append("\\\\");
				break;
			case '\n':
				stringBuilder.Append("\\n");
				break;
			case '\r':
				stringBuilder.Append("\\r");
				break;
			case '\t':
				stringBuilder.Append("\\t");
				break;
			default:
				stringBuilder.Append(c);
				break;
			}
		}
		return stringBuilder.ToString();
	}
}
public static class Patcher
{
	private static readonly string[] None = new string[0];

	public static IEnumerable<string> TargetDLLs => None;

	public static void Patch(AssemblyDefinition assembly)
	{
	}

	private static void AddPath(List<string> list, string property)
	{
		try
		{
			PropertyInfo property2 = typeof(Paths).GetProperty(property, BindingFlags.Static | BindingFlags.Public);
			if (!(property2 == null))
			{
				object value = property2.GetValue(null, null);
				if (value is string item)
				{
					list.Add(item);
				}
				else if (value is string[] collection)
				{
					list.AddRange(collection);
				}
			}
		}
		catch
		{
		}
	}

	public static void Initialize()
	{
		ManualLogSource val = null;
		try
		{
			val = Logger.CreateLogSource("RepoRPG RU");
			Env env = new Env();
			env.PluginPath = Paths.PluginPath;
			env.ConfigPath = Paths.ConfigPath;
			AddPath(env.SearchDirs, "DllSearchPaths");
			AddPath(env.SearchDirs, "ManagedPath");
			AddPath(env.SearchDirs, "BepInExAssemblyDirectory");
			try
			{
				env.SearchDirs.Add(Path.GetDirectoryName(typeof(object).Assembly.Location));
			}
			catch
			{
			}
			env.SearchDirs.Add(Paths.PluginPath);
			env.SearchDirs.Add(Paths.PatcherPluginPath);
			ManualLogSource sink = val;
			env.Info = delegate(string s)
			{
				sink.LogInfo((object)s);
			};
			env.Warn = delegate(string s)
			{
				sink.LogWarning((object)s);
			};
			env.Error = delegate(string s)
			{
				sink.LogError((object)s);
			};
			Worker.Run(env);
		}
		catch (Exception ex)
		{
			try
			{
				if (val != null)
				{
					val.LogError((object)("Русификатор не запустился, мод RepoRPG останется английским: " + ex));
				}
			}
			catch
			{
			}
		}
	}
}
internal sealed class Env
{
	public string PluginPath;

	public string ConfigPath;

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

	public Action<string> Info;

	public Action<string> Warn;

	public Action<string> Error;
}
internal static class Worker
{
	internal sealed class Candidate
	{
		public string Path;

		public byte[] Bytes;

		public Version Version = new Version(0, 0);

		public string VersionText = "?";

		public bool Generated;

		public string Stamp;
	}

	public const string StampResource = "RepoRPG_RU.stamp";

	private const string OutputName = "RepoRPG.dll";

	public static void Run(Env env)
	{
		if (string.IsNullOrEmpty(env.PluginPath) || !Directory.Exists(env.PluginPath))
		{
			return;
		}
		Settings settings = Settings.Load(Path.Combine(env.ConfigPath ?? "", "RepoRPG_RU.cfg"), createIfMissing: true);
		string text = FindFile(env.PluginPath, "RepoRPG_RU.dll");
		string text2 = ((text != null) ? Path.GetDirectoryName(text) : null);
		string text3 = ((text2 != null) ? Path.Combine(text2, "RepoRPG.dll") : null);
		Candidate candidate = null;
		foreach (string item in FindAll(env.PluginPath, "RepoRPG.dll"))
		{
			Candidate candidate2 = Inspect(item);
			if (candidate2 == null)
			{
				continue;
			}
			if (candidate2.Generated)
			{
				if (text3 == null || !SamePath(item, text3))
				{
					TryDelete(item, env, "устаревшая копия");
				}
				continue;
			}
			if (text3 != null && SamePath(item, text3))
			{
				env.Warn("Оригинальный RepoRPG.dll лежит в папке русификатора (" + item + "). Перенесите его в отдельную папку, иначе перевод не применяется.");
				return;
			}
			if (candidate == null || candidate2.Version > candidate.Version)
			{
				candidate = candidate2;
			}
		}
		if (text2 == null)
		{
			env.Warn("Не найден RepoRPG_RU.dll в BepInEx/plugins - русификатор установлен не полностью, перевод не применяется.");
			return;
		}
		if (!settings.Enabled)
		{
			TryDelete(text3, env, "перевод выключен в RepoRPG_RU.cfg");
			env.Info("Перевод выключен (Enabled = false).");
			return;
		}
		if (candidate == null)
		{
			TryDelete(text3, env, "оригинальный мод не найден");
			env.Warn("Мод RepoRPG (RepoRPG.dll) не найден или выключен - переводить нечего.");
			return;
		}
		try
		{
			Translate(env, settings, candidate, text2, text3);
		}
		catch (Exception ex)
		{
			TryDelete(text3, env, "ошибка при создании");
			env.Error("Не удалось создать переведённую копию RepoRPG " + candidate.VersionText + " - мод загрузится на английском. Причина: " + ex);
		}
	}

	private static void Translate(Env env, Sett