Decompiled source of OdinsWatch v0.2.11

OdinsWatch.dll

Decompiled 5 months ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DW4EXhYhIbucMIqmBND;
using HarmonyLib;
using Ibf5epYEXNAvuXRyEnK;
using JetBrains.Annotations;
using JoXnjgYv0df4W3xDKmk;
using Microsoft.CodeAnalysis;
using OdinsWatch;
using Q2wfu5G4SpRpViVq0Ca;
using QwPTvDXd7LY45iRjRke;
using ServerSync;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using W9YwkRYCJPH3JA0r9QO;
using iFUdDoYfB5JjhOYAes9;
using mjoxDkDswu6MbTJhUpT;
using sEvIbrpYw521JZPhBvI;
using tntNoJpcA1jOiNMSMSE;
using vCNxXkD4X2qrbrVgfc5;

[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("资源工坊www.aopk.cn")]
[assembly: AssemblyCopyright("资源工坊www.aopk.cn")]
[assembly: Guid("ae182502-5840-458c-b6ad-39d0e0d256ab")]
[assembly: SuppressIldasm]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyFileVersion("0.2.11")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("奥丁之眼-0.2.11")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyCompany("蝼蚁梦制作")]
[assembly: AssemblyProduct("OdinsWatch")]
[assembly: AssemblyDescription("蝼蚁梦制作")]
[assembly: AssemblyConfiguration("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.11.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class EmbeddedAttribute : Attribute
	{
		public EmbeddedAttribute()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
			NullableFlags = new byte[1] { P_0 };
		}

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

		public NullableContextAttribute(byte P_0)
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
			Flag = P_0;
		}
	}
}
namespace OdinsWatch
{
	[BepInPlugin("AOPK.OdinsWatch", "奥丁之眼", "0.2.11")]
	public class Mian : BaseUnityPlugin
	{
		public Harmony harmony;

		private A3BFGYYOWuGDVlWr0tv VJAbctCKf;

		private RmE7DAD3XqITqHVXCf6 WcFeeaGsh;

		private rmqoQuD1dmgVsWx9GDh AsUIREvn8;

		internal static bool Vd6m941eB;

		internal static readonly bool e9vHGRFq7;

		private readonly ConfigSync lBq2KhJUv;

		internal static readonly string kFZqThMli;

		internal static ConfigEntry<string> IUffGiADW;

		internal static ConfigEntry<ushort> kMnANVW2s;

		internal static ConfigEntry<string> fULrmZXoi;

		private ConfigEntry<bool> jnw8YZ5mb;

		internal static ConfigEntry<bool> P517GRqyW;

		internal static ConfigEntry<string> hJhBQTE0O;

		internal static ConfigEntry<string> NeLScyAii;

		internal static ConfigEntry<bool> Mg1QbItQS;

		internal static ConfigEntry<int> zCHCH4qs2;

		internal static ConfigEntry<string> V99xApmOW;

		internal static ConfigEntry<bool> lpa1LHjix;

		internal static ConfigEntry<int> RhvsAyUM9;

		internal static ConfigEntry<int> fIVNqJi4b;

		internal static ConfigEntry<bool> oI2t7epwD;

		internal static ConfigEntry<string> K7BW4a0vf;

		internal static ConfigEntry<string> EMRL1Mlri;

		internal static ConfigEntry<string> ggSjtMgoT;

		internal static ConfigEntry<string> kSuFgQiaI;

		internal static ConfigEntry<string> xbcg0k2IX;

		internal static ConfigEntry<bool> KdvVuTnUH;

		internal static ConfigEntry<float> bCIafXHCA;

		internal static ConfigEntry<float> AZr6BcoIV;

		internal static ConfigEntry<float> gUVwxj488;

		internal static ConfigEntry<float> BuR0tndhW;

		internal static ConfigEntry<float> GfRRsM5CF;

		internal static ConfigEntry<bool> uFqMnYtDH;

		internal static ConfigEntry<int> G2RKbmNSI;

		internal static ConfigEntry<float> Xx5P3OrIG;

		internal static ConfigEntry<float> OmlyHhWjK;

		internal static ConfigEntry<float> gbulpnvNf;

		internal static ConfigEntry<float> MNnUt1qYq;

		internal static ConfigEntry<float> c08kH2QdM;

		internal static ConfigEntry<float> qEkncufUv;

		internal static ConfigEntry<float> VFC9fggr6;

		internal static ConfigEntry<bool> NH4oPOGA3;

		internal static ConfigEntry<bool> ioEzBRDGs;

		internal static ConfigEntry<bool> M4HDE84DhH;

		internal static ConfigEntry<bool> bSxDDqfUGA;

		internal static ConfigEntry<bool> n25DYt8DwL;

		internal static ConfigEntry<bool> pd8DpOefvC;

		internal static ConfigEntry<float> hifDObBvBv;

		internal static ConfigEntry<float> JIuDhS1RMJ;

		internal static ConfigEntry<float> JVZDixx2R1;

		internal static ConfigEntry<float> iikDGJB0ee;

		public void Start()
		{
			if (rmqoQuD1dmgVsWx9GDh.Dy7DjrKY8t())
			{
				tLDHRnDzaovuMvmKXEJ.IAmYperstW(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-947559740 ^ -947559740));
				tLDHRnDzaovuMvmKXEJ.IAmYperstW(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2076552374 ^ -2076552442), rmqoQuD1dmgVsWx9GDh.d4aDFbNeyU(), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			}
		}

		public void Awake()
		{
			//IL_0bda: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be5: Expected O, but got Unknown
			//IL_0c62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c6c: Expected O, but got Unknown
			jnw8YZ5mb = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-966540854 ^ -966540894), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1133434849 ^ -1133434771), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x6F299361 ^ 0x6F29931F));
			P517GRqyW = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1546067013 ^ 0x5C271C2D), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48FCD092 ^ 0x48FCD078), value: false, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1836494548 ^ -1836494374));
			NeLScyAii = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x6BC2F73E ^ 0x6BC2F756), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1836494548 ^ -1836494816), "", cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x2F616220 ^ 0x2F616334), synchronizedSetting: false);
			hJhBQTE0O = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1778664704 ^ -1778664600), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-520423485 ^ -520423807), "", cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x8BBB05 ^ 0x8BBA11), synchronizedSetting: false);
			if (e9vHGRFq7)
			{
				IUffGiADW = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1343710716 ^ -1343710386), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x642C10F0 ^ 0x642C11A8), "", cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994026848 ^ -994026556), synchronizedSetting: false);
				kMnANVW2s = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-520423485 ^ -520423799), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--633333367 ^ 0x25BFE7FF), (ushort)2456, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4915F790 ^ 0x4915F600), synchronizedSetting: false);
				fULrmZXoi = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1826996771 ^ -1826997097), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48FCD092 ^ 0x48FCD19E), "", cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1127543568 ^ 0x4334F2B2), synchronizedSetting: false);
			}
			Mg1QbItQS = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xBC87536 ^ 0xBC8755E), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994167792 ^ -994167392), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-601821950 ^ -601822014));
			zCHCH4qs2 = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1037472129 ^ 0x3DD6905F), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-562080393 ^ -562080613), 2, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x53AA769E ^ 0x53AA7762));
			RhvsAyUM9 = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-100829183 ^ -100828705), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-98749177 ^ -98748597), 1, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-485863768 ^ -485863596));
			fIVNqJi4b = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x50C420EF ^ 0x50C42131), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1288876563 ^ 0x4CD2B04F), 1, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-839022388 ^ -839022288));
			oI2t7epwD = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1730898610 ^ -1730898800), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1836494548 ^ -1836493988), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-216930971 ^ -216930535));
			lpa1LHjix = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D968D34 ^ 0x3D968D5C), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519167090), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x61BC3310 ^ 0x61BC31A6));
			xbcg0k2IX = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-98749177 ^ -98748463), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-271261740 ^ -271262416), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519167024), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-947559740 ^ -947559970));
			ggSjtMgoT = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x35DEBE67 ^ 0x35DEBCB1), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1098409344 ^ -1098409528), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-738700297 ^ -738701041), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-271261740 ^ -271262584));
			V99xApmOW = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1137296265 ^ -1137295711), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xBC87536 ^ 0xBC876BC), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x50C420EF ^ 0x50C42379), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-507095511 ^ -507095553));
			K7BW4a0vf = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1E3F61D9 ^ 0x1E3F630F), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1810016084 ^ -1810014740), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994167792 ^ -994168484), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-878854484 ^ -878855174));
			kSuFgQiaI = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x6F299361 ^ 0x6F2991B7), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7601BE71 ^ 0x7601BBD1), "", cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x16E1CAD4 ^ 0x16E1CF7A));
			EMRL1Mlri = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1627430108 ^ 0x61009E0A), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-98749177 ^ -98750209), "", cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-85961350 ^ -85961858));
			KdvVuTnUH = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-601821950 ^ -601821846), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1660133231 ^ -1660131647), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xFDCC567 ^ 0xFDCC307));
			bCIafXHCA = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-98749177 ^ -98749561), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1573792578 ^ -1573793232), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xC4E8F6C ^ 0xC4E89CC));
			AZr6BcoIV = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--592664568 ^ 0x23535178), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-58607713 ^ -58609337), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x399BCC15 ^ 0x399BCAF9));
			gUVwxj488 = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-86372877 ^ -86373517), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1098409344 ^ -1098408538), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1856477526 ^ -1856478832));
			BuR0tndhW = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-280820206 ^ -280821614), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-20144152 ^ -20146020), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1495448691 ^ -1495448565));
			GfRRsM5CF = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1B444CBC ^ 0x1B444A3C), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x50C420EF ^ 0x50C42741), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1243848504 ^ -1243846794));
			JVZDixx2R1 = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1919466676 ^ -1919466036), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x39B5DC8B ^ 0x39B5DB6F), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x642C10F0 ^ 0x642C170C));
			iikDGJB0ee = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1573792578 ^ -1573793218), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x16E1CAD4 ^ 0x16E1C2FE), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4667001E ^ 0x4667085C));
			G2RKbmNSI = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7514E7A3 ^ 0x7514E123), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4395287 ^ 0x4395AF7), 0, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7514E7A3 ^ 0x7514EF25));
			Xx5P3OrIG = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--832233779 ^ 0x319AE7B3), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x2E6806F ^ 0x2E688DD), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x2E6806F ^ 0x2E688AD));
			OmlyHhWjK = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1627430108 ^ 0x61009A5C), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-738700297 ^ -738698465), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1919466676 ^ -1919464524));
			gbulpnvNf = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-738700297 ^ -738699913), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-601821950 ^ -601824228), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1491610595 ^ -1491608277));
			MNnUt1qYq = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1198427699 ^ -1198426291), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5289DC43 ^ 0x5289D527), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-520423485 ^ -520421701));
			c08kH2QdM = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1127543568 ^ 0x4334F590), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x64B2575B ^ 0x64B25ECD), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48DC695F ^ 0x48DC60F5));
			qEkncufUv = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1034721101 ^ -1034719693), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1528336581 ^ -1528338705), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x64B2575B ^ 0x64B25EB3));
			VFC9fggr6 = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-86372877 ^ -86373517), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1778664704 ^ -1778667242), 0f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x36BA69E7 ^ 0x36BA63CD));
			uFqMnYtDH = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5ED6308F ^ 0x5ED6360F), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-621329454 ^ -621327994), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1546067013 ^ 0x5C27162D));
			ioEzBRDGs = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D968D34 ^ 0x3D968BB4), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-868607152 ^ -868609576), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5ED6308F ^ 0x5ED63A13));
			M4HDE84DhH = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D968D34 ^ 0x3D968BB4), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-520423485 ^ -520422017), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x66F5DEF7 ^ 0x66F5D427));
			bSxDDqfUGA = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-738700297 ^ -738699913), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x35DEBE67 ^ 0x35DEB497), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7629FEA ^ 0x76294EE));
			n25DYt8DwL = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-271261740 ^ -271263404), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x446F6176 ^ 0x446F6A52), value: true, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x642C10F0 ^ 0x642C1BC8));
			pd8DpOefvC = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7514E7A3 ^ 0x7514E123), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x399BCC15 ^ 0x399BC74D), value: false, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1219259449 ^ -1219258197));
			hifDObBvBv = VGbJJ1OnO(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x714D8A19 ^ 0x714D8C99), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48DC695F ^ 0x48DC62D3), 0.2f, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1491610595 ^ -1491607619));
			JIuDhS1RMJ = pl1ZRGDQl(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1F124952 ^ 0x1F124FD2), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-111499785 ^ -111497655), 1f, new ConfigDescription(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1ACAA66 ^ 0x1ACA1B2), (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			BvC3ZVgZC();
			YdKtgndOWJLX6Bc7Ufd.xM8dDC8RJr(this, A3BFGYYOWuGDVlWr0tv.sv4YTO3nAA(), YdKtgndOWJLX6Bc7Ufd.WcBdh533am);
			YdKtgndOWJLX6Bc7Ufd.xM8dDC8RJr(this, vraQVXY4ORnlIsr1SmW.OFpYebLP6S(), YdKtgndOWJLX6Bc7Ufd.WcBdh533am);
			lBq2KhJUv.AddLockingConfigEntry<bool>(jnw8YZ5mb);
			VJAbctCKf = new A3BFGYYOWuGDVlWr0tv();
			WcFeeaGsh = new RmE7DAD3XqITqHVXCf6((MonoBehaviour)(object)this);
			AsUIREvn8 = new rmqoQuD1dmgVsWx9GDh();
			AsUIREvn8.ld3DNa11W5();
			harmony = new Harmony(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1491610595 ^ -1491609569));
			QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(harmony, QUxtOOdi9ZTQhPRfeQt.QecdGp7tNa);
			SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-134741461 ^ -134738417), SLy5u1dT0UmS9JNX6t8.WhQdXrKxUE);
		}

		public void Update()
		{
			GqLoUAYq212BF03PZS9.qiUYryyadX();
			K9oy67pDOyO2aceVKqs.pVxpOO26D8();
			if (Vd6m941eB && I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1) != null)
			{
				WcFeeaGsh.UgSDbu15Wq();
				Vd6m941eB = false;
			}
			if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef) && rmqoQuD1dmgVsWx9GDh.OhuDUCkdhZ)
			{
				AsUIREvn8.MMYDWAsvJM();
				rmqoQuD1dmgVsWx9GDh.OhuDUCkdhZ = false;
			}
			if (IsClientInstance() && !Vd6m941eB && rmqoQuD1dmgVsWx9GDh.AfrDlnjZaS)
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363AAA1C));
				RmE7DAD3XqITqHVXCf6.J5dDqyX3Cv(rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA);
				rmqoQuD1dmgVsWx9GDh.AfrDlnjZaS = false;
			}
			if (A3BFGYYOWuGDVlWr0tv.nfDYGLYgfk() && A3BFGYYOWuGDVlWr0tv.QxHYubEkew)
			{
				string text = ((A3BFGYYOWuGDVlWr0tv.zFvYZlWOE1 == 0) ? XkpvLRd5hUPPJ3RZwtV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x16E1CAD4 ^ 0x16E1C5F8), yJR8Ccd4LVsXxuAyWlX.xM8dDC8RJr(ref A3BFGYYOWuGDVlWr0tv.ndgY33VK5a, 3.0, yJR8Ccd4LVsXxuAyWlX.riPdvtdOLD), XkpvLRd5hUPPJ3RZwtV.aUndbJKkxf) : "");
				string text2 = ((A3BFGYYOWuGDVlWr0tv.zFvYZlWOE1 == 1) ? XkpvLRd5hUPPJ3RZwtV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1529015598 ^ -1529012738), yJR8Ccd4LVsXxuAyWlX.xM8dDC8RJr(ref A3BFGYYOWuGDVlWr0tv.ndgY33VK5a, 15.0, yJR8Ccd4LVsXxuAyWlX.riPdvtdOLD), XkpvLRd5hUPPJ3RZwtV.aUndbJKkxf) : "");
				string text3 = ((A3BFGYYOWuGDVlWr0tv.zFvYZlWOE1 == 2) ? cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-507095511 ^ -507094675) : "");
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(o4ouKmdesL12FB7Dr77.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1789112222 ^ -1789108418), new object[4]
				{
					A3BFGYYOWuGDVlWr0tv.Lp0Yi6Bbw5(A3BFGYYOWuGDVlWr0tv.zFvYZlWOE1),
					text,
					text2,
					text3
				}, o4ouKmdesL12FB7Dr77.ik4dIYEY9L));
				A3BFGYYOWuGDVlWr0tv.QxHYubEkew = false;
			}
			else if (A3BFGYYOWuGDVlWr0tv.nfDYGLYgfk() && A3BFGYYOWuGDVlWr0tv.hZ5YcTres9)
			{
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(ILnneIdmmDqT1UvTTqV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1836494548 ^ -1836491096), A3BFGYYOWuGDVlWr0tv.Lp0Yi6Bbw5(A3BFGYYOWuGDVlWr0tv.zFvYZlWOE1), yJR8Ccd4LVsXxuAyWlX.xM8dDC8RJr(ref A3BFGYYOWuGDVlWr0tv.ndgY33VK5a, 1.0, yJR8Ccd4LVsXxuAyWlX.riPdvtdOLD), ILnneIdmmDqT1UvTTqV.EgodHN9gTQ));
				A3BFGYYOWuGDVlWr0tv.hZ5YcTres9 = false;
			}
			if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)285, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i) && VjMScKdrea0l2HoViGP.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.Dv2dARN0XF), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1084993159 ^ -1084989749), VjMScKdrea0l2HoViGP.Khvd8E2hM0))
			{
				HRTR2Ad7h0idySB0Cg7.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4395287 ^ 0x4395D43), HRTR2Ad7h0idySB0Cg7.oPPdBEjllr);
			}
			if (P517GRqyW.Value)
			{
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)284, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-58202035 ^ -58197943));
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)286, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--832233779 ^ 0x319AF127));
					RmE7DAD3XqITqHVXCf6.J5dDqyX3Cv(rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA);
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)287, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xFDCC567 ^ 0xFDCD54B));
					tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef);
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)288, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1133434849 ^ -1133430749));
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)289, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-111499785 ^ -111495749));
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)290, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-111499785 ^ -111495765));
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)291, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1826996771 ^ -1827000911));
				}
				if (M1GBaqd2RcbgPJ6QpwS.xM8dDC8RJr((KeyCode)292, M1GBaqd2RcbgPJ6QpwS.HAHdqGYA5i))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1573792578 ^ -1573796672));
				}
			}
		}

		private ConfigEntry<T> pl1ZRGDQl<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(TKL16pdYurbZa39IeFj.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(description, z58kVpdSnvv1ptnoFer.rIVdQJEGiN), synchronizedSetting ? cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1ACAA66 ^ 0x1ACBAC6) : cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1288876563 ^ 0x4CD2A283), TKL16pdYurbZa39IeFj.dIWdp7nDY1), Hc9b4JdCVwgeYhrf9OH.xM8dDC8RJr(description, Hc9b4JdCVwgeYhrf9OH.xXcdxFIFDO), KJNGt6d1iTA1IsS17QU.xM8dDC8RJr(description, KJNGt6d1iTA1IsS17QU.Y9kdsTOvOW));
			ConfigEntry<T> val2 = o0w7uUdNJyWKfR7Wbwa.xM8dDC8RJr(this, o0w7uUdNJyWKfR7Wbwa.meAdtKLcXM).Bind<T>(group, name, value, val);
			lBq2KhJUv.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			val2.SettingChanged += delegate
			{
				if (IsLocalInstance() || IsServerInstance())
				{
					QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(o0w7uUdNJyWKfR7Wbwa.xM8dDC8RJr(this, o0w7uUdNJyWKfR7Wbwa.meAdtKLcXM), QUxtOOdi9ZTQhPRfeQt.LIBu3qpDAS);
				}
			};
			return val2;
		}

		private ConfigEntry<T> VGbJJ1OnO<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return pl1ZRGDQl(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		private void BvC3ZVgZC()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.HMedWTxhAh), kFZqThMli);
			PRMSshdL0AdweX0JGBZ.xM8dDC8RJr(fileSystemWatcher, odl4KSdZ8, PRMSshdL0AdweX0JGBZ.zGIdj3mnpb);
			PRMSshdL0AdweX0JGBZ.xM8dDC8RJr(fileSystemWatcher, odl4KSdZ8, PRMSshdL0AdweX0JGBZ.Y2tdF5FJNA);
			ndGrxPdgtVIohD8xEoK.xM8dDC8RJr(fileSystemWatcher, odl4KSdZ8, ndGrxPdgtVIohD8xEoK.BeEdVoyDi6);
			lIN52Jdac24h7AiVTIC.xM8dDC8RJr(fileSystemWatcher, true, lIN52Jdac24h7AiVTIC.TOWd6EBSvv);
			LRW0rldRxtgnmERERWQ.xM8dDC8RJr(fileSystemWatcher, sJDvm2dweJVkEveXyI9.xM8dDC8RJr(sJDvm2dweJVkEveXyI9.os3d0YDMbd), LRW0rldRxtgnmERERWQ.aDQdMlkaYJ);
			lIN52Jdac24h7AiVTIC.xM8dDC8RJr(fileSystemWatcher, true, lIN52Jdac24h7AiVTIC.nD7dKsTyXP);
		}

		private void odl4KSdZ8(object sender, FileSystemEventArgs e)
		{
			string text = weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.HMedWTxhAh);
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			if (!xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(text, YojN9kdP7gBDyAFmGpM.xM8dDC8RJr(ref directorySeparatorChar, YojN9kdP7gBDyAFmGpM.oywdyRSiwc), kFZqThMli, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI), xxvKOqdkvwpXoasn4Ua.CFndnhjNjS) || (!IsLocalInstance() && !IsServerInstance()))
			{
				return;
			}
			try
			{
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(TKL16pdYurbZa39IeFj.xM8dDC8RJr(kFZqThMli, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x435F5309 ^ 0x435F43BD), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(o0w7uUdNJyWKfR7Wbwa.xM8dDC8RJr(this, o0w7uUdNJyWKfR7Wbwa.meAdtKLcXM), QUxtOOdi9ZTQhPRfeQt.L29d9VmTDT);
			}
			catch
			{
				tLDHRnDzaovuMvmKXEJ.Error(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xBC87536 ^ 0xBC865E6), kFZqThMli, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1491610595 ^ -1491614521), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
				tLDHRnDzaovuMvmKXEJ.Error(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x616F40D ^ 0x616E4E3));
			}
		}

		public void DeleteConfigFileContent()
		{
			if (!e9vHGRFq7)
			{
				return;
			}
			string text = weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.HMedWTxhAh);
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			string text2 = qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(text, YojN9kdP7gBDyAFmGpM.xM8dDC8RJr(ref directorySeparatorChar, YojN9kdP7gBDyAFmGpM.oywdyRSiwc), kFZqThMli, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI);
			try
			{
				if (xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(text2, xxvKOqdkvwpXoasn4Ua.CFndnhjNjS))
				{
					string text3 = EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(text2, EBVFkOdo6PFGs87KtPu.WJ4dzmRxIw);
					string[] array = QfeQViuDUsYTXBFqxeg.xM8dDC8RJr(text3, new string[1] { weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.kUluED6eM9) }, StringSplitOptions.None, QfeQViuDUsYTXBFqxeg.upZuYnHFlS);
					if (array.Length > 20)
					{
						text3 = K433C4upLXU8sYamuA1.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.kUluED6eM9), array.Take(20), K433C4upLXU8sYamuA1.EHjuOPw28o);
					}
					UeF7jOuhRLWesbYVJPd.xM8dDC8RJr(text2, text3, UeF7jOuhRLWesbYVJPd.ecpui5HBuU);
				}
			}
			catch (Exception)
			{
			}
		}

		private void fVQvBLDmb()
		{
		}

		public static bool IsLocalInstance()
		{
			if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef))
			{
				if (GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), GjPiZGuGKt3esLg2lg0.OoruTlUvE2))
				{
					return !GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), GjPiZGuGKt3esLg2lg0.i1duXFc2Xq);
				}
				return false;
			}
			return false;
		}

		public static bool IsClientInstance()
		{
			if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef))
			{
				if (!GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), GjPiZGuGKt3esLg2lg0.OoruTlUvE2))
				{
					return !GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), GjPiZGuGKt3esLg2lg0.i1duXFc2Xq);
				}
				return false;
			}
			return false;
		}

		public static bool IsServerInstance()
		{
			if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef))
			{
				if (GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), GjPiZGuGKt3esLg2lg0.OoruTlUvE2))
				{
					return GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), GjPiZGuGKt3esLg2lg0.i1duXFc2Xq);
				}
				return false;
			}
			return false;
		}

		public Mian()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			harmony = new Harmony(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x616F40D ^ 0x616F80F));
			lBq2KhJUv = new ConfigSync(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1491610595 ^ -1491609569))
			{
				DisplayName = cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1034721101 ^ -1034716737),
				CurrentVersion = cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x66F5DEF7 ^ 0x66F5CFEF),
				MinimumRequiredVersion = cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x53AA769E ^ 0x53AA6786)
			};
			((BaseUnityPlugin)this)..ctor();
		}

		static Mian()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			Vd6m941eB = true;
			e9vHGRFq7 = nd2fPluZmqwsunkPWEu.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(uIS04sudwwkC6acq6gt.xM8dDC8RJr(uIS04sudwwkC6acq6gt.wupuuYJkLm), z58kVpdSnvv1ptnoFer.imNucTyGa1), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1133434849 ^ -1133430473), StringComparison.OrdinalIgnoreCase, nd2fPluZmqwsunkPWEu.B9wuJ99lOI);
			kFZqThMli = cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1B444CBC ^ 0x1B445D86);
		}

		[CompilerGenerated]
		private void egT5MBVR8<T>(object sender, EventArgs args)
		{
			if (IsLocalInstance() || IsServerInstance())
			{
				QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(o0w7uUdNJyWKfR7Wbwa.xM8dDC8RJr(this, o0w7uUdNJyWKfR7Wbwa.meAdtKLcXM), QUxtOOdi9ZTQhPRfeQt.LIBu3qpDAS);
			}
		}
	}
}
namespace OdinsWatch.Patches
{
	[HarmonyPatch(typeof(ZRoutedRpc), "AddPeer")]
	public class AddPeer_Patch
	{
		[HarmonyPostfix]
		public static void ZRoutedRpc_AddPeer_Postfix()
		{
			if (Mian.IsClientInstance() && Mian.lpa1LHjix.Value)
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2062391414 ^ -2062387474));
				RmE7DAD3XqITqHVXCf6.J5dDqyX3Cv(rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA);
			}
		}

		public AddPeer_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch("OnSteamServersConnected")]
	[HarmonyPatch(typeof(ZSteamMatchmaking))]
	public class ZSteamMatchmaking_OnSteamServersConnected_Patch
	{
		public static bool Prefix(SteamServersConnected_t data)
		{
			tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615267440));
			return false;
		}

		public ZSteamMatchmaking_OnSteamServersConnected_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch("OnSteamServersDisconnected")]
	[HarmonyPatch(typeof(ZSteamMatchmaking))]
	public class ZSteamMatchmaking_OnSteamServersDisconnected_Patch
	{
		public static bool Prefix(SteamServersConnected_t data)
		{
			tLDHRnDzaovuMvmKXEJ.Error(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1433507106 ^ -1433502892));
			return false;
		}

		public ZSteamMatchmaking_OnSteamServersDisconnected_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch("OnSteamServersConnectFail")]
	[HarmonyPatch(typeof(ZSteamMatchmaking))]
	public class ZSteamMatchmaking_OnSteamServersConnectFail_Patch
	{
		public static bool Prefix(SteamServersConnected_t data)
		{
			tLDHRnDzaovuMvmKXEJ.Error(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994167792 ^ -994171470));
			return false;
		}

		public ZSteamMatchmaking_OnSteamServersConnectFail_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch("LoadMainSceneIfBackendSelected")]
	[HarmonyPatch(typeof(FejdStartup))]
	public class FejdStartup_LoadMainSceneIfBackendSelected_Patch
	{
		public static bool Prefix(FejdStartup __instance)
		{
			if (__instance.m_startingWorld || c4fEwPu456PfBOEDARk.xM8dDC8RJr(c4fEwPu456PfBOEDARk.CjwuvrW9xx))
			{
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7601BE71 ^ 0x7601AFC9));
				QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(__instance, QUxtOOdi9ZTQhPRfeQt.WQqu5Jvm7U);
				return false;
			}
			FejdStartup.retries++;
			if (FejdStartup.retries > 50)
			{
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1529015598 ^ -1529019628));
				ZNet.SetExternalError((ConnectionStatus)5);
				HRTR2Ad7h0idySB0Cg7.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D765934 ^ 0x3D7648C8), HRTR2Ad7h0idySB0Cg7.PMQubaJGUg);
				return false;
			}
			((MonoBehaviour)__instance).Invoke(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4915F790 ^ 0x4915E59A), 0.25f);
			tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2062391414 ^ -2062387776));
			return false;
		}

		public FejdStartup_LoadMainSceneIfBackendSelected_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch(typeof(ZPlayFabMatchmaking), "OnSessionUpdated")]
	[HarmonyPatch(typeof(ZPlayFabMatchmaking))]
	public class ZPlayFabMatchmaking_OnSessionUpdated_Patch
	{
		public static bool Prefix(State newState, ZPlayFabMatchmaking __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			__instance.m_state = newState;
			State state = __instance.m_state;
			switch (state - 1)
			{
			case 0:
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(ILnneIdmmDqT1UvTTqV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x74EA0EC8 ^ 0x74EA1CB0), __instance.m_serverData.serverName, weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.NToueLAx1S), ILnneIdmmDqT1UvTTqV.EgodHN9gTQ));
				__instance.m_retries = 100;
				QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(__instance, QUxtOOdi9ZTQhPRfeQt.iQ7uIQ11lG);
				return false;
			case 1:
				QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(__instance, QUxtOOdi9ZTQhPRfeQt.FW2ummkleA);
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(ILnneIdmmDqT1UvTTqV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2076552374 ^ -2076556832), weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.NToueLAx1S), __instance.m_serverData.serverName, ILnneIdmmDqT1UvTTqV.EgodHN9gTQ));
				return false;
			case 2:
			{
				FieldInfo fieldInfo = BBat2uuqZGB9I7N42Op.xM8dDC8RJr(ogGoU6uHZtBhNFcBghR.xM8dDC8RJr(typeof(ZPlayFabMatchmaking).TypeHandle, ogGoU6uHZtBhNFcBghR.tRDu2iscWG), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519162894), BBat2uuqZGB9I7N42Op.NawufrsMuL);
				if ((((object)fieldInfo != null) ? g4GPUbuABo2sxhGuD6t.xM8dDC8RJr(fieldInfo, null, g4GPUbuABo2sxhGuD6t.tkeurhhS8A) : null) is Action<string> action)
				{
					action(__instance.m_serverData.remotePlayerId);
				}
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(Gchx5qu8h5fV0g1ZD2Q.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1ACAA66 ^ 0x1ACB89E), __instance.m_serverData.serverName, weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.NToueLAx1S), __instance.m_serverData.numPlayers, Gchx5qu8h5fV0g1ZD2Q.QDDu7LgWiD));
				return false;
			}
			default:
				return true;
			}
		}

		public ZPlayFabMatchmaking_OnSessionUpdated_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch(typeof(ZPlayFabMatchmaking), "UpdateNumPlayers")]
	[HarmonyPatch(typeof(ZPlayFabMatchmaking))]
	public class ZPlayFabMatchmaking_UpdateNumPlayers_Patch
	{
		public static bool Prefix(ZPlayFabMatchmaking __instance, string info)
		{
			__instance.m_serverData.numPlayers = JhiCCwuBpRJYVymCbF7.xM8dDC8RJr(JhiCCwuBpRJYVymCbF7.LGquSlhj58);
			if (!__instance.m_serverData.isDedicatedServer)
			{
				PlayFabMatchmakingServerData serverData = __instance.m_serverData;
				serverData.numPlayers++;
			}
			tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(o4ouKmdesL12FB7Dr77.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1127543568 ^ 0x4334E02A), new object[4]
			{
				info,
				__instance.m_serverData.serverName,
				weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.NToueLAx1S),
				__instance.m_serverData.numPlayers
			}, o4ouKmdesL12FB7Dr77.ik4dIYEY9L));
			return false;
		}

		public ZPlayFabMatchmaking_UpdateNumPlayers_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class Disconnect_Patch
	{
		public static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(__instance, GjPiZGuGKt3esLg2lg0.OoruTlUvE2))
			{
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xBC87536 ^ 0xBC866B2));
				RmE7DAD3XqITqHVXCf6.sBpDxSY1CN.Remove(peer.m_rpc);
			}
		}
	}
	[HarmonyPatch(typeof(HitData), "GetAttacker")]
	public class GetAttacker_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(HitData __instance, ref Character __result)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_008c: Expected O, but got Unknown
			if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)__result, null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef))
			{
				try
				{
					FieldInfo fieldInfo = rmhFEguQ9NkEUwl4YYw.xM8dDC8RJr(ogGoU6uHZtBhNFcBghR.xM8dDC8RJr(typeof(Character).TypeHandle, ogGoU6uHZtBhNFcBghR.tRDu2iscWG), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1034721101 ^ -1034716389), BindingFlags.Instance | BindingFlags.NonPublic, rmhFEguQ9NkEUwl4YYw.Lu4uCPHyxE);
					if (CWqfuHuxDu7kERYGiGX.xM8dDC8RJr(fieldInfo, null, CWqfuHuxDu7kERYGiGX.bARu184k57))
					{
						ZNetView val = (ZNetView)g4GPUbuABo2sxhGuD6t.xM8dDC8RJr(fieldInfo, __result, g4GPUbuABo2sxhGuD6t.tkeurhhS8A);
						string text = cTLcuQuthAODuuIiDA0.xM8dDC8RJr(zrBZRCusquD6Yfp8d3h.xM8dDC8RJr((object)val, zrBZRCusquD6Yfp8d3h.Ef9uNbPvYA), ZDOVars.s_playerName, "", cTLcuQuthAODuuIiDA0.q3nuWAUqpd);
						if (GjPiZGuGKt3esLg2lg0.xM8dDC8RJr((object)val, GjPiZGuGKt3esLg2lg0.aGpuLA172Z) && text != null && hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(text, z58kVpdSnvv1ptnoFer.xM8dDC8RJr(Player.m_localPlayer, z58kVpdSnvv1ptnoFer.EwnujYW3Ee), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
						{
							FnEodbYQxlVy7Z4PsXd.Je8Y11K5hq(text);
							FnEodbYQxlVy7Z4PsXd.HSdYVH02xt(LVytBjuVvhxVFG8s5oJ.xM8dDC8RJr(__instance, LVytBjuVvhxVFG8s5oJ.grguaTP3ZN));
							FnEodbYQxlVy7Z4PsXd.VFFYwcs5Fw(LVytBjuVvhxVFG8s5oJ.xM8dDC8RJr(__instance, LVytBjuVvhxVFG8s5oJ.xfru6FGAD9));
							FnEodbYQxlVy7Z4PsXd.BN3YMaDans(LVytBjuVvhxVFG8s5oJ.xM8dDC8RJr(__instance, LVytBjuVvhxVFG8s5oJ.R5suwrDFZi));
						}
					}
				}
				catch (Exception ex)
				{
					tLDHRnDzaovuMvmKXEJ.Error(XkpvLRd5hUPPJ3RZwtV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-438241056 ^ -438244518), ex, XkpvLRd5hUPPJ3RZwtV.aUndbJKkxf));
				}
			}
			if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(FnEodbYQxlVy7Z4PsXd.S7gYxZUeGe(), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(Player.m_localPlayer, z58kVpdSnvv1ptnoFer.EwnujYW3Ee), hNXi1LuFBGI1BK6YVmw.ldcu0nBusq))
			{
				float num = LVytBjuVvhxVFG8s5oJ.xM8dDC8RJr(__instance, LVytBjuVvhxVFG8s5oJ.grguaTP3ZN);
				FnEodbYQxlVy7Z4PsXd.EBqYjN2j17(LVytBjuVvhxVFG8s5oJ.xM8dDC8RJr(Player.m_localPlayer, LVytBjuVvhxVFG8s5oJ.IdwuRQQr5V) - num);
			}
		}

		public GetAttacker_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
}
namespace honVbgDXWYgouMAd6hF
{
	[HarmonyPatch]
	internal static class qlGD7EDTTyyUxAIxJ1K
	{
		private static bool Op5DJIaStX;

		[HarmonyPatch(typeof(FejdStartup), "Start")]
		[HarmonyPriority(799)]
		[HarmonyPrefix]
		public static void fJPDdRsWAh()
		{
			Op5DJIaStX = true;
		}

		[HarmonyPatch(typeof(ZLog), "LogWarning")]
		[HarmonyPrefix]
		public static bool W6WDuoDnBf(object o)
		{
			if (!Op5DJIaStX)
			{
				if (o is string s)
				{
					return !iw4Dcohbe3(s);
				}
				return true;
			}
			return true;
		}

		private static bool iw4Dcohbe3(string s)
		{
			if (s != null)
			{
				switch (z3CFtkuM7utmBww9VWh.xM8dDC8RJr(s, z3CFtkuM7utmBww9VWh.tHxuKKsIs0))
				{
				case 57:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615267072), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 31:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1253936477 ^ -1253939457), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 32:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-601821950 ^ -601818724), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 35:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x39B5DC8B ^ 0x39B5C869), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 100:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1137296265 ^ -1137301157), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 109:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7CA90E20 ^ 0x7CA91BD8), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 98:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-216930971 ^ -216927309), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 83:
					if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1098409344 ^ -1098412770), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
					{
						break;
					}
					goto IL_01d9;
				case 112:
					{
						if (!hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(s, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1084993159 ^ -1084995279), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
						{
							break;
						}
						goto IL_01d9;
					}
					IL_01d9:
					return true;
				}
			}
			return false;
		}

		[HarmonyPatch(typeof(Logger), "InternalLogEvent", new Type[]
		{
			typeof(object),
			typeof(LogEventArgs)
		})]
		[HarmonyPrefix]
		public static bool BNuDZLH5Hf(object sender, LogEventArgs eventArgs)
		{
			if (!Op5DJIaStX)
			{
				if (eZ0mr4uPCl9R8i3OIs9.xM8dDC8RJr(eventArgs, eZ0mr4uPCl9R8i3OIs9.gVMuyiYl5b) is string s)
				{
					return !iw4Dcohbe3(s);
				}
				return true;
			}
			return true;
		}
	}
}
namespace OdinsWatch.Patches
{
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class OnNewConnection_Patch
	{
		public static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			RmE7DAD3XqITqHVXCf6.I15D7iOMVp(peer);
			if (!GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(__instance, GjPiZGuGKt3esLg2lg0.i1duXFc2Xq))
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1528336581 ^ -1528334825));
				ZPackage val = new ZPackage();
				sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(val, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-601821950 ^ -601818086), sE6Ex3ullynNDxDvsTn.O8vuUVLA8j);
				peer.m_rpc.Invoke(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1137296265 ^ -1137302217), new object[1] { val });
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_ClientHandshake")]
	public class RPC_ClientHandshake_Patch
	{
		public static bool Prefix(ZNet __instance, ZRpc rpc, bool needPassword, string serverPasswordSalt)
		{
			string value = Mian.fULrmZXoi.Value;
			if (xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(value, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm))
			{
				return true;
			}
			ZNet.m_serverPasswordSalt = serverPasswordSalt;
			if (needPassword)
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2076552374 ^ -2076554732));
				lIN52Jdac24h7AiVTIC.xM8dDC8RJr(G9UR9GunE0e1KSJAwKC.xM8dDC8RJr(__instance.m_connectingDialog, G9UR9GunE0e1KSJAwKC.NNgu98oDDG), false, lIN52Jdac24h7AiVTIC.MAGuoJBsyw);
				WQgf4Fuzyr3dMwi4Sar.xM8dDC8RJr(__instance, rpc, value, WQgf4Fuzyr3dMwi4Sar.La6cENbO2c);
				return false;
			}
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-497884973 ^ -497878611));
			return true;
		}

		public RPC_ClientHandshake_Patch()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public static class RPC_PeerInfo_Patch
	{
		public static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(__instance, GjPiZGuGKt3esLg2lg0.OoruTlUvE2) && !RmE7DAD3XqITqHVXCf6.sBpDxSY1CN.Contains(rpc))
			{
				tLDHRnDzaovuMvmKXEJ.IAmYperstW(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-85961350 ^ -85963538));
				rpc.Invoke(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1836494548 ^ -1836496744), new object[1] { 3 });
				return false;
			}
			return true;
		}
	}
}
namespace vCNxXkD4X2qrbrVgfc5
{
	internal class RmE7DAD3XqITqHVXCf6
	{
		private MonoBehaviour A18DBMndiC;

		private static Stopwatch sDrDSZIe88;

		private static string AuCDQHkUwX;

		private static int nrIDCol9dN;

		public static List<ZRpc> sBpDxSY1CN;

		public RmE7DAD3XqITqHVXCf6(MonoBehaviour MonoBehaviour)
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
			A18DBMndiC = MonoBehaviour;
		}

		private static void JM7DvDZ3uP(string msg)
		{
			((Character)Player.m_localPlayer).Message((MessageType)2, msg, 0, (Sprite)null);
		}

		public static void aJtD5G4d6t(string messageText)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			UserInfo val = new UserInfo
			{
				Name = cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--592664568 ^ 0x23534E3A),
				Gamertag = string.Empty,
				NetworkUserId = weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.FsNcDGvdW9)
			};
			ZRoutedRpc obj = I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1);
			if (obj != null)
			{
				kvvJSCcOsVW8a2Cv0fZ.xM8dDC8RJr(obj, ZRoutedRpc.Everybody, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1724940706 ^ -1724946542), new object[5]
				{
					xxi6yFcYeWZITCbwcpf.xM8dDC8RJr(xxi6yFcYeWZITCbwcpf.yMpcp7nsD9),
					2,
					val,
					messageText,
					weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.FsNcDGvdW9)
				}, kvvJSCcOsVW8a2Cv0fZ.wOCch4AJcj);
			}
		}

		public void UgSDbu15Wq()
		{
			if (I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1) != null)
			{
				I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1).Register<ZPackage>(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4395287 ^ 0x4394B61), (Action<long, ZPackage>)egADmKFApE);
				I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1).Register<ZPackage>(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1660133231 ^ -1660126581), (Action<long, ZPackage>)jCnD2GoafB);
				I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1).Register<ZPackage>(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x446F6176 ^ 0x446F7B38), (Action<long, ZPackage>)LfoDAp0yhk);
				I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1).Register<ZPackage>(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1034721101 ^ -1034718661), (Action<long, ZPackage>)nAdD8ZN2JF);
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x435F5309 ^ 0x435F49CB));
			}
			else
			{
				tLDHRnDzaovuMvmKXEJ.Error(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-133231150 ^ -133228794));
			}
		}

		internal static void ngsDew0aqB(string data)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (AuCDQHkUwX == null || hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(data, AuCDQHkUwX, hNXi1LuFBGI1BK6YVmw.ldcu0nBusq) || KtUtuYciDWH09A0GCOE.xM8dDC8RJr(sDrDSZIe88, KtUtuYciDWH09A0GCOE.d53cGbkQRR) >= nrIDCol9dN)
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-497884973 ^ -497878475), data, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				ZPackage val = new ZPackage();
				sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(val, data, sE6Ex3ullynNDxDvsTn.O8vuUVLA8j);
				long num = KtUtuYciDWH09A0GCOE.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1), KtUtuYciDWH09A0GCOE.BsmcTrJZiw);
				kvvJSCcOsVW8a2Cv0fZ.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1), num, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1127543568 ^ 0x4334EAF6), new object[1] { val }, kvvJSCcOsVW8a2Cv0fZ.Dh4cX78twK);
				AuCDQHkUwX = data;
				QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(sDrDSZIe88, QUxtOOdi9ZTQhPRfeQt.ta0cdthto8);
			}
		}

		internal static void t6VDI4QG6g(long sender, string data)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1491610595 ^ -1491611935), data, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			ZPackage val = new ZPackage();
			sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(val, data, sE6Ex3ullynNDxDvsTn.O8vuUVLA8j);
			kvvJSCcOsVW8a2Cv0fZ.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1), sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1810016084 ^ -1810021706), new object[1] { val }, kvvJSCcOsVW8a2Cv0fZ.Dh4cX78twK);
		}

		private void egADmKFApE(long sender, ZPackage pkg)
		{
			YdKtgndOWJLX6Bc7Ufd.xM8dDC8RJr(A18DBMndiC, MwTDHRoX0E(sender, pkg), YdKtgndOWJLX6Bc7Ufd.CZmcuYPvUa);
		}

		private IEnumerator MwTDHRoX0E(long sender, ZPackage pkg)
		{
			string text = z58kVpdSnvv1ptnoFer.xM8dDC8RJr(pkg, z58kVpdSnvv1ptnoFer.RdkccT6Zp6);
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1778664704 ^ -1778674726), text, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			string[] parts = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(text, new char[1] { '\n' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
			string playerName = fm6haqcjfo5Hy2tXCjZ.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), sender, fm6haqcjfo5Hy2tXCjZ.X7pcFAu5sC).m_playerName;
			if (parts.Length == 2 && A3BFGYYOWuGDVlWr0tv.nfDYGLYgfk())
			{
				string obj = parts[0];
				string text2 = parts[1];
				if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(obj, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-485863768 ^ -485857698), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-493992837 ^ -493982683), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4667001E ^ 0x4667291C), text2, YICegicgWYKxpYvNTRh.aMtcVqg4Dt), SLy5u1dT0UmS9JNX6t8.HsIcRUofTl);
					if (Mian.zCHCH4qs2.Value == 1)
					{
						t6VDI4QG6g(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1037472129 ^ 0x3DD68AC9));
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), playerName, sE6Ex3ullynNDxDvsTn.eTi44rFpH5);
					}
					if (Mian.zCHCH4qs2.Value == 2)
					{
						t6VDI4QG6g(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-562080393 ^ -562082241));
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), playerName, sE6Ex3ullynNDxDvsTn.gqm4vhiGgp);
					}
					_ = Mian.zCHCH4qs2.Value;
					if (Mian.oI2t7epwD.Value)
					{
						aJtD5G4d6t(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2076552374 ^ -2076542188), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363A8C28), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
					}
				}
				if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(obj, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x642C10F0 ^ 0x642C39D4), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1137296265 ^ -1137306583), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x53AA769E ^ 0x53AA5FAE), text2, YICegicgWYKxpYvNTRh.aMtcVqg4Dt), SLy5u1dT0UmS9JNX6t8.QStZZEOxDX);
					if (Mian.fIVNqJi4b.Value == 1)
					{
						t6VDI4QG6g(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1660133231 ^ -1660126273));
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), playerName, sE6Ex3ullynNDxDvsTn.eTi44rFpH5);
					}
					if (Mian.fIVNqJi4b.Value == 2)
					{
						t6VDI4QG6g(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1034721101 ^ -1034718307));
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), playerName, sE6Ex3ullynNDxDvsTn.gqm4vhiGgp);
					}
					_ = Mian.fIVNqJi4b.Value;
					if (Mian.oI2t7epwD.Value)
					{
						aJtD5G4d6t(YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-738700297 ^ -738690135), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x35DEBE67 ^ 0x35DE9757), text2, YICegicgWYKxpYvNTRh.aMtcVqg4Dt));
					}
				}
				yield return null;
			}
			if (parts.Length == 2 && !A3BFGYYOWuGDVlWr0tv.nfDYGLYgfk())
			{
				aJtD5G4d6t(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363A8DBC));
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1856477526 ^ -1856483816));
				yield return null;
			}
		}

		private void jCnD2GoafB(long sender, ZPackage pkg)
		{
			string text = z58kVpdSnvv1ptnoFer.xM8dDC8RJr(pkg, z58kVpdSnvv1ptnoFer.RdkccT6Zp6);
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xAC68384 ^ 0xAC69896), text, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			if (text != null)
			{
				if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1731728554 ^ 0x67380F84), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					JM7DvDZ3uP(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1B444CBC ^ 0x1B44578A));
				}
				else if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994167792 ^ -994169000), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					JM7DvDZ3uP(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5289DC43 ^ 0x5289C775));
					oA2CfTcZq2AKjUpFqDK.xM8dDC8RJr(oA2CfTcZq2AKjUpFqDK.DAKcJnSgQu);
				}
			}
		}

		internal static void J5dDqyX3Cv(Dictionary<string, string> hashDictionary)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			MemoryStream memoryStream = new MemoryStream();
			byte[] array;
			try
			{
				nru3M8c3HEjt1J79m4I.xM8dDC8RJr(new BinaryFormatter(), memoryStream, hashDictionary, nru3M8c3HEjt1J79m4I.HoQc4WMfoN);
				array = UJErTscvaZRNGOHfRcH.xM8dDC8RJr(memoryStream, UJErTscvaZRNGOHfRcH.yPtc5bSIQK);
			}
			finally
			{
				if (memoryStream != null)
				{
					QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(memoryStream, QUxtOOdi9ZTQhPRfeQt.N3RcbGSiqn);
				}
			}
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x498F0BFD ^ 0x498F10AD), K433C4upLXU8sYamuA1.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1E3F61D9 ^ 0x1E3F7AB1), hashDictionary.Select((KeyValuePair<string, string> kv) => qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(kv.Key, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4B182EE9 ^ 0x4B1806FF), kv.Value, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI)), K433C4upLXU8sYamuA1.EHjuOPw28o), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			ZPackage val = new ZPackage();
			p6P7mFceNfmLqo1QsR8.xM8dDC8RJr(val, array, p6P7mFceNfmLqo1QsR8.crqcInxi4e);
			long num = KtUtuYciDWH09A0GCOE.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1), KtUtuYciDWH09A0GCOE.BsmcTrJZiw);
			if (num != 0L)
			{
				kvvJSCcOsVW8a2Cv0fZ.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1), num, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-878854484 ^ -878861086), new object[1] { val }, kvvJSCcOsVW8a2Cv0fZ.Dh4cX78twK);
			}
		}

		internal static void sntDfMbPcn(long sender, string data)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-134741461 ^ -134735547), data, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			ZPackage val = new ZPackage();
			sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(val, data, sE6Ex3ullynNDxDvsTn.O8vuUVLA8j);
			kvvJSCcOsVW8a2Cv0fZ.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.xM8dDC8RJr(I6kXJFddt1so3jk7Hcv.k9yduXKeN1), sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5CE1FDAF ^ 0x5CE1E727), new object[1] { val }, kvvJSCcOsVW8a2Cv0fZ.Dh4cX78twK);
		}

		private void LfoDAp0yhk(long sender, ZPackage pkg)
		{
			YdKtgndOWJLX6Bc7Ufd.xM8dDC8RJr(A18DBMndiC, Sn9DrE0EFE(sender, pkg), YdKtgndOWJLX6Bc7Ufd.CZmcuYPvUa);
		}

		private IEnumerator Sn9DrE0EFE(long sender, ZPackage pkg)
		{
			byte[] binaryData = UJErTscvaZRNGOHfRcH.xM8dDC8RJr(pkg, UJErTscvaZRNGOHfRcH.vFlJsS4udL);
			MemoryStream memoryStream = new MemoryStream(binaryData);
			Dictionary<string, string> dictionary;
			try
			{
				dictionary = (Dictionary<string, string>)dkOWJi4JVEg7lYTiW3G.xM8dDC8RJr(new BinaryFormatter(), memoryStream, dkOWJi4JVEg7lYTiW3G.BcM43D6l8g);
			}
			finally
			{
				if (memoryStream != null)
				{
					QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(memoryStream, QUxtOOdi9ZTQhPRfeQt.N3RcbGSiqn);
				}
			}
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1627430108 ^ 0x6100B4C2), K433C4upLXU8sYamuA1.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--633333367 ^ 0x25BFFD1F), dictionary.Select((KeyValuePair<string, string> kv) => qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(kv.Key, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7629FEA ^ 0x762B7FC), kv.Value, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI)), K433C4upLXU8sYamuA1.EHjuOPw28o), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			if (binaryData != null && A3BFGYYOWuGDVlWr0tv.nfDYGLYgfk())
			{
				Dictionary<string, string> dictionary2 = rmqoQuD1dmgVsWx9GDh.T1jDVcTIkk(sender, Mian.V99xApmOW.Value, dictionary);
				Dictionary<string, string> dictionary3 = rmqoQuD1dmgVsWx9GDh.T1jDVcTIkk(sender, Mian.V99xApmOW.Value, rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA);
				string playerName = fm6haqcjfo5Hy2tXCjZ.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), sender, fm6haqcjfo5Hy2tXCjZ.X7pcFAu5sC).m_playerName;
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D968D34 ^ 0x3D96AA18), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-134710601 ^ -134720885), K433C4upLXU8sYamuA1.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x780C9EDA ^ 0x780C85B2), dictionary2.Select((KeyValuePair<string, string> kv) => qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(kv.Key, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363A8D2A), kv.Value, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI)), K433C4upLXU8sYamuA1.EHjuOPw28o), YICegicgWYKxpYvNTRh.aMtcVqg4Dt));
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615282004), K433C4upLXU8sYamuA1.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5B900590 ^ 0x5B901EF8), dictionary3.Select((KeyValuePair<string, string> kv) => qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(kv.Key, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x39B5DC8B ^ 0x39B5F49D), kv.Value, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI)), K433C4upLXU8sYamuA1.EHjuOPw28o), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				if (!rmqoQuD1dmgVsWx9GDh.qwBDgw4SkR(sender, dictionary2, dictionary3))
				{
					if (Mian.RhvsAyUM9.Value == 1)
					{
						t6VDI4QG6g(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-134741461 ^ -134735611));
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), playerName, sE6Ex3ullynNDxDvsTn.eTi44rFpH5);
					}
					if (Mian.RhvsAyUM9.Value == 2)
					{
						t6VDI4QG6g(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xAC60EB0 ^ 0xAC6159E));
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), playerName, sE6Ex3ullynNDxDvsTn.gqm4vhiGgp);
					}
					_ = Mian.RhvsAyUM9.Value;
					if (Mian.oI2t7epwD.Value)
					{
						aJtD5G4d6t(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x35C98940 ^ 0x35C9A11E), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1133434849 ^ -1133445007), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
					}
				}
				yield return null;
			}
			if (binaryData != null && !A3BFGYYOWuGDVlWr0tv.nfDYGLYgfk())
			{
				aJtD5G4d6t(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519173720));
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615282092));
				yield return null;
			}
		}

		private void nAdD8ZN2JF(long sender, ZPackage pkg)
		{
			string text = z58kVpdSnvv1ptnoFer.xM8dDC8RJr(pkg, z58kVpdSnvv1ptnoFer.RdkccT6Zp6);
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x498F0BFD ^ 0x498F1079), text, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			if (text != null)
			{
				if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994167792 ^ -994168912), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(text);
				}
				else if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1573792578 ^ -1573794018), hNXi1LuFBGI1BK6YVmw.ldcu0nBusq))
				{
					tLDHRnDzaovuMvmKXEJ.IAmYperstW(text);
				}
			}
		}

		public static void I15D7iOMVp(ZNetPeer peer)
		{
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3FA7AECA ^ 0x3FA7B566));
			peer.m_rpc.Register<ZPackage>(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-58202035 ^ -58199795), (Action<ZRpc, ZPackage>)ClientVersion);
			peer.m_rpc.Register<ZPackage>(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D968D34 ^ 0x3D9696F4), (Action<ZRpc, ZPackage>)CheckResult);
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1724940706 ^ -1724947068));
		}

		public static void ClientVersion(ZRpc rpc, ZPackage pkg)
		{
			string text = z58kVpdSnvv1ptnoFer.xM8dDC8RJr(pkg, z58kVpdSnvv1ptnoFer.RdkccT6Zp6);
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1724940706 ^ -1724947024), text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x758FEF6 ^ 0x758E2F6), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
			if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-134741461 ^ -134737101), hNXi1LuFBGI1BK6YVmw.ldcu0nBusq))
			{
				tLDHRnDzaovuMvmKXEJ.IAmYperstW(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1FA9AEA5 ^ 0x1FA9B285));
				rpc.Invoke(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1810016084 ^ -1810022120), new object[1] { 3 });
			}
			else
			{
				sBpDxSY1CN.Add(rpc);
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x6BB2BA6F ^ 0x6BB2A62B));
			}
		}

		public static void CheckResult(ZRpc rpc, ZPackage pkg)
		{
			string text = z58kVpdSnvv1ptnoFer.xM8dDC8RJr(pkg, z58kVpdSnvv1ptnoFer.RdkccT6Zp6);
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-868607152 ^ -868613954), text, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1504133155 ^ -1504140323), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
		}

		static RmE7DAD3XqITqHVXCf6()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			sDrDSZIe88 = new Stopwatch();
			AuCDQHkUwX = null;
			nrIDCol9dN = 5000;
			sBpDxSY1CN = new List<ZRpc>();
		}
	}
}
namespace mjoxDkDswu6MbTJhUpT
{
	internal class rmqoQuD1dmgVsWx9GDh
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass17_0
		{
			public rmqoQuD1dmgVsWx9GDh mfvOxuIuMa;

			public string CtrO1NEQPD;

			public <>c__DisplayClass17_0()
			{
				cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
				base..ctor();
			}

			internal void cgqOCjgO83()
			{
				string value = mfvOxuIuMa.mrYDMkUn3u(CtrO1NEQPD);
				Dictionary<string, string> uO5DPPDrCA = rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA;
				bool flag = false;
				try
				{
					SV6ocEcBUADFL4kFo3F.xM8dDC8RJr(uO5DPPDrCA, ref flag, SV6ocEcBUADFL4kFo3F.yQycS9gSIH);
					string key = mfvOxuIuMa.Xb1D0QOflp(FbBDkHyWSj, CtrO1NEQPD);
					if (rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA.ContainsKey(key))
					{
						rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA.Remove(key);
					}
					rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA.Add(key, value);
					mfvOxuIuMa.KH9D6M5jUB();
				}
				finally
				{
					if (flag)
					{
						SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(uO5DPPDrCA, SLy5u1dT0UmS9JNX6t8.SURcNfJ9lv);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_0
		{
			public string tEmON3XJyi;

			public <>c__DisplayClass19_0()
			{
				cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
				base..ctor();
			}

			internal bool zssOs1pqJl(string folder)
			{
				return VjMScKdrea0l2HoViGP.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(tEmON3XJyi, z58kVpdSnvv1ptnoFer.usJc9jNj6m), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(folder, z58kVpdSnvv1ptnoFer.usJc9jNj6m), VjMScKdrea0l2HoViGP.Khvd8E2hM0);
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <计算文件哈希值>d__17 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncVoidMethodBuilder <>t__builder;

			public rmqoQuD1dmgVsWx9GDh <>4__this;

			public string filePath;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				int num = <>1__state;
				rmqoQuD1dmgVsWx9GDh rmqoQuD1dmgVsWx9GDh2 = <>4__this;
				try
				{
					TaskAwaiter awaiter;
					if (num == 0)
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
						goto IL_00b4;
					}
					<>c__DisplayClass17_0 CS$<>8__locals0 = new <>c__DisplayClass17_0
					{
						mfvOxuIuMa = <>4__this,
						CtrO1NEQPD = filePath
					};
					if (rmqoQuD1dmgVsWx9GDh2.SGODwTCUkQ(CS$<>8__locals0.CtrO1NEQPD))
					{
						awaiter = Yrtthl4eI2Q9qDeSX06.xM8dDC8RJr(TD9kOf45g5Ic69tlOEl.xM8dDC8RJr(delegate
						{
							string value = CS$<>8__locals0.mfvOxuIuMa.mrYDMkUn3u(CS$<>8__locals0.CtrO1NEQPD);
							Dictionary<string, string> uO5DPPDrCA = rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA;
							bool flag = false;
							try
							{
								SV6ocEcBUADFL4kFo3F.xM8dDC8RJr(uO5DPPDrCA, ref flag, SV6ocEcBUADFL4kFo3F.yQycS9gSIH);
								string key = CS$<>8__locals0.mfvOxuIuMa.Xb1D0QOflp(FbBDkHyWSj, CS$<>8__locals0.CtrO1NEQPD);
								if (rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA.ContainsKey(key))
								{
									rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA.Remove(key);
								}
								rmqoQuD1dmgVsWx9GDh.uO5DPPDrCA.Add(key, value);
								CS$<>8__locals0.mfvOxuIuMa.KH9D6M5jUB();
							}
							finally
							{
								if (flag)
								{
									SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(uO5DPPDrCA, SLy5u1dT0UmS9JNX6t8.SURcNfJ9lv);
								}
							}
						}, TD9kOf45g5Ic69tlOEl.Tb04bnDQoL), Yrtthl4eI2Q9qDeSX06.m5p4IVPmHf);
						if (!sYK9Qh4mthsnjL1LUIv.xM8dDC8RJr(ref awaiter, sYK9Qh4mthsnjL1LUIv.n8U4HPZuu8))
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
							return;
						}
						goto IL_00b4;
					}
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7601BE71 ^ 0x76019747), CS$<>8__locals0.CtrO1NEQPD, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
					goto end_IL_000e;
					IL_00b4:
					dkU8H24231rFhvfafyB.xM8dDC8RJr(ref awaiter, dkU8H24231rFhvfafyB.CpI4qNmlng);
					end_IL_000e:;
				}
				catch (Exception ex)
				{
					<>1__state = -2;
					t3aQVX4f9ttG1aWTsUC.xM8dDC8RJr(ref <>t__builder, ex, t3aQVX4f9ttG1aWTsUC.A4u4Akemos);
					return;
				}
				<>1__state = -2;
				mbgmNN4rJ3vbi6CU1an.xM8dDC8RJr(ref <>t__builder, mbgmNN4rJ3vbi6CU1an.Uhi487GCxl);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				ivShdr47jWTKABO05qL.xM8dDC8RJr(ref <>t__builder, stateMachine, ivShdr47jWTKABO05qL.A0u4BIq4Ej);
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		private FileSystemWatcher qUmDKdp6sg;

		internal static Dictionary<string, string> uO5DPPDrCA;

		internal static bool i40DyY9mDt;

		internal static bool AfrDlnjZaS;

		internal static bool OhuDUCkdhZ;

		internal static string FbBDkHyWSj;

		private static string VDNDnkWZnm;

		private static string lWVD97yZpY;

		private static string BxDDoAjK8I;

		internal void ld3DNa11W5()
		{
			Mian.xbcg0k2IX.SettingChanged += UlLDtHfttj;
			Mian.ggSjtMgoT.SettingChanged += UlLDtHfttj;
			Mian.kSuFgQiaI.SettingChanged += UlLDtHfttj;
			Mian.EMRL1Mlri.SettingChanged += UlLDtHfttj;
			Mian.K7BW4a0vf.SettingChanged += UlLDtHfttj;
		}

		internal void UlLDtHfttj(object sender, EventArgs e)
		{
			if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef))
			{
				if (qUmDKdp6sg != null)
				{
					lIN52Jdac24h7AiVTIC.xM8dDC8RJr(qUmDKdp6sg, false, lIN52Jdac24h7AiVTIC.nD7dKsTyXP);
					QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(qUmDKdp6sg, QUxtOOdi9ZTQhPRfeQt.HlNcmFEY70);
					qUmDKdp6sg = null;
				}
				i40DyY9mDt = true;
				uO5DPPDrCA.Clear();
				MMYDWAsvJM();
				AfrDlnjZaS = true;
			}
		}

		internal void MMYDWAsvJM()
		{
			if (Mian.IsClientInstance())
			{
				if (!Dy7DjrKY8t())
				{
					FbBDkHyWSj = TKL16pdYurbZa39IeFj.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.WWbcHYml9J), iWNDRIG8O0(Mian.ggSjtMgoT.Value), TKL16pdYurbZa39IeFj.U82c2wwlTH);
				}
				else
				{
					FbBDkHyWSj = TKL16pdYurbZa39IeFj.xM8dDC8RJr(d4aDFbNeyU(), iWNDRIG8O0(Mian.ggSjtMgoT.Value), TKL16pdYurbZa39IeFj.U82c2wwlTH);
				}
			}
			else if (Mian.IsServerInstance() || Mian.IsLocalInstance())
			{
				if (!Dy7DjrKY8t())
				{
					FbBDkHyWSj = TKL16pdYurbZa39IeFj.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.WWbcHYml9J), iWNDRIG8O0(Mian.xbcg0k2IX.Value), TKL16pdYurbZa39IeFj.U82c2wwlTH);
				}
				else
				{
					FbBDkHyWSj = TKL16pdYurbZa39IeFj.xM8dDC8RJr(d4aDFbNeyU(), iWNDRIG8O0(Mian.xbcg0k2IX.Value), TKL16pdYurbZa39IeFj.U82c2wwlTH);
				}
			}
			VDNDnkWZnm = TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--592664568 ^ 0x23534B9C), xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(iWNDRIG8O0(Mian.kSuFgQiaI.Value), xxvKOqdkvwpXoasn4Ua.o4aukDGAPm) ? "" : TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1084993159 ^ -1084994293), iWNDRIG8O0(Mian.kSuFgQiaI.Value), TKL16pdYurbZa39IeFj.dIWdp7nDY1), TKL16pdYurbZa39IeFj.dIWdp7nDY1);
			lWVD97yZpY = TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7514E7A3 ^ 0x7514FBDB), xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(iWNDRIG8O0(Mian.EMRL1Mlri.Value), xxvKOqdkvwpXoasn4Ua.o4aukDGAPm) ? "" : TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615268716), iWNDRIG8O0(Mian.EMRL1Mlri.Value), TKL16pdYurbZa39IeFj.dIWdp7nDY1), TKL16pdYurbZa39IeFj.dIWdp7nDY1);
			BxDDoAjK8I = Mian.K7BW4a0vf.Value;
			if (!Mian.lpa1LHjix.Value)
			{
				return;
			}
			if (xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(FbBDkHyWSj, xxvKOqdkvwpXoasn4Ua.bdBcq1ibhC))
			{
				if (i40DyY9mDt)
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x77D4C9B ^ 0x77D5045), FbBDkHyWSj, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1343710716 ^ -1343715608), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
					string[] array = vHf5rEcfhiAUFHwZjcL.xM8dDC8RJr(FbBDkHyWSj, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1302396482 ^ -1302389578), SearchOption.AllDirectories, vHf5rEcfhiAUFHwZjcL.h0BcAFFoOy);
					foreach (string filePath in array)
					{
						rgSDasPO4P(filePath);
					}
					i40DyY9mDt = false;
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(FbBDkHyWSj, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1037472129 ^ 0x3DD68C8F), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				}
				if (qUmDKdp6sg != null)
				{
					lIN52Jdac24h7AiVTIC.xM8dDC8RJr(qUmDKdp6sg, false, lIN52Jdac24h7AiVTIC.nD7dKsTyXP);
					QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(qUmDKdp6sg, QUxtOOdi9ZTQhPRfeQt.HlNcmFEY70);
					qUmDKdp6sg = null;
				}
				UnFj5lcrM4RYHbfE1bp.xM8dDC8RJr(1000, UnFj5lcrM4RYHbfE1bp.akSc86gGvP);
				qUmDKdp6sg = new FileSystemWatcher(FbBDkHyWSj);
				lIN52Jdac24h7AiVTIC.xM8dDC8RJr(qUmDKdp6sg, true, lIN52Jdac24h7AiVTIC.TOWd6EBSvv);
				PRMSshdL0AdweX0JGBZ.xM8dDC8RJr(qUmDKdp6sg, S7bDLULh50, PRMSshdL0AdweX0JGBZ.Y2tdF5FJNA);
				PRMSshdL0AdweX0JGBZ.xM8dDC8RJr(qUmDKdp6sg, S7bDLULh50, PRMSshdL0AdweX0JGBZ.zGIdj3mnpb);
				PRMSshdL0AdweX0JGBZ.xM8dDC8RJr(qUmDKdp6sg, S7bDLULh50, PRMSshdL0AdweX0JGBZ.glVc7yikM6);
				ndGrxPdgtVIohD8xEoK.xM8dDC8RJr(qUmDKdp6sg, S7bDLULh50, ndGrxPdgtVIohD8xEoK.BeEdVoyDi6);
				LRW0rldRxtgnmERERWQ.xM8dDC8RJr(qUmDKdp6sg, sJDvm2dweJVkEveXyI9.xM8dDC8RJr(sJDvm2dweJVkEveXyI9.os3d0YDMbd), LRW0rldRxtgnmERERWQ.aDQdMlkaYJ);
				lIN52Jdac24h7AiVTIC.xM8dDC8RJr(qUmDKdp6sg, true, lIN52Jdac24h7AiVTIC.nD7dKsTyXP);
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-134741461 ^ -134734025), FbBDkHyWSj, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			}
			else
			{
				tLDHRnDzaovuMvmKXEJ.Error(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x35DEBE67 ^ 0x35DEA357), FbBDkHyWSj, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			}
		}

		private void S7bDLULh50(object sender, FileSystemEventArgs e)
		{
			Dictionary<string, string> dictionary = uO5DPPDrCA;
			bool flag = false;
			try
			{
				SV6ocEcBUADFL4kFo3F.xM8dDC8RJr(dictionary, ref flag, SV6ocEcBUADFL4kFo3F.yQycS9gSIH);
				string key = Xb1D0QOflp(FbBDkHyWSj, z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g));
				if (!xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g), xxvKOqdkvwpXoasn4Ua.CFndnhjNjS))
				{
					if (uO5DPPDrCA.ContainsKey(key))
					{
						uO5DPPDrCA.Remove(key);
						KH9D6M5jUB();
						tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-133231150 ^ -133230448), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615268438), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
						AfrDlnjZaS = true;
					}
				}
				else
				{
					if (!SGODwTCUkQ(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g)))
					{
						return;
					}
					if (FgN6jVcCDAVJhILIQBy.xM8dDC8RJr(e, FgN6jVcCDAVJhILIQBy.QWRcxrTFLH) == WatcherChangeTypes.Renamed)
					{
						if (uO5DPPDrCA.ContainsKey(key))
						{
							uO5DPPDrCA.Remove(key);
							rgSDasPO4P(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g));
							tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1919466676 ^ -1919459826), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x446F6176 ^ 0x446F7C1C), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
							AfrDlnjZaS = true;
						}
					}
					else if (FgN6jVcCDAVJhILIQBy.xM8dDC8RJr(e, FgN6jVcCDAVJhILIQBy.QWRcxrTFLH) == WatcherChangeTypes.Created || FgN6jVcCDAVJhILIQBy.xM8dDC8RJr(e, FgN6jVcCDAVJhILIQBy.QWRcxrTFLH) == WatcherChangeTypes.Changed)
					{
						rgSDasPO4P(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g));
						string text = FgN6jVcCDAVJhILIQBy.xM8dDC8RJr(e, FgN6jVcCDAVJhILIQBy.QWRcxrTFLH) switch
						{
							WatcherChangeTypes.Created => cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1253936477 ^ -1253937367), 
							WatcherChangeTypes.Changed => cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x36BA69E7 ^ 0x36BA7475), 
							_ => throw new ArgumentOutOfRangeException(), 
						};
						tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(jlBnnwc1sGCQVyOyKkL.xM8dDC8RJr(new string[5]
						{
							cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519160726),
							z58kVpdSnvv1ptnoFer.xM8dDC8RJr(e, z58kVpdSnvv1ptnoFer.IcycQkFB1g),
							cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994167792 ^ -994170486),
							text,
							cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x616F40D ^ 0x616E9A9)
						}, jlBnnwc1sGCQVyOyKkL.EPMcsaJJ60));
						AfrDlnjZaS = true;
					}
				}
			}
			finally
			{
				if (flag)
				{
					SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(dictionary, SLy5u1dT0UmS9JNX6t8.SURcNfJ9lv);
				}
			}
		}

		internal static bool Dy7DjrKY8t()
		{
			string[] array = spedxnctIPXiG87wsxH.xM8dDC8RJr(spedxnctIPXiG87wsxH.v5KcWEM4SE);
			for (int i = 0; i < array.Length; i++)
			{
				if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(array[i], cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1F759D9C ^ 0x1F758024), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					return true;
				}
			}
			return false;
		}

		internal static string d4aDFbNeyU()
		{
			string[] array = spedxnctIPXiG87wsxH.xM8dDC8RJr(spedxnctIPXiG87wsxH.v5KcWEM4SE);
			for (int i = 0; i < array.Length - 1; i++)
			{
				if (hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(array[i], cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363AB884), hNXi1LuFBGI1BK6YVmw.p0kug0VoD1))
				{
					return EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(array[i + 1], EBVFkOdo6PFGs87KtPu.vhacLIjfyb), EBVFkOdo6PFGs87KtPu.vhacLIjfyb), EBVFkOdo6PFGs87KtPu.vhacLIjfyb);
				}
			}
			return null;
		}

		internal static bool qwBDgw4SkR(long sender, Dictionary<string, string> clientHash, Dictionary<string, string> serverHash)
		{
			bool flag = true;
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(clientHash.Keys);
			HashSet<string> hashSet2 = new HashSet<string>(serverHash.Keys);
			string playerName = fm6haqcjfo5Hy2tXCjZ.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), sender, fm6haqcjfo5Hy2tXCjZ.X7pcFAu5sC).m_playerName;
			if (hashSet.Count != hashSet2.Count)
			{
				flag = false;
				list.AddRange(hashSet.Except(hashSet2));
				list.AddRange(hashSet2.Except(hashSet));
			}
			else
			{
				foreach (KeyValuePair<string, string> item in clientHash)
				{
					if (!hashSet2.Contains(item.Key) || hNXi1LuFBGI1BK6YVmw.xM8dDC8RJr(serverHash[item.Key], item.Value, hNXi1LuFBGI1BK6YVmw.ldcu0nBusq))
					{
						flag = false;
						list.Add(item.Key);
					}
				}
			}
			if (flag)
			{
				RmE7DAD3XqITqHVXCf6.sntDfMbPcn(sender, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x399BCC15 ^ 0x399BD7B5));
				tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1495448691 ^ -1495441837), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-994026848 ^ -994031800), qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
			}
			else
			{
				foreach (string item2 in list.Except(serverHash.Keys).ToList())
				{
					RmE7DAD3XqITqHVXCf6.sntDfMbPcn(sender, TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48DC695F ^ 0x48DC74A9), item2, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
					tLDHRnDzaovuMvmKXEJ.IAmYperstW(YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x53AA769E ^ 0x53AA6B40), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x758FEF6 ^ 0x758E300), item2, YICegicgWYKxpYvNTRh.aMtcVqg4Dt));
				}
				foreach (string item3 in list.Except(clientHash.Keys).ToList())
				{
					RmE7DAD3XqITqHVXCf6.sntDfMbPcn(sender, TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4915F790 ^ 0x4915E986), item3, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
					tLDHRnDzaovuMvmKXEJ.IAmYperstW(YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x50C420EF ^ 0x50C43D31), playerName, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x6BB2BA6F ^ 0x6BB2A479), item3, YICegicgWYKxpYvNTRh.aMtcVqg4Dt));
				}
			}
			return flag;
		}

		internal static Dictionary<string, string> T1jDVcTIkk(long sender, string regulation, Dictionary<string, string> filehash)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(filehash);
			if (xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(regulation, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm))
			{
				return dictionary;
			}
			string playerName = fm6haqcjfo5Hy2tXCjZ.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), sender, fm6haqcjfo5Hy2tXCjZ.X7pcFAu5sC).m_playerName;
			bool flag = VjMScKdrea0l2HoViGP.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(fm6haqcjfo5Hy2tXCjZ.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.xM8dDC8RJr(q55GAgdcCAYFUU0ZvsL.JFwdZpLgoK), sender, fm6haqcjfo5Hy2tXCjZ.X7pcFAu5sC).m_socket, z58kVpdSnvv1ptnoFer.wsXcauH8gp), VjMScKdrea0l2HoViGP.k9Gc64QL9r);
			string[] array = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(regulation, new char[1] { ';' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
			Dictionary<string, List<string>> dictionary2 = new Dictionary<string, List<string>>();
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string[] array3 = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(array2[i], new char[1] { ':' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
				if (array3.Length != 2)
				{
					SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48DC695F ^ 0x48DC7769), regulation, TKL16pdYurbZa39IeFj.dIWdp7nDY1), SLy5u1dT0UmS9JNX6t8.HsIcRUofTl);
					return dictionary;
				}
				string key = array3[0];
				string[] source = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(array3[1], new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
				dictionary2[key] = source.ToList();
			}
			if (dictionary2.ContainsKey(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-966540854 ^ -966533224)))
			{
				foreach (string item in dictionary2[cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x481D3E87 ^ 0x481D20D5)].Select((string rule) => MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(rule, new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59)[0]).ToList())
				{
					if (dictionary.ContainsKey(item))
					{
						dictionary.Remove(item);
					}
				}
			}
			if (dictionary2.ContainsKey(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5E52898C ^ 0x5E5297D0)) && flag)
			{
				foreach (string item2 in dictionary2[cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x5B900590 ^ 0x5B901BCC)].Select((string rule) => MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(rule, new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59)[0]).ToList())
				{
					if (dictionary.ContainsKey(item2))
					{
						dictionary.Remove(item2);
					}
				}
			}
			if (dictionary2.ContainsKey(playerName))
			{
				foreach (string item3 in dictionary2[playerName].Select((string rule) => MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(rule, new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59)[0]).ToList())
				{
					if (dictionary.ContainsKey(item3))
					{
						dictionary.Remove(item3);
					}
				}
			}
			return dictionary;
		}

		[AsyncStateMachine(typeof(<计算文件哈希值>d__17))]
		private void rgSDasPO4P(string filePath)
		{
			<计算文件哈希值>d__17 stateMachine = default(<计算文件哈希值>d__17);
			stateMachine.<>t__builder = tdM6AAcMwefOWJm25s0.xM8dDC8RJr(tdM6AAcMwefOWJm25s0.BIccKfoPuH);
			stateMachine.<>4__this = this;
			stateMachine.filePath = filePath;
			stateMachine.<>1__state = -1;
			stateMachine.<>t__builder.Start(ref stateMachine);
		}

		private void KH9D6M5jUB()
		{
			if (!Mian.P517GRqyW.Value)
			{
				return;
			}
			EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.s0wcPLIg4H), EBVFkOdo6PFGs87KtPu.vhacLIjfyb);
			string path = TKL16pdYurbZa39IeFj.xM8dDC8RJr(EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.xM8dDC8RJr(weFLyUdfrDWMSAwU09m.s0wcPLIg4H), EBVFkOdo6PFGs87KtPu.vhacLIjfyb), iWNDRIG8O0(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1504133155 ^ -1504140873)), TKL16pdYurbZa39IeFj.U82c2wwlTH);
			bool flag = false;
			try
			{
				SV6ocEcBUADFL4kFo3F.xM8dDC8RJr(this, ref flag, SV6ocEcBUADFL4kFo3F.yQycS9gSIH);
				StreamWriter streamWriter = new StreamWriter(path);
				try
				{
					foreach (KeyValuePair<string, string> item in uO5DPPDrCA)
					{
						sE6Ex3ullynNDxDvsTn.xM8dDC8RJr(streamWriter, qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(item.Key, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1627430108 ^ 0x610080AE), item.Value, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI), sE6Ex3ullynNDxDvsTn.qZWcy09MwC);
					}
				}
				finally
				{
					if (streamWriter != null)
					{
						QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(streamWriter, QUxtOOdi9ZTQhPRfeQt.N3RcbGSiqn);
					}
				}
			}
			finally
			{
				if (flag)
				{
					SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(this, SLy5u1dT0UmS9JNX6t8.SURcNfJ9lv);
				}
			}
		}

		private bool SGODwTCUkQ(string filePath)
		{
			<>c__DisplayClass19_0 CS$<>8__locals0 = new <>c__DisplayClass19_0();
			CS$<>8__locals0.tEmON3XJyi = filePath;
			string[] source = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(VDNDnkWZnm, new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
			string[] source2 = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(lWVD97yZpY, new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
			string[] source3 = MtmuHocwsBrpFKaxsiT.xM8dDC8RJr(BxDDoAjK8I, new char[1] { ',' }, MtmuHocwsBrpFKaxsiT.YeVc0w7t59);
			if (source.Any((string folder) => VjMScKdrea0l2HoViGP.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(CS$<>8__locals0.tEmON3XJyi, z58kVpdSnvv1ptnoFer.usJc9jNj6m), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(folder, z58kVpdSnvv1ptnoFer.usJc9jNj6m), VjMScKdrea0l2HoViGP.Khvd8E2hM0)))
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1810016084 ^ -1810020816), CS$<>8__locals0.tEmON3XJyi, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				return false;
			}
			if (source2.Contains(EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(CS$<>8__locals0.tEmON3XJyi, EBVFkOdo6PFGs87KtPu.qplclY92BM)))
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-86372877 ^ -86371489), CS$<>8__locals0.tEmON3XJyi, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				return false;
			}
			if (xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(BxDDoAjK8I, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm))
			{
				tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-990598604 ^ -990595954), CS$<>8__locals0.tEmON3XJyi, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
				return true;
			}
			int num;
			if (!xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(CS$<>8__locals0.tEmON3XJyi, EBVFkOdo6PFGs87KtPu.IdecUPmbUJ), xxvKOqdkvwpXoasn4Ua.o4aukDGAPm))
			{
				num = (source3.Contains(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(oECnFcck6hZpwT808ZY.xM8dDC8RJr(EBVFkOdo6PFGs87KtPu.xM8dDC8RJr(CS$<>8__locals0.tEmON3XJyi, EBVFkOdo6PFGs87KtPu.IdecUPmbUJ), new char[1] { '.' }, oECnFcck6hZpwT808ZY.lEMcntipQJ), z58kVpdSnvv1ptnoFer.usJc9jNj6m)) ? 1 : 0);
				if (num != 0)
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1810016084 ^ -1810020842), CS$<>8__locals0.tEmON3XJyi, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
					return (byte)num != 0;
				}
			}
			else
			{
				num = 0;
			}
			tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-280820206 ^ -280815422), CS$<>8__locals0.tEmON3XJyi, TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			return (byte)num != 0;
		}

		private string Xb1D0QOflp(string rootPath, string filePath)
		{
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			Uri uri = new Uri(TKL16pdYurbZa39IeFj.xM8dDC8RJr(rootPath, YojN9kdP7gBDyAFmGpM.xM8dDC8RJr(ref directorySeparatorChar, YojN9kdP7gBDyAFmGpM.oywdyRSiwc), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
			Uri uri2 = new Uri(filePath);
			return dieEUJZDWlT0M64b261.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(Yd3T3IcobL0UEhJgHjc.xM8dDC8RJr(uri, uri2, Yd3T3IcobL0UEhJgHjc.ajPczqh85M), z58kVpdSnvv1ptnoFer.M41ZE9EVCt), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1EC0B888 ^ 0x1EC0A66A), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519159872), dieEUJZDWlT0M64b261.pxiZYBO09m);
		}

		internal static string iWNDRIG8O0(string path)
		{
			return EGbNC0ZpIp2IjpCpf9H.xM8dDC8RJr(EGbNC0ZpIp2IjpCpf9H.xM8dDC8RJr(path, '\\', Path.DirectorySeparatorChar, EGbNC0ZpIp2IjpCpf9H.qI7ZOgoHQk), '/', Path.DirectorySeparatorChar, EGbNC0ZpIp2IjpCpf9H.qI7ZOgoHQk);
		}

		private string mrYDMkUn3u(string filePath)
		{
			MD5 mD = Gl5fJUZhVSAZMhaBV7D.xM8dDC8RJr(Gl5fJUZhVSAZMhaBV7D.I37ZikKkeV);
			try
			{
				FileStream fileStream = VarpaYZG8ORrw9EePvl.xM8dDC8RJr(filePath, VarpaYZG8ORrw9EePvl.m3ZZTJydHW);
				try
				{
					return z58kVpdSnvv1ptnoFer.xM8dDC8RJr(dieEUJZDWlT0M64b261.xM8dDC8RJr(KdE6nhZuKOhl7AUMHFS.xM8dDC8RJr(SKbGGvZXkVvvC8LO6nK.xM8dDC8RJr(mD, fileStream, SKbGGvZXkVvvC8LO6nK.dBXZdhFwPP), KdE6nhZuKOhl7AUMHFS.iPnZcI5nZN), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x36BA69E7 ^ 0x36BA7709), "", dieEUJZDWlT0M64b261.pxiZYBO09m), z58kVpdSnvv1ptnoFer.usJc9jNj6m);
				}
				finally
				{
					if (fileStream != null)
					{
						QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(fileStream, QUxtOOdi9ZTQhPRfeQt.N3RcbGSiqn);
					}
				}
			}
			finally
			{
				if (mD != null)
				{
					QUxtOOdi9ZTQhPRfeQt.xM8dDC8RJr(mD, QUxtOOdi9ZTQhPRfeQt.N3RcbGSiqn);
				}
			}
		}

		public rmqoQuD1dmgVsWx9GDh()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			base..ctor();
		}

		static rmqoQuD1dmgVsWx9GDh()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			uO5DPPDrCA = new Dictionary<string, string>();
			i40DyY9mDt = true;
			AfrDlnjZaS = false;
			OhuDUCkdhZ = true;
		}
	}
}
namespace Ibf5epYEXNAvuXRyEnK
{
	internal static class tLDHRnDzaovuMvmKXEJ
	{
		public static void wfpYDfTDk2(string message)
		{
			if (Mian.P517GRqyW.Value)
			{
				SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x399BCC15 ^ 0x399BD2E1), message, TKL16pdYurbZa39IeFj.dIWdp7nDY1), SLy5u1dT0UmS9JNX6t8.WhQdXrKxUE);
			}
		}

		public static void RLxYYmbW3p(string message)
		{
			SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1084993159 ^ -1084993933), message, TKL16pdYurbZa39IeFj.dIWdp7nDY1), SLy5u1dT0UmS9JNX6t8.WhQdXrKxUE);
		}

		public static void IAmYperstW(string message)
		{
			SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-2076552374 ^ -2076554134), message, TKL16pdYurbZa39IeFj.dIWdp7nDY1), SLy5u1dT0UmS9JNX6t8.QStZZEOxDX);
		}

		public static void Error(string message)
		{
			SLy5u1dT0UmS9JNX6t8.xM8dDC8RJr(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0xBC87536 ^ 0xBC86A00), message, TKL16pdYurbZa39IeFj.dIWdp7nDY1), SLy5u1dT0UmS9JNX6t8.HsIcRUofTl);
		}
	}
}
namespace DW4EXhYhIbucMIqmBND
{
	internal class A3BFGYYOWuGDVlWr0tv : MonoBehaviour
	{
		private static bool DrvYXcfOAf;

		private static bool drdYdc9xpO;

		internal static bool QxHYubEkew;

		internal static bool hZ5YcTres9;

		internal static int zFvYZlWOE1;

		internal static bool lsXYJr2NKy;

		internal static DateTime ndgY33VK5a;

		internal static bool Lp0Yi6Bbw5(int vipLevel)
		{
			switch (vipLevel)
			{
			case 0:
			{
				TimeSpan timeSpan = mlYE78Z4aglL0w2rY2J.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.OUxZ3ItkdE), ndgY33VK5a, mlYE78Z4aglL0w2rY2J.HmKZvcVuPu);
				return NG9oPgZ5xtXp8MRKqF5.xM8dDC8RJr(ref timeSpan, NG9oPgZ5xtXp8MRKqF5.i76Zbbd6p8) <= 0.5;
			}
			case 1:
			{
				TimeSpan timeSpan = mlYE78Z4aglL0w2rY2J.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.OUxZ3ItkdE), ndgY33VK5a, mlYE78Z4aglL0w2rY2J.HmKZvcVuPu);
				return NG9oPgZ5xtXp8MRKqF5.xM8dDC8RJr(ref timeSpan, NG9oPgZ5xtXp8MRKqF5.TNcZeTLjay) <= 3.0;
			}
			case 2:
				return true;
			default:
				return false;
			}
		}

		internal static bool nfDYGLYgfk()
		{
			if (!lsXYJr2NKy)
			{
				TimeSpan timeSpan = mlYE78Z4aglL0w2rY2J.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.OUxZ3ItkdE), ndgY33VK5a, mlYE78Z4aglL0w2rY2J.HmKZvcVuPu);
				return NG9oPgZ5xtXp8MRKqF5.xM8dDC8RJr(ref timeSpan, NG9oPgZ5xtXp8MRKqF5.TNcZeTLjay) <= 1.0;
			}
			if (lsXYJr2NKy)
			{
				if (zFvYZlWOE1 == 0)
				{
					TimeSpan timeSpan = mlYE78Z4aglL0w2rY2J.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.OUxZ3ItkdE), ndgY33VK5a, mlYE78Z4aglL0w2rY2J.HmKZvcVuPu);
					return NG9oPgZ5xtXp8MRKqF5.xM8dDC8RJr(ref timeSpan, NG9oPgZ5xtXp8MRKqF5.TNcZeTLjay) <= 3.0;
				}
				if (zFvYZlWOE1 == 1)
				{
					TimeSpan timeSpan = mlYE78Z4aglL0w2rY2J.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.OUxZ3ItkdE), ndgY33VK5a, mlYE78Z4aglL0w2rY2J.HmKZvcVuPu);
					return NG9oPgZ5xtXp8MRKqF5.xM8dDC8RJr(ref timeSpan, NG9oPgZ5xtXp8MRKqF5.TNcZeTLjay) <= 15.0;
				}
				if (zFvYZlWOE1 == 2)
				{
					return true;
				}
			}
			return false;
		}

		public static IEnumerator sv4YTO3nAA()
		{
			while (true)
			{
				if (Mian.IsLocalInstance() || Mian.IsServerInstance())
				{
					if (!xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(Mian.hJhBQTE0O.Value, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm) && !xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(Mian.NeLScyAii.Value, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm))
					{
						string text = YICegicgWYKxpYvNTRh.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7629FEA ^ 0x762B6AC), Mian.hJhBQTE0O.Value, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D765934 ^ 0x3D7670D2), Mian.NeLScyAii.Value, YICegicgWYKxpYvNTRh.aMtcVqg4Dt);
						UnityWebRequest www = yv2MfI4SOtDkEcoA1HY.xM8dDC8RJr(text, yv2MfI4SOtDkEcoA1HY.Exn4Q9opUZ);
						IxhLr44CMffyxSKJsGL.xM8dDC8RJr(www, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-85961350 ^ -85950608), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-779247954 ^ -779242356), IxhLr44CMffyxSKJsGL.awn4x6tjDV);
						IxhLr44CMffyxSKJsGL.xM8dDC8RJr(www, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-458499248 ^ -458493590), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x7CA90E20 ^ 0x7CA92476), IxhLr44CMffyxSKJsGL.awn4x6tjDV);
						yield return iDvbel41JOFJOQAmZgt.xM8dDC8RJr(www, iDvbel41JOFJOQAmZgt.Kan4sqdvgF);
						if ((int)www.result == 2 || (int)www.result == 3)
						{
							tLDHRnDzaovuMvmKXEJ.Error(TKL16pdYurbZa39IeFj.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4667001E ^ 0x46672A64), z58kVpdSnvv1ptnoFer.xM8dDC8RJr(www, z58kVpdSnvv1ptnoFer.hmU4NttrAV), TKL16pdYurbZa39IeFj.dIWdp7nDY1));
							hZ5YcTres9 = true;
							yield return (object)new WaitForSeconds(60f);
						}
						else
						{
							string text2 = aJ0Q2q4g47AjMcijFBO.xM8dDC8RJr(MHLCPE4t5AS7iYgm5jb.xM8dDC8RJr(MHLCPE4t5AS7iYgm5jb.uaF4WhqirU), UJErTscvaZRNGOHfRcH.xM8dDC8RJr(NqmvXv4LwrATcqE3TjF.xM8dDC8RJr(www, NqmvXv4LwrATcqE3TjF.Eev4jVGC9t), UJErTscvaZRNGOHfRcH.VTG4F597Nn), aJ0Q2q4g47AjMcijFBO.gQC4V94S13);
							Match match = bdNsHN4atY51ZsU55e3.xM8dDC8RJr(text2, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-621329454 ^ -621319870), bdNsHN4atY51ZsU55e3.vfT46Ban5G);
							Match match2 = bdNsHN4atY51ZsU55e3.xM8dDC8RJr(text2, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x37A456D5 ^ 0x37A47C6F), bdNsHN4atY51ZsU55e3.vfT46Ban5G);
							if (GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(match, GjPiZGuGKt3esLg2lg0.zhh4wC2qLE) && GjPiZGuGKt3esLg2lg0.xM8dDC8RJr(match2, GjPiZGuGKt3esLg2lg0.zhh4wC2qLE))
							{
								zFvYZlWOE1 = KiLX6d3UVd2E0JGmPak.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(p9rJOr4Mc0KuNv7DVse.xM8dDC8RJr(OaZuXi40bQXL6j61W4e.xM8dDC8RJr(match, OaZuXi40bQXL6j61W4e.Qh14RNETDA), 1, p9rJOr4Mc0KuNv7DVse.nQL4KvQsGd), z58kVpdSnvv1ptnoFer.brJ4PHCQ4K), KiLX6d3UVd2E0JGmPak.hd94yDhs1J);
								lsXYJr2NKy = xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(p9rJOr4Mc0KuNv7DVse.xM8dDC8RJr(OaZuXi40bQXL6j61W4e.xM8dDC8RJr(match2, OaZuXi40bQXL6j61W4e.Qh14RNETDA), 1, p9rJOr4Mc0KuNv7DVse.nQL4KvQsGd), z58kVpdSnvv1ptnoFer.brJ4PHCQ4K), xxvKOqdkvwpXoasn4Ua.DNu4lAlt1F);
								string text3 = ((zFvYZlWOE1 == 1) ? cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-58202035 ^ -58211495) : ((zFvYZlWOE1 == 2) ? cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1288876563 ^ 0x4CD2991B) : cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4F0522BC ^ 0x4F050840)));
								tLDHRnDzaovuMvmKXEJ.RLxYYmbW3p(qjOK8YdlmJB3xuQqbJ3.xM8dDC8RJr(lsXYJr2NKy ? cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363A8E0C) : cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x4667001E ^ 0x46672B3E), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x1FA9AEA5 ^ 0x1FA985E5), text3, qjOK8YdlmJB3xuQqbJ3.SDxdUYIWSI));
								if (lsXYJr2NKy)
								{
									QxHYubEkew = true;
								}
							}
							else
							{
								tLDHRnDzaovuMvmKXEJ.Error(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-562080393 ^ -562069953));
								hZ5YcTres9 = true;
							}
							if (lsXYJr2NKy)
							{
								yield return (object)new WaitForSeconds(21600f);
							}
						}
						drdYdc9xpO = false;
					}
					else if ((xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(Mian.hJhBQTE0O.Value, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm) || xxvKOqdkvwpXoasn4Ua.xM8dDC8RJr(Mian.NeLScyAii.Value, xxvKOqdkvwpXoasn4Ua.o4aukDGAPm)) && !drdYdc9xpO)
					{
						tLDHRnDzaovuMvmKXEJ.IAmYperstW(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-520423485 ^ -520430439));
						hZ5YcTres9 = true;
						drdYdc9xpO = true;
					}
				}
				yield return null;
			}
		}

		public A3BFGYYOWuGDVlWr0tv()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			((MonoBehaviour)this)..ctor();
		}

		static A3BFGYYOWuGDVlWr0tv()
		{
			cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
			DrvYXcfOAf = false;
			drdYdc9xpO = false;
			QxHYubEkew = false;
			hZ5YcTres9 = false;
			ndgY33VK5a = lDe9FnZJNtkC04RUcl2.xM8dDC8RJr(lDe9FnZJNtkC04RUcl2.OUxZ3ItkdE);
		}
	}
}
namespace JoXnjgYv0df4W3xDKmk
{
	internal class vraQVXY4ORnlIsr1SmW
	{
		private delegate bool pjqZhwOtETBMObT6CTy(IntPtr hWnd, IntPtr lParam);

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public List<string> p1jOL0sTtt;

			public <>c__DisplayClass5_0()
			{
				cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
				base..ctor();
			}

			internal void ik2OWx3NTN()
			{
				using List<string>.Enumerator enumerator = p1jOL0sTtt.GetEnumerator();
				while (enumerator.MoveNext())
				{
					YvKY57bC0W(new <>c__DisplayClass5_1
					{
						IYdOF1HicI = enumerator.Current
					}.MrSOj8G0ju, IntPtr.Zero);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_1
		{
			public string IYdOF1HicI;

			public <>c__DisplayClass5_1()
			{
				cmBCZsG35yEuM65p2P4.YcYG1ulmgM();
				base..ctor();
			}

			internal bool MrSOj8G0ju(IntPtr hWnd, IntPtr lParam)
			{
				StringBuilder stringBuilder = new StringBuilder(256);
				Da9YbZZCPw(hWnd, stringBuilder, z3CFtkuM7utmBww9VWh.xM8dDC8RJr(stringBuilder, z3CFtkuM7utmBww9VWh.j7n4Uxuolg));
				if (ex4YmFgfoh(z58kVpdSnvv1ptnoFer.xM8dDC8RJr(stringBuilder, z58kVpdSnvv1ptnoFer.M41ZE9EVCt), IYdOF1HicI))
				{
					tLDHRnDzaovuMvmKXEJ.wfpYDfTDk2(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x36BA69E7 ^ 0x36BA4229));
					if (tOHGKudJUA2Pc12NJfr.xM8dDC8RJr((Object)(object)Player.m_localPlayer, null, tOHGKudJUA2Pc12NJfr.QeDd3OUvef) && Mian.IsClientInstance())
					{
						RmE7DAD3XqITqHVXCf6.ngsDew0aqB(XkpvLRd5hUPPJ3RZwtV.xM8dDC8RJr(cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x481D3E87 ^ 0x481D1565), stringBuilder, XkpvLRd5hUPPJ3RZwtV.aUndbJKkxf));
					}
					N0YY2dTBSp = true;
				}
				return true;
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <EnumerateWindowsAsync>d__5 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public List<string> windowTitlesToScan;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = Yrtthl4eI2Q9qDeSX06.xM8dDC8RJr(TD9kOf45g5Ic69tlOEl.xM8dDC8RJr(new <>c__DisplayClass5_0
						{
							p1jOL0sTtt = windowTitlesToScan
						}.ik2OWx3NTN, TD9kOf45g5Ic69tlOEl.Tb04bnDQoL), Yrtthl4eI2Q9qDeSX06.m5p4IVPmHf);
						if (!sYK9Qh4mthsnjL1LUIv.xM8dDC8RJr(ref awaiter, sYK9Qh4mthsnjL1LUIv.n8U4HPZuu8))
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					dkU8H24231rFhvfafyB.xM8dDC8RJr(ref awaiter, dkU8H24231rFhvfafyB.CpI4qNmlng);
				}
				catch (Exception ex)
				{
					<>1__state = -2;
					vq8PoT4kQ1yQ2hp9IUb.xM8dDC8RJr(ref <>t__builder, ex, vq8PoT4kQ1yQ2hp9IUb.mG14nLyRhg);
					return;
				}
				<>1__state = -2;
				yHskY849WyIGpndwX6A.xM8dDC8RJr(ref <>t__builder, yHskY849WyIGpndwX6A.w3Y4oD2cCw);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				d3qICy4ziLS8loI0dFc.xM8dDC8RJr(ref <>t__builder, stateMachine, d3qICy4ziLS8loI0dFc.pmivEV8gDK);
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		private static bool N0YY2dTBSp;

		[DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "EnumWindows", SetLastError = true)]
		private static extern bool YvKY57bC0W(pjqZhwOtETBMObT6CTy enumProc, IntPtr lParam);

		[DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "GetWindowText", SetLastError = true)]
		private static extern int Da9YbZZCPw(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

		public static IEnumerator OFpYebLP6S()
		{
			List<string> windowTitlesToScan = new List<string>
			{
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-58607713 ^ -58614679),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x8BBB05 ^ 0x8B9711),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1615271706 ^ -1615280946),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1660133231 ^ -1660138329),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x61B6F0BB ^ 0x61B6DCEF),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x39B5DC8B ^ 0x39B5F0E9),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(--1127543568 ^ 0x4334DF68),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1243848504 ^ -1243853732),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x363AA53C ^ 0x363A89F6),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1433507106 ^ -1433516538),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-280820206 ^ -280810758),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3192288E ^ 0x31920470),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x6F08CAAA ^ 0x6F08E7BA),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-947559740 ^ -947564562),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1137296265 ^ -1137307313),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x48DC695F ^ 0x48DC4419),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-519167704 ^ -519172998),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-507095511 ^ -507086015),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x39B5DC8B ^ 0x39B5F101),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-520423485 ^ -520431007),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1219259449 ^ -1219248523),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x3D765934 ^ 0x3D7674FA),
				cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x714D8A19 ^ 0x714DA7C5)
			};
			while (true)
			{
				if (Mian.IsClientInstance() && Mian.Mg1QbItQS.Value)
				{
					yield return QDIYIjnkm7(windowTitlesToScan);
					_ = N0YY2dTBSp;
				}
				yield return (object)new WaitForSeconds(5f);
			}
		}

		[AsyncStateMachine(typeof(<EnumerateWindowsAsync>d__5))]
		private static Task QDIYIjnkm7(List<string> windowTitlesToScan)
		{
			<EnumerateWindowsAsync>d__5 stateMachine = default(<EnumerateWindowsAsync>d__5);
			stateMachine.<>t__builder = iSFUBmZI5omg54X4FTD.xM8dDC8RJr(iSFUBmZI5omg54X4FTD.W1NZmlJ8Jh);
			stateMachine.windowTitlesToScan = windowTitlesToScan;
			stateMachine.<>1__state = -1;
			stateMachine.<>t__builder.Start(ref stateMachine);
			return wEaihOZHVMFuSYvTsa2.xM8dDC8RJr(ref stateMachine.<>t__builder, wEaihOZHVMFuSYvTsa2.oGuZ2mFKUZ);
		}

		private static bool ex4YmFgfoh(string title, string pattern)
		{
			pattern = dieEUJZDWlT0M64b261.xM8dDC8RJr(pattern, cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(-1098409344 ^ -1098414200), cmBCZsG35yEuM65p2P4.GL9GN2Dvoa(0x292D0CB0 ^ 0x292D13FC), dieEUJZDWlT0M64b261.pxiZYBO09m);
			return hNXi1LuFBGI1BK