using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Threading;
using System.Threading.Tasks;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("Daniel Grunwald, Omer Mor, Alex Davies, jnm2")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2012–2018 Daniel Grunwald, Omer Mor, Alex Davies, Joseph Musser")]
[assembly: AssemblyDescription("C# 5 async/await support for .NET Framework pre-4.5\r\nThis package is now unified to include all functionality from AsyncBridge.Net35 and AsyncBridge.Portable.")]
[assembly: AssemblyFileVersion("0.3.1.0")]
[assembly: AssemblyInformationalVersion("0.3.1")]
[assembly: AssemblyProduct("AsyncBridge")]
[assembly: AssemblyTitle("C# 5 async/await support for .NET Framework pre-4.5")]
[assembly: AssemblyVersion("0.3.1.0")]
public static class AsyncCompatLibExtensions
{
	public static TaskAwaiter GetAwaiter(this Task task)
	{
		if (task == null)
		{
			throw new ArgumentNullException("task");
		}
		return new TaskAwaiter(task);
	}

	public static TaskAwaiter<TResult> GetAwaiter<TResult>(this Task<TResult> task)
	{
		if (task == null)
		{
			throw new ArgumentNullException("task");
		}
		return new TaskAwaiter<TResult>(task);
	}

	public static ConfiguredTaskAwaitable<TResult> ConfigureAwait<TResult>(this Task<TResult> task, bool continueOnCapturedContext)
	{
		if (task == null)
		{
			throw new ArgumentNullException("task");
		}
		return new ConfiguredTaskAwaitable<TResult>(task, continueOnCapturedContext);
	}

	public static ConfiguredTaskAwaitable ConfigureAwait(this Task task, bool continueOnCapturedContext)
	{
		if (task == null)
		{
			throw new ArgumentNullException("task");
		}
		return new ConfiguredTaskAwaitable(task, continueOnCapturedContext);
	}
}
namespace System.Threading
{
	internal static class ExecutionContextEx
	{
		public static void Dispose(this ExecutionContext context)
		{
		}
	}
}
namespace System.Threading.Tasks
{
	public static class TaskEx
	{
		private static Task s_preCompletedTask;

		private static Task s_preCanceledTask;

		private const string ArgumentOutOfRange_TimeoutNonNegativeOrMinusOne = "The timeout must be non-negative or -1, and it must be less than or equal to Int32.MaxValue.";

		static TaskEx()
		{
			s_preCompletedTask = (Task)(object)FromResult(result: false);
			s_preCanceledTask = ((Func<Task>)delegate
			{
				TaskCompletionSource<bool> obj = new TaskCompletionSource<bool>();
				obj.TrySetCanceled();
				return (Task)(object)obj.Task;
			})();
		}

		public static Task Run(Action action)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Run(action, CancellationToken.None);
		}

		public static Task Run(Action action, CancellationToken cancellationToken)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Task.Factory.StartNew(action, cancellationToken, (TaskCreationOptions)0, TaskScheduler.Default);
		}

		public static Task<TResult> Run<TResult>(Func<TResult> function)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Run(function, CancellationToken.None);
		}

		public static Task<TResult> Run<TResult>(Func<TResult> function, CancellationToken cancellationToken)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Task.Factory.StartNew<TResult>(function, cancellationToken, (TaskCreationOptions)0, TaskScheduler.Default);
		}

		public static Task Run(Func<Task> function)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Run(function, CancellationToken.None);
		}

		public static Task Run(Func<Task> function, CancellationToken cancellationToken)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return TaskExtensions.Unwrap(TaskEx.Run<Task>(function, cancellationToken));
		}

		public static Task<TResult> Run<TResult>(Func<Task<TResult>> function)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Run(function, CancellationToken.None);
		}

		public static Task<TResult> Run<TResult>(Func<Task<TResult>> function, CancellationToken cancellationToken)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return TaskExtensions.Unwrap<TResult>(TaskEx.Run<Task<TResult>>(function, cancellationToken));
		}

		public static Task Delay(int dueTime)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Delay(dueTime, CancellationToken.None);
		}

		public static Task Delay(TimeSpan dueTime)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Delay(dueTime, CancellationToken.None);
		}

		public static Task Delay(TimeSpan dueTime, CancellationToken cancellationToken)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			long num = (long)dueTime.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("dueTime", "The timeout must be non-negative or -1, and it must be less than or equal to Int32.MaxValue.");
			}
			return Delay((int)num, cancellationToken);
		}

		public static Task Delay(int dueTime, CancellationToken cancellationToken)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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)
			if (dueTime < -1)
			{
				throw new ArgumentOutOfRangeException("dueTime", "The timeout must be non-negative or -1, and it must be less than or equal to Int32.MaxValue.");
			}
			if (((CancellationToken)(ref cancellationToken)).IsCancellationRequested)
			{
				return s_preCanceledTask;
			}
			if (dueTime == 0)
			{
				return s_preCompletedTask;
			}
			TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
			CancellationTokenRegistration ctr = default(CancellationTokenRegistration);
			Timer timer = null;
			timer = new Timer(delegate
			{
				((CancellationTokenRegistration)(ref ctr)).Dispose();
				timer.Dispose();
				tcs.TrySetResult(true);
			}, null, -1, -1);
			if (((CancellationToken)(ref cancellationToken)).CanBeCanceled)
			{
				ctr = ((CancellationToken)(ref cancellationToken)).Register((Action)delegate
				{
					timer.Dispose();
					tcs.TrySetCanceled();
				});
			}
			timer.Change(dueTime, -1);
			return (Task)(object)tcs.Task;
		}

		public static Task WhenAll(params Task[] tasks)
		{
			return WhenAll((IEnumerable<Task>)tasks);
		}

		public static Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks)
		{
			return WhenAll((IEnumerable<Task<TResult>>)tasks);
		}

		public static Task WhenAll(IEnumerable<Task> tasks)
		{
			return (Task)(object)WhenAllCore(tasks, delegate(Task[] completedTasks, TaskCompletionSource<object> tcs)
			{
				tcs.TrySetResult((object)null);
			});
		}

		public static Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>> tasks)
		{
			return WhenAllCore(tasks.Cast<Task>(), delegate(Task[] completedTasks, TaskCompletionSource<TResult[]> tcs)
			{
				tcs.TrySetResult((from Task<TResult> t in completedTasks
					select t.Result).ToArray());
			});
		}

		private static Task<TResult> WhenAllCore<TResult>(IEnumerable<Task> tasks, Action<Task[], TaskCompletionSource<TResult>> setResultAction)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (tasks == null)
			{
				throw new ArgumentNullException("tasks");
			}
			TaskCompletionSource<TResult> tcs = new TaskCompletionSource<TResult>();
			Task[] array = (tasks as Task[]) ?? tasks.ToArray();
			if (array.Length == 0)
			{
				setResultAction(array, tcs);
			}
			else
			{
				Task.Factory.ContinueWhenAll(array, (Action<Task[]>)delegate(Task[] completedTasks)
				{
					List<Exception> targetList = null;
					bool flag = false;
					foreach (Task val in completedTasks)
					{
						if (val.IsFaulted)
						{
							AddPotentiallyUnwrappedExceptions(ref targetList, (Exception)(object)val.Exception);
						}
						else if (val.IsCanceled)
						{
							flag = true;
						}
					}
					if (targetList != null && targetList.Count > 0)
					{
						tcs.TrySetException((IEnumerable<Exception>)targetList);
					}
					else if (flag)
					{
						tcs.TrySetCanceled();
					}
					else
					{
						setResultAction(completedTasks, tcs);
					}
				}, CancellationToken.None, (TaskContinuationOptions)524288, TaskScheduler.Default);
			}
			return tcs.Task;
		}

		public static Task<Task> WhenAny(params Task[] tasks)
		{
			return WhenAny((IEnumerable<Task>)tasks);
		}

		public static Task<Task> WhenAny(IEnumerable<Task> tasks)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (tasks == null)
			{
				throw new ArgumentNullException("tasks");
			}
			TaskCompletionSource<Task> val = new TaskCompletionSource<Task>();
			Task.Factory.ContinueWhenAny<bool>((tasks as Task[]) ?? tasks.ToArray(), (Func<Task, bool>)val.TrySetResult, CancellationToken.None, (TaskContinuationOptions)524288, TaskScheduler.Default);
			return val.Task;
		}

		public static Task<Task<TResult>> WhenAny<TResult>(params Task<TResult>[] tasks)
		{
			return WhenAny((IEnumerable<Task<TResult>>)tasks);
		}

		public static Task<Task<TResult>> WhenAny<TResult>(IEnumerable<Task<TResult>> tasks)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (tasks == null)
			{
				throw new ArgumentNullException("tasks");
			}
			TaskCompletionSource<Task<TResult>> val = new TaskCompletionSource<Task<TResult>>();
			Task.Factory.ContinueWhenAny<TResult, bool>((tasks as Task<TResult>[]) ?? tasks.ToArray(), (Func<Task<TResult>, bool>)val.TrySetResult, CancellationToken.None, (TaskContinuationOptions)524288, TaskScheduler.Default);
			return val.Task;
		}

		public static Task<TResult> FromResult<TResult>(TResult result)
		{
			TaskCompletionSource<TResult> obj = new TaskCompletionSource<TResult>((object)result);
			obj.TrySetResult(result);
			return obj.Task;
		}

		public static YieldAwaitable Yield()
		{
			return default(YieldAwaitable);
		}

		private static void AddPotentiallyUnwrappedExceptions(ref List<Exception> targetList, Exception exception)
		{
			AggregateException ex = (AggregateException)(object)((exception is AggregateException) ? exception : null);
			if (targetList == null)
			{
				targetList = new List<Exception>();
			}
			if (ex != null)
			{
				targetList.Add((ex.InnerExceptions.Count == 1) ? exception.InnerException : exception);
			}
			else
			{
				targetList.Add(exception);
			}
		}
	}
}
namespace System.Runtime
{
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class TargetedPatchingOptOutAttribute : Attribute
	{
		private readonly string m_reason;

		public string Reason => m_reason;

		public TargetedPatchingOptOutAttribute(string reason)
		{
			m_reason = reason;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	internal struct AsyncMethodBuilderCore
	{
		private sealed class MoveNextRunner
		{
			private readonly ExecutionContext m_context;

			internal IAsyncStateMachine m_stateMachine;

			[SecurityCritical]
			private static ContextCallback s_invokeMoveNext;

			[SecurityCritical]
			internal MoveNextRunner(ExecutionContext context)
			{
				m_context = context;
			}

			[SecuritySafeCritical]
			internal void Run()
			{
				if (m_context == null)
				{
					m_stateMachine.MoveNext();
					return;
				}
				ContextCallback callback = InvokeMoveNext;
				ExecutionContext.Run(m_context, callback, m_stateMachine);
			}

			[SecurityCritical]
			private static void InvokeMoveNext(object stateMachine)
			{
				((IAsyncStateMachine)stateMachine).MoveNext();
			}
		}

		internal IAsyncStateMachine m_stateMachine;

		[SecuritySafeCritical]
		[DebuggerStepThrough]
		internal void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			if (stateMachine == null)
			{
				throw new ArgumentNullException("stateMachine");
			}
			stateMachine.MoveNext();
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			if (stateMachine == null)
			{
				throw new ArgumentNullException("stateMachine");
			}
			if (m_stateMachine != null)
			{
				throw new InvalidOperationException("The builder was not properly initialized.");
			}
			m_stateMachine = stateMachine;
		}

		[SecuritySafeCritical]
		internal Action GetCompletionAction<TMethodBuilder, TStateMachine>(ref TMethodBuilder builder, ref TStateMachine stateMachine) where TMethodBuilder : IAsyncMethodBuilder where TStateMachine : IAsyncStateMachine
		{
			MoveNextRunner moveNextRunner = new MoveNextRunner(ExecutionContext.Capture());
			Action result = moveNextRunner.Run;
			if (m_stateMachine == null)
			{
				builder.PreBoxInitialization();
				m_stateMachine = stateMachine;
				m_stateMachine.SetStateMachine(m_stateMachine);
			}
			moveNextRunner.m_stateMachine = m_stateMachine;
			return result;
		}

		internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (targetContext != null)
			{
				try
				{
					targetContext.Post(delegate(object state)
					{
						throw TaskAwaiter.PrepareExceptionForRethrow((Exception)state);
					}, exception);
					return;
				}
				catch (Exception ex)
				{
					exception = (Exception)new AggregateException(new Exception[2] { exception, ex });
				}
			}
			ThreadPool.QueueUserWorkItem(delegate(object state)
			{
				throw TaskAwaiter.PrepareExceptionForRethrow((Exception)state);
			}, exception);
		}
	}
	internal class AsyncMethodTaskCache<TResult>
	{
		private sealed class AsyncMethodBooleanTaskCache : AsyncMethodTaskCache<bool>
		{
			private readonly TaskCompletionSource<bool> m_true = CreateCompleted(result: true);

			private readonly TaskCompletionSource<bool> m_false = CreateCompleted(result: false);

			internal override TaskCompletionSource<bool> FromResult(bool result)
			{
				if (!result)
				{
					return m_false;
				}
				return m_true;
			}
		}

		private sealed class AsyncMethodInt32TaskCache : AsyncMethodTaskCache<int>
		{
			private static readonly TaskCompletionSource<int>[] Int32Tasks;

			private const int INCLUSIVE_INT32_MIN = -1;

			private const int EXCLUSIVE_INT32_MAX = 9;

			static AsyncMethodInt32TaskCache()
			{
				Int32Tasks = CreateInt32Tasks();
			}

			private static TaskCompletionSource<int>[] CreateInt32Tasks()
			{
				TaskCompletionSource<int>[] array = new TaskCompletionSource<int>[10];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = CreateCompleted(i - 1);
				}
				return array;
			}

			internal override TaskCompletionSource<int> FromResult(int result)
			{
				if (result < -1 || result >= 9)
				{
					return CreateCompleted(result);
				}
				return Int32Tasks[result - -1];
			}
		}

		internal static readonly AsyncMethodTaskCache<TResult> Singleton;

		static AsyncMethodTaskCache()
		{
			Singleton = CreateCache();
		}

		internal static TaskCompletionSource<TResult> CreateCompleted(TResult result)
		{
			TaskCompletionSource<TResult> obj = new TaskCompletionSource<TResult>();
			obj.TrySetResult(result);
			return obj;
		}

		private static AsyncMethodTaskCache<TResult> CreateCache()
		{
			Type typeFromHandle = typeof(TResult);
			if ((object)typeFromHandle == typeof(bool))
			{
				return (AsyncMethodTaskCache<TResult>)(object)new AsyncMethodBooleanTaskCache();
			}
			if ((object)typeFromHandle == typeof(int))
			{
				return (AsyncMethodTaskCache<TResult>)(object)new AsyncMethodInt32TaskCache();
			}
			return null;
		}

		internal virtual TaskCompletionSource<TResult> FromResult(TResult result)
		{
			return CreateCompleted(result);
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class AsyncStateMachineAttribute : StateMachineAttribute
	{
		public AsyncStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	public struct AsyncTaskMethodBuilder : IAsyncMethodBuilder
	{
		private static readonly TaskCompletionSource<VoidTaskResult> s_cachedCompleted;

		private AsyncTaskMethodBuilder<VoidTaskResult> m_builder;

		public Task Task => (Task)(object)m_builder.Task;

		private object ObjectIdForDebugger => Task;

		static AsyncTaskMethodBuilder()
		{
			s_cachedCompleted = AsyncTaskMethodBuilder<VoidTaskResult>.s_defaultResultTask;
		}

		public static AsyncTaskMethodBuilder Create()
		{
			return default(AsyncTaskMethodBuilder);
		}

		[DebuggerStepThrough]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			m_builder.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			m_builder.SetStateMachine(stateMachine);
		}

		void IAsyncMethodBuilder.PreBoxInitialization()
		{
			_ = Task;
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			m_builder.AwaitOnCompleted(ref awaiter, ref stateMachine);
		}

		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			m_builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
		}

		public void SetResult()
		{
			m_builder.SetResult(s_cachedCompleted);
		}

		public void SetException(Exception exception)
		{
			m_builder.SetException(exception);
		}

		internal void SetNotificationForWaitCompletion(bool enabled)
		{
			m_builder.SetNotificationForWaitCompletion(enabled);
		}
	}
	public struct AsyncTaskMethodBuilder<TResult> : IAsyncMethodBuilder
	{
		internal static readonly TaskCompletionSource<TResult> s_defaultResultTask;

		private System.Runtime.CompilerServices.AsyncMethodBuilderCore m_coreState;

		private TaskCompletionSource<TResult> m_task;

		internal TaskCompletionSource<TResult> CompletionSource
		{
			get
			{
				TaskCompletionSource<TResult> val = m_task;
				if (val == null)
				{
					val = (m_task = new TaskCompletionSource<TResult>());
				}
				return val;
			}
		}

		public Task<TResult> Task => CompletionSource.Task;

		private object ObjectIdForDebugger => Task;

		static AsyncTaskMethodBuilder()
		{
			s_defaultResultTask = AsyncMethodTaskCache<TResult>.CreateCompleted(default(TResult));
			try
			{
				AsyncVoidMethodBuilder.PreventUnobservedTaskExceptions();
			}
			catch
			{
			}
		}

		public static AsyncTaskMethodBuilder<TResult> Create()
		{
			return default(AsyncTaskMethodBuilder<TResult>);
		}

		[DebuggerStepThrough]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			m_coreState.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			m_coreState.SetStateMachine(stateMachine);
		}

		void IAsyncMethodBuilder.PreBoxInitialization()
		{
			_ = Task;
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			try
			{
				Action completionAction = m_coreState.GetCompletionAction(ref this, ref stateMachine);
				awaiter.OnCompleted(completionAction);
			}
			catch (Exception exception)
			{
				System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
			}
		}

		[SecuritySafeCritical]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			try
			{
				Action completionAction = m_coreState.GetCompletionAction(ref this, ref stateMachine);
				awaiter.UnsafeOnCompleted(completionAction);
			}
			catch (Exception exception)
			{
				System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
			}
		}

		public void SetResult(TResult result)
		{
			TaskCompletionSource<TResult> task = m_task;
			if (task == null)
			{
				m_task = GetTaskForResult(result);
			}
			else if (!task.TrySetResult(result))
			{
				throw new InvalidOperationException("The Task was already completed.");
			}
		}

		internal void SetResult(TaskCompletionSource<TResult> completedTask)
		{
			if (m_task == null)
			{
				m_task = completedTask;
			}
			else
			{
				SetResult(default(TResult));
			}
		}

		public void SetException(Exception exception)
		{
			if (exception == null)
			{
				throw new ArgumentNullException("exception");
			}
			TaskCompletionSource<TResult> completionSource = CompletionSource;
			if (!((exception is OperationCanceledException) ? completionSource.TrySetCanceled() : completionSource.TrySetException(exception)))
			{
				throw new InvalidOperationException("The Task was already completed.");
			}
		}

		internal void SetNotificationForWaitCompletion(bool enabled)
		{
		}

		private TaskCompletionSource<TResult> GetTaskForResult(TResult result)
		{
			AsyncMethodTaskCache<TResult> singleton = AsyncMethodTaskCache<TResult>.Singleton;
			if (singleton == null)
			{
				return AsyncMethodTaskCache<TResult>.CreateCompleted(result);
			}
			return singleton.FromResult(result);
		}
	}
	public struct AsyncVoidMethodBuilder : IAsyncMethodBuilder
	{
		private readonly SynchronizationContext m_synchronizationContext;

		private System.Runtime.CompilerServices.AsyncMethodBuilderCore m_coreState;

		private object m_objectIdForDebugger;

		private static int s_preventUnobservedTaskExceptionsInvoked;

		private object ObjectIdForDebugger => m_objectIdForDebugger ?? (m_objectIdForDebugger = new object());

		static AsyncVoidMethodBuilder()
		{
			try
			{
				PreventUnobservedTaskExceptions();
			}
			catch
			{
			}
		}

		private AsyncVoidMethodBuilder(SynchronizationContext synchronizationContext)
		{
			m_synchronizationContext = synchronizationContext;
			synchronizationContext?.OperationStarted();
			m_coreState = default(System.Runtime.CompilerServices.AsyncMethodBuilderCore);
			m_objectIdForDebugger = null;
		}

		internal static void PreventUnobservedTaskExceptions()
		{
			if (Interlocked.CompareExchange(ref s_preventUnobservedTaskExceptionsInvoked, 1, 0) == 0)
			{
				TaskScheduler.UnobservedTaskException += delegate(object s, UnobservedTaskExceptionEventArgs e)
				{
					e.SetObserved();
				};
			}
		}

		public static AsyncVoidMethodBuilder Create()
		{
			return new AsyncVoidMethodBuilder(SynchronizationContext.Current);
		}

		[DebuggerStepThrough]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			m_coreState.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			m_coreState.SetStateMachine(stateMachine);
		}

		void IAsyncMethodBuilder.PreBoxInitialization()
		{
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			try
			{
				Action completionAction = m_coreState.GetCompletionAction(ref this, ref stateMachine);
				awaiter.OnCompleted(completionAction);
			}
			catch (Exception exception)
			{
				System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
			}
		}

		[SecuritySafeCritical]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			try
			{
				Action completionAction = m_coreState.GetCompletionAction(ref this, ref stateMachine);
				awaiter.UnsafeOnCompleted(completionAction);
			}
			catch (Exception exception)
			{
				System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
			}
		}

		public void SetResult()
		{
			if (m_synchronizationContext != null)
			{
				NotifySynchronizationContextOfCompletion();
			}
		}

		public void SetException(Exception exception)
		{
			if (exception == null)
			{
				throw new ArgumentNullException("exception");
			}
			if (m_synchronizationContext != null)
			{
				try
				{
					System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, m_synchronizationContext);
					return;
				}
				finally
				{
					NotifySynchronizationContextOfCompletion();
				}
			}
			System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
		}

		private void NotifySynchronizationContextOfCompletion()
		{
			try
			{
				m_synchronizationContext.OperationCompleted();
			}
			catch (Exception exception)
			{
				System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class CallerFilePathAttribute : Attribute
	{
		[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
		public CallerFilePathAttribute()
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class CallerLineNumberAttribute : Attribute
	{
		[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
		public CallerLineNumberAttribute()
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class CallerMemberNameAttribute : Attribute
	{
		[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
		public CallerMemberNameAttribute()
		{
		}
	}
	public struct ConfiguredTaskAwaitable<TResult>
	{
		public struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly Task<TResult> m_task;

			private readonly bool m_continueOnCapturedContext;

			public bool IsCompleted => ((Task)m_task).IsCompleted;

			internal ConfiguredTaskAwaiter(Task<TResult> task, bool continueOnCapturedContext)
			{
				m_task = task;
				m_continueOnCapturedContext = continueOnCapturedContext;
			}

			public void OnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal((Task)(object)m_task, continuation, m_continueOnCapturedContext);
			}

			[SecurityCritical]
			public void UnsafeOnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal((Task)(object)m_task, continuation, m_continueOnCapturedContext);
			}

			public TResult GetResult()
			{
				TaskAwaiter.ValidateEnd((Task)(object)m_task);
				return m_task.Result;
			}
		}

		private readonly ConfiguredTaskAwaiter m_configuredTaskAwaiter;

		internal ConfiguredTaskAwaitable(Task<TResult> task, bool continueOnCapturedContext)
		{
			m_configuredTaskAwaiter = new ConfiguredTaskAwaiter(task, continueOnCapturedContext);
		}

		public ConfiguredTaskAwaiter GetAwaiter()
		{
			return m_configuredTaskAwaiter;
		}
	}
	public struct ConfiguredTaskAwaitable
	{
		public struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly Task m_task;

			private readonly bool m_continueOnCapturedContext;

			public bool IsCompleted => m_task.IsCompleted;

			internal ConfiguredTaskAwaiter(Task task, bool continueOnCapturedContext)
			{
				m_task = task;
				m_continueOnCapturedContext = continueOnCapturedContext;
			}

			public void OnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext);
			}

			[SecurityCritical]
			public void UnsafeOnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext);
			}

			public void GetResult()
			{
				TaskAwaiter.ValidateEnd(m_task);
			}
		}

		private readonly ConfiguredTaskAwaiter m_configuredTaskAwaiter;

		internal ConfiguredTaskAwaitable(Task task, bool continueOnCapturedContext)
		{
			m_configuredTaskAwaiter = new ConfiguredTaskAwaiter(task, continueOnCapturedContext);
		}

		public ConfiguredTaskAwaiter GetAwaiter()
		{
			return m_configuredTaskAwaiter;
		}
	}
	internal interface IAsyncMethodBuilder
	{
		void PreBoxInitialization();
	}
	public interface IAsyncStateMachine
	{
		void MoveNext();

		void SetStateMachine(IAsyncStateMachine stateMachine);
	}
	public interface ICriticalNotifyCompletion : INotifyCompletion
	{
		[SecurityCritical]
		void UnsafeOnCompleted(Action continuation);
	}
	public interface INotifyCompletion
	{
		void OnCompleted(Action continuation);
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class IteratorStateMachineAttribute : StateMachineAttribute
	{
		public IteratorStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public class StateMachineAttribute : Attribute
	{
		public Type StateMachineType { get; private set; }

		public StateMachineAttribute(Type stateMachineType)
		{
			StateMachineType = stateMachineType;
		}
	}
	public struct TaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
	{
		private static readonly MethodInfo s_prepForRemoting;

		private static readonly object[] s_emptyParams;

		internal const bool CONTINUE_ON_CAPTURED_CONTEXT_DEFAULT = true;

		private const string InvalidOperationException_TaskNotCompleted = "The task has not yet completed.";

		private readonly Task m_task;

		public bool IsCompleted => m_task.IsCompleted;

		private static bool IsValidLocationForInlining
		{
			get
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && (object)current.GetType() != typeof(SynchronizationContext))
				{
					return false;
				}
				return TaskScheduler.Current == TaskScheduler.Default;
			}
		}

		static TaskAwaiter()
		{
			s_prepForRemoting = GetPrepForRemotingMethodInfo();
			s_emptyParams = new object[0];
		}

		internal TaskAwaiter(Task task)
		{
			m_task = task;
		}

		public void OnCompleted(Action continuation)
		{
			OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true);
		}

		[SecurityCritical]
		public void UnsafeOnCompleted(Action continuation)
		{
			OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true);
		}

		public void GetResult()
		{
			ValidateEnd(m_task);
		}

		internal static void ValidateEnd(Task task)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)task.Status != 5)
			{
				HandleNonSuccess(task);
			}
		}

		private static void HandleNonSuccess(Task task)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if (!task.IsCompleted)
			{
				try
				{
					task.Wait();
				}
				catch
				{
				}
			}
			if ((int)task.Status != 5)
			{
				ThrowForNonSuccess(task);
			}
		}

		private static void ThrowForNonSuccess(Task task)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0012: 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_000d: Invalid comparison between Unknown and I4
			TaskStatus status = task.Status;
			if ((int)status != 6)
			{
				if ((int)status == 7)
				{
					throw PrepareExceptionForRethrow(((Exception)(object)task.Exception).InnerException);
				}
				throw new InvalidOperationException("The task has not yet completed.");
			}
			throw new TaskCanceledException(task);
		}

		internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (continuation == null)
			{
				throw new ArgumentNullException("continuation");
			}
			SynchronizationContext syncContext = (continueOnCapturedContext ? SynchronizationContext.Current : null);
			if (syncContext != null && (object)syncContext.GetType() != typeof(SynchronizationContext))
			{
				task.ContinueWith((Action<Task>)delegate
				{
					try
					{
						syncContext.Post(delegate(object state)
						{
							((Action)state)();
						}, continuation);
					}
					catch (Exception exception)
					{
						System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
					}
				}, CancellationToken.None, (TaskContinuationOptions)524288, TaskScheduler.Default);
				return;
			}
			TaskScheduler val = (continueOnCapturedContext ? TaskScheduler.Current : TaskScheduler.Default);
			if (task.IsCompleted)
			{
				Task.Factory.StartNew((Action<object>)delegate(object state)
				{
					((Action)state)();
				}, (object)continuation, CancellationToken.None, (TaskCreationOptions)0, val);
				return;
			}
			if (val != TaskScheduler.Default)
			{
				task.ContinueWith((Action<Task>)delegate
				{
					RunNoException(continuation);
				}, CancellationToken.None, (TaskContinuationOptions)524288, val);
				return;
			}
			task.ContinueWith((Action<Task>)delegate
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				if (IsValidLocationForInlining)
				{
					RunNoException(continuation);
				}
				else
				{
					Task.Factory.StartNew((Action<object>)delegate(object state)
					{
						RunNoException((Action)state);
					}, (object)continuation, CancellationToken.None, (TaskCreationOptions)0, TaskScheduler.Default);
				}
			}, CancellationToken.None, (TaskContinuationOptions)524288, TaskScheduler.Default);
		}

		private static void RunNoException(Action continuation)
		{
			try
			{
				continuation();
			}
			catch (Exception exception)
			{
				System.Runtime.CompilerServices.AsyncMethodBuilderCore.ThrowAsync(exception, null);
			}
		}

		internal static Exception PrepareExceptionForRethrow(Exception exc)
		{
			if ((object)s_prepForRemoting != null)
			{
				try
				{
					s_prepForRemoting.Invoke(exc, s_emptyParams);
				}
				catch
				{
				}
			}
			return exc;
		}

		private static MethodInfo GetPrepForRemotingMethodInfo()
		{
			try
			{
				return typeof(Exception).GetMethod("PrepForRemoting", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			catch
			{
				return null;
			}
		}
	}
	public struct TaskAwaiter<TResult> : ICriticalNotifyCompletion, INotifyCompletion
	{
		private readonly Task<TResult> m_task;

		public bool IsCompleted => ((Task)m_task).IsCompleted;

		internal TaskAwaiter(Task<TResult> task)
		{
			m_task = task;
		}

		public void OnCompleted(Action continuation)
		{
			TaskAwaiter.OnCompletedInternal((Task)(object)m_task, continuation, continueOnCapturedContext: true);
		}

		[SecurityCritical]
		public void UnsafeOnCompleted(Action continuation)
		{
			TaskAwaiter.OnCompletedInternal((Task)(object)m_task, continuation, continueOnCapturedContext: true);
		}

		public TResult GetResult()
		{
			TaskAwaiter.ValidateEnd((Task)(object)m_task);
			return m_task.Result;
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct VoidTaskResult
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct YieldAwaitable
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct YieldAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private static readonly Task s_completed;

			public bool IsCompleted => false;

			static YieldAwaiter()
			{
				s_completed = (Task)(object)TaskEx.FromResult(0);
			}

			public void OnCompleted(Action continuation)
			{
				s_completed.GetAwaiter().OnCompleted(continuation);
			}

			[SecurityCritical]
			public void UnsafeOnCompleted(Action continuation)
			{
				s_completed.GetAwaiter().UnsafeOnCompleted(continuation);
			}

			public void GetResult()
			{
			}
		}

		public YieldAwaiter GetAwaiter()
		{
			return default(YieldAwaiter);
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("Warp World, Inc.")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© 2026 Warp World, Inc.")]
[assembly: AssemblyFileVersion("5.0.9776.24445")]
[assembly: AssemblyInformationalVersion("5.0.9776.24445+90c600e1db2ff53dd548283d7fc60b5af3e3ec86")]
[assembly: AssemblyProduct("ConnectorLib.JSON")]
[assembly: AssemblyTitle("ConnectorLib.JSON")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("5.0.9776.24445")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ConnectorLib.JSON
{
	public class CamelCaseStringEnumConverter : JsonConverter<Enum>
	{
		public override void WriteJson(JsonWriter writer, Enum? value, JsonSerializer serializer)
		{
			if (value == null)
			{
				serializer.Serialize(writer, (object)null);
			}
			else
			{
				serializer.Serialize(writer, (object)value.ToCamelCase());
			}
		}

		public override Enum ReadJson(JsonReader reader, Type objectType, Enum? existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			return ReadJToken(JToken.ReadFrom(reader), objectType);
		}

		public static Enum ReadJToken(JToken reader, Type objectType)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			JTokenType type = reader.Type;
			if ((int)type != 6)
			{
				if ((int)type == 8)
				{
					string text = Extensions.Value<string>((IEnumerable<JToken>)reader);
					if (text == null)
					{
						throw new SerializationException("The value was null.");
					}
					try
					{
						return (Enum)Enum.Parse(objectType, text, ignoreCase: true);
					}
					catch (Exception)
					{
						throw new SerializationException("The value was not recognized.");
					}
				}
				throw new SerializationException("The value was not a string or number.");
			}
			int? num = Extensions.Value<int>((IEnumerable<JToken>)reader);
			if (!num.HasValue)
			{
				throw new SerializationException("The value was null.");
			}
			return (Enum)Enum.ToObject(objectType, num.Value);
		}
	}
	public class DataRequest : SimpleJSONRequest
	{
		public string key;

		public DataRequest(string key)
		{
			this.key = key;
			type = RequestType.DataRequest;
		}
	}
	public class DataResponse : SimpleJSONResponse
	{
		public string key;

		public JToken? value;

		public EffectStatus status;

		public long timeRemaining;

		public string? message;

		[JsonConstructor]
		public DataResponse(string key, EffectStatus status, object? value = null, long timeRemaining = 0L, string? message = null)
		{
			this.key = key;
			this.value = value.IfNotNull((Func<object, JToken?>)JToken.FromObject);
			this.status = status;
			this.timeRemaining = timeRemaining;
			this.message = message;
			type = ResponseType.DataResponse;
		}

		public static DataResponse SuccessIfDefined(string key, object? value, string failMessage = "")
		{
			if (value == null)
			{
				return Retry(key, 0L, failMessage);
			}
			if (value is string input && input.IsNullOrWhiteSpace())
			{
				return Retry(key, 0L, failMessage);
			}
			return Success(key, value);
		}

		public static DataResponse Success(string key, object? value)
		{
			return new DataResponse(key, EffectStatus.Success, value, 0L);
		}

		public static DataResponse Success(string key, object? value, string? message)
		{
			return new DataResponse(key, EffectStatus.Success, value, 0L, message);
		}

		public static DataResponse Failure(string key)
		{
			return new DataResponse(key, EffectStatus.Failure, null, 0L);
		}

		public static DataResponse Failure(string key, string? message)
		{
			return new DataResponse(key, EffectStatus.Failure, null, 0L, message);
		}

		public static DataResponse Failure(string key, object? value, string? message = null)
		{
			return new DataResponse(key, EffectStatus.Failure, value, 0L, message);
		}

		public static DataResponse Retry(string key, long delay = 0L, string? message = null)
		{
			return new DataResponse(key, EffectStatus.Retry, null, delay, message);
		}
	}
	public class EffectRequest : SimpleJSONRequest
	{
		public class Target
		{
			public string? service;

			public string? id;

			public string? name;

			public string? avatar;
		}

		public string? code;

		public string? message;

		public JToken? parameters;

		public uint? quantity;

		public JArray? targets;

		public long? duration;

		public string? viewer;

		public JArray? viewers;

		public long? cost;

		public Dictionary<string, object?>? arguments;

		public Guid? requestID;

		[JsonConverter(typeof(IEffectSourceDetails.Converter))]
		public IEffectSourceDetails? sourceDetails;

		public EffectRequest()
		{
			type = RequestType.EffectStart;
		}
	}
	public class EffectResponse : SimpleJSONResponse
	{
		private class MetadataConverter : JsonConverter<Dictionary<string, DataResponse>?>
		{
			public override void WriteJson(JsonWriter writer, Dictionary<string, DataResponse>? value, JsonSerializer serializer)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				if (value == null)
				{
					serializer.Serialize(writer, (object)null);
					return;
				}
				JObject val = new JObject();
				foreach (KeyValuePair<string, DataResponse> item in value)
				{
					JObject val2 = JObject.FromObject((object)item.Value);
					val2.Remove("key");
					val[item.Key] = (JToken)(object)val2;
				}
				serializer.Serialize(writer, (object)val);
			}

			public override Dictionary<string, DataResponse>? ReadJson(JsonReader reader, Type objectType, Dictionary<string, DataResponse>? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				JObject val = (JObject)serializer.Deserialize(reader);
				if (val == null)
				{
					return null;
				}
				Dictionary<string, DataResponse> dictionary = new Dictionary<string, DataResponse>();
				foreach (JProperty item in val.Properties())
				{
					JObject val2 = (JObject)item.Value;
					val2["key"] = JToken.op_Implicit(item.Name);
					dictionary.Add(item.Name, ((JToken)val2).ToObject<DataResponse>());
				}
				return dictionary;
			}
		}

		public EffectStatus status;

		public string? message;

		public StandardErrors messageID;

		public long timeRemaining;

		[JsonConverter(typeof(MetadataConverter))]
		public Dictionary<string, DataResponse>? metadata;

		public EffectResponse()
		{
		}

		public EffectResponse(uint id, EffectStatus status)
			: this(id, status, 0L)
		{
		}

		public EffectResponse(uint id, EffectStatus status, StandardErrors messageID, string? message = null)
			: this(id, status, 0L, messageID, message)
		{
		}

		public EffectResponse(uint id, EffectStatus status, string? message)
			: this(id, status, 0L, message)
		{
		}

		public EffectResponse(uint id, EffectStatus status, TimeSpan timeRemaining)
			: this(id, status, checked((long)timeRemaining.TotalMilliseconds))
		{
		}

		public EffectResponse(uint id, EffectStatus status, TimeSpan timeRemaining, StandardErrors messageID)
			: this(id, status, checked((long)timeRemaining.TotalMilliseconds), messageID)
		{
		}

		public EffectResponse(uint id, EffectStatus status, TimeSpan timeRemaining, string? message)
			: this(id, status, checked((long)timeRemaining.TotalMilliseconds), message)
		{
		}

		public EffectResponse(uint id, EffectStatus status, long timeRemaining, string? message = null)
		{
			base.id = id;
			this.status = status;
			this.timeRemaining = timeRemaining;
			this.message = message;
			type = ResponseType.EffectRequest;
		}

		[JsonConstructor]
		public EffectResponse(uint id, EffectStatus status, long timeRemaining, StandardErrors messageID, string? message = null)
		{
			base.id = id;
			this.status = status;
			this.timeRemaining = timeRemaining;
			this.messageID = messageID;
			this.message = message;
			type = ResponseType.EffectRequest;
		}

		public static EffectResponse Success(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Success, message);
		}

		public static EffectResponse Success(uint id, long delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Success, delay, message);
		}

		public static EffectResponse Success(uint id, TimeSpan delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Success, delay, message);
		}

		public static EffectResponse Failure(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Failure, message);
		}

		public static EffectResponse Failure(uint id, StandardErrors error, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Failure, error, message);
		}

		public static EffectResponse Unavailable(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Unavailable, message);
		}

		public static EffectResponse Unavailable(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Unavailable, error);
		}

		public static EffectResponse Retry(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Retry, 0L, message);
		}

		public static EffectResponse Retry(uint id, long delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, message);
		}

		public static EffectResponse Retry(uint id, TimeSpan delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, message);
		}

		public static EffectResponse Retry(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Retry, 0L, error);
		}

		public static EffectResponse Retry(uint id, long delay, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, error);
		}

		public static EffectResponse Retry(uint id, TimeSpan delay, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, error);
		}

		public static EffectResponse Paused(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Paused, 0L, message);
		}

		public static EffectResponse Paused(uint id, long timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, message);
		}

		public static EffectResponse Paused(uint id, TimeSpan timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, message);
		}

		public static EffectResponse Paused(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Paused, 0L, error);
		}

		public static EffectResponse Paused(uint id, long timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, error);
		}

		public static EffectResponse Paused(uint id, TimeSpan timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, error);
		}

		public static EffectResponse Resumed(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Resumed, 0L, message);
		}

		public static EffectResponse Resumed(uint id, long timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, message);
		}

		public static EffectResponse Resumed(uint id, TimeSpan timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, message);
		}

		public static EffectResponse Resumed(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Resumed, 0L, error);
		}

		public static EffectResponse Resumed(uint id, long timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, error);
		}

		public static EffectResponse Resumed(uint id, TimeSpan timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, error);
		}

		public static EffectResponse Finished(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Finished, 0L, message);
		}

		public static EffectResponse Finished(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Finished, 0L, error);
		}
	}
	public interface IEffectSourceDetails
	{
		public class Converter : JsonConverter<IEffectSourceDetails?>
		{
			public static readonly Converter Instance = new Converter();

			public override IEffectSourceDetails? ReadJson(JsonReader reader, Type objectType, IEffectSourceDetails? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)reader.TokenType == 11)
				{
					return null;
				}
				JObject val = JObject.Load(reader);
				JToken obj = val["type"];
				return ((obj != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj) : null) switch
				{
					"twitch-channel-reward" => ((JToken)val).ToObject<TwitchChannelRewardSourceDetails>(), 
					"stream-labs-donation" => ((JToken)val).ToObject<StreamLabsDonationSourceDetails>(), 
					"event-hype-train" => ((JToken)val).ToObject<HypeTrainSourceDetails>(), 
					"tiktok-gift" => ((JToken)val).ToObject<TikTokGiftSourceDetails>(), 
					"tiktok-like" => ((JToken)val).ToObject<TikTokLikeSourceDetails>(), 
					"tiktok-follow" => ((JToken)val).ToObject<TikTokFollowSourceDetails>(), 
					"tiktok-share" => ((JToken)val).ToObject<TikTokShareSourceDetails>(), 
					"pulsoid-trigger" => ((JToken)val).ToObject<PulsoidTriggerSourceDetails>(), 
					"crowd-control-test" => ((JToken)val).ToObject<CrowdControlTestSourceDetails>(), 
					"crowd-control-chaos-mode" => ((JToken)val).ToObject<CrowdControlChaosModeSourceDetails>(), 
					"crowd-control-retry" => ((JToken)val).ToObject<CrowdControlRetrySourceDetails>(), 
					_ => null, 
				};
			}

			public override void WriteJson(JsonWriter writer, IEffectSourceDetails? value, JsonSerializer serializer)
			{
				serializer.Serialize(writer, (object)((value == null) ? null : JObject.FromObject((object)value)));
			}
		}

		[JsonProperty("type")]
		string Type { get; }
	}
	public class TwitchChannelRewardSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "twitch-channel-reward";

		[JsonProperty("rewardID")]
		public string RewardID { get; set; }

		[JsonProperty("redemptionID")]
		public string RedemptionID { get; set; }

		[JsonProperty("twitchID")]
		public string TwitchID { get; set; }

		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("cost")]
		public int Cost { get; set; }
	}
	public class StreamLabsDonationSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "stream-labs-donation";

		[JsonProperty("donationID")]
		public string DonationID { get; set; }

		[JsonProperty("cost")]
		public string Cost { get; set; }

		[JsonProperty("currency")]
		public string Currency { get; set; }

		[JsonProperty("name")]
		public string? Name { get; set; }

		[JsonProperty("message")]
		public string? Message { get; set; }
	}
	public class HypeTrainSourceDetails : IEffectSourceDetails
	{
		public class Contribution
		{
			[JsonProperty("user_id")]
			public string UserID { get; set; }

			[JsonProperty("user_login")]
			public string UserLogin { get; set; }

			[JsonProperty("user_name")]
			public string UserName { get; set; }

			[JsonProperty("type")]
			public string Type { get; set; }

			[JsonProperty("total")]
			public int Total { get; set; }
		}

		[JsonProperty("type")]
		public string Type => "event-hype-train";

		[JsonProperty("total")]
		public int Total { get; set; }

		[JsonProperty("progress")]
		public int Progress { get; set; }

		[JsonProperty("goal")]
		public int Goal { get; set; }

		[JsonProperty("top_contributions")]
		public List<Contribution> TopContributions { get; set; }

		[JsonProperty("last_contribution")]
		public Contribution LastContribution { get; set; }

		[JsonProperty("level")]
		public int Level { get; set; }
	}
	public abstract class TikTokSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public abstract string Type { get; }

		[JsonProperty("cost")]
		public int Cost { get; set; }

		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("userID")]
		public string UserID { get; set; }
	}
	public class TikTokGiftSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-gift";

		[JsonProperty("giftID")]
		public int GiftID { get; set; }

		[JsonProperty("giftName")]
		public string GiftName { get; set; }

		[JsonProperty("transactionID")]
		public string? TransactionID { get; set; }
	}
	public class TikTokLikeSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-like";
	}
	public class TikTokFollowSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-follow";
	}
	public class TikTokShareSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-share";
	}
	public class PulsoidTriggerSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "pulsoid-trigger";

		[JsonProperty("heartRate")]
		public int HeartRate { get; set; }

		[JsonProperty("uuid")]
		public Guid Uuid { get; set; }

		[JsonProperty("triggerType")]
		public string TriggerType { get; set; }

		[JsonProperty("targetHeartRate")]
		public int TargetHeartRate { get; set; }

		[JsonProperty("holdTime")]
		public int HoldTime { get; set; }

		[JsonProperty("cooldown")]
		public int Cooldown { get; set; }
	}
	public class CrowdControlTestSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "crowd-control-test";
	}
	public class CrowdControlChaosModeSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "crowd-control-chaos-mode";
	}
	public class CrowdControlRetrySourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "crowd-control-retry";
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum EffectStatus
	{
		Success = 0,
		Failure = 1,
		Unavailable = 2,
		Retry = 3,
		Queue = 4,
		Running = 5,
		Paused = 6,
		Resumed = 7,
		Finished = 8,
		Wait = 9,
		RemoteScheduled = 10,
		Visible = 128,
		NotVisible = 129,
		Selectable = 130,
		NotSelectable = 131,
		Reserved0 = 160,
		NotReady = 255
	}
	public class EffectUpdate : SimpleJSONResponse
	{
		[JsonConverter(typeof(CamelCaseStringEnumConverter))]
		public enum IdentifierType
		{
			Effect,
			Group,
			Category
		}

		[Obsolete("This field is deprecated. Please use the ids field instead.")]
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string? code;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string[]? ids;

		public IdentifierType idType;

		public EffectStatus status;

		public string? message;

		public EffectUpdate()
		{
		}

		public EffectUpdate(string id, EffectStatus status, string? message = null)
		{
			ids = new string[1] { id };
			idType = IdentifierType.Effect;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(string id, IdentifierType idType, EffectStatus status, string? message = null)
		{
			ids = new string[1] { id };
			this.idType = idType;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(string[] ids, EffectStatus status, string? message = null)
		{
			this.ids = ids;
			idType = IdentifierType.Effect;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(string[] ids, IdentifierType idType, EffectStatus status, string? message = null)
		{
			this.ids = ids;
			this.idType = idType;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(IEnumerable<string> ids, EffectStatus status, string? message = null)
		{
			this.ids = ids.ToArray();
			idType = IdentifierType.Effect;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(IEnumerable<string> ids, IdentifierType idType, EffectStatus status, string? message = null)
		{
			this.ids = ids.ToArray();
			this.idType = idType;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}
	}
	public class EmptyRequest : SimpleJSONRequest
	{
	}
	public class EmptyResponse : SimpleJSONResponse
	{
	}
	internal static class EnumEx
	{
		internal static string ToCamelCase(this Enum value)
		{
			return value.ToString("G").ToCamelCase();
		}
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum GameState
	{
		Unknown = 0,
		Error = -1,
		Unmodded = -2,
		BadGameSettings = -3,
		WrongVersion = -4,
		NotFocused = -5,
		Loading = -6,
		InLevel = 1,
		[Obsolete("Use InLevel instead. This state is redundant and does not provide any additional information about the game state.")]
		Ready = 1,
		TitleScreen = -17,
		Credits = -18,
		Menu = -13,
		Paused = -7,
		WrongMode = -8,
		SafeArea = -9,
		StartingArea = -19,
		Dialogue = -20,
		Cutscene = -11,
		BadPlayerState = -12,
		InputLocked = -21,
		Map = -14,
		UntimedArea = -10,
		InCombat = -15,
		NotInCombat = -16,
		PipelineBusy = -128,
		NotReady = int.MinValue
	}
	public class GameUpdate : SimpleJSONResponse
	{
		public GameState state;

		public string? message;

		public GameUpdate(GameState state, string? message = null)
		{
			this.state = state;
			this.message = message;
			type = ResponseType.GameUpdate;
		}
	}
	public class GenericEventRequest : SimpleJSONRequest
	{
		[JsonProperty(PropertyName = "internal")]
		public bool @internal;

		public string eventType;

		public Dictionary<string, object?>? data;

		public GenericEventRequest(string eventType)
		{
			type = RequestType.GenericEvent;
			this.eventType = eventType;
		}

		[JsonConstructor]
		public GenericEventRequest(string eventType, IEnumerable<KeyValuePair<string, object?>>? data)
			: this(eventType)
		{
			this.data = ((data != null) ? data.ToDictionary() : null);
		}

		[JsonConstructor]
		public GenericEventRequest(string eventType, IEnumerable<KeyValuePair<string, object?>>? data, bool @internal)
			: this(eventType, data)
		{
			this.@internal = @internal;
		}
	}
	public class GenericEventResponse : SimpleJSONResponse
	{
		[JsonProperty(PropertyName = "internal")]
		public bool @internal;

		public string eventType;

		public Dictionary<string, object?>? data;

		public GenericEventResponse(string eventType)
		{
			type = ResponseType.GenericEvent;
			this.eventType = eventType;
		}

		public GenericEventResponse(string eventType, IEnumerable<KeyValuePair<string, object>>? data, bool @internal = false)
			: this(eventType)
		{
			this.data = ((data != null) ? data.ToDictionary() : null);
			this.@internal = @internal;
		}

		[JsonConstructor]
		public GenericEventResponse(string eventType, Dictionary<string, object>? data, [JsonProperty(PropertyName = "internal")] bool @internal)
			: this(eventType, data)
		{
			this.@internal = @internal;
		}
	}
	internal class HexColorConverter : JsonConverter<ParameterColorValue>
	{
		private static readonly Dictionary<char, byte> CHAR_LOOKUP = new Dictionary<char, byte>
		{
			{ '0', 0 },
			{ '1', 1 },
			{ '2', 2 },
			{ '3', 3 },
			{ '4', 4 },
			{ '5', 5 },
			{ '6', 6 },
			{ '7', 7 },
			{ '8', 8 },
			{ '9', 9 },
			{ 'A', 10 },
			{ 'B', 11 },
			{ 'C', 12 },
			{ 'D', 13 },
			{ 'E', 14 },
			{ 'F', 15 }
		};

		public override void WriteJson(JsonWriter writer, ParameterColorValue value, JsonSerializer serializer)
		{
			serializer.Serialize(writer, (object)string.Format("#{0}{1:X2}{2:X2}{3:X2}", (value.A != byte.MaxValue) ? value.A.ToString("X2") : string.Empty, value.R, value.G, value.B));
		}

		public override ParameterColorValue ReadJson(JsonReader reader, Type objectType, ParameterColorValue existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			if (TryParse(serializer.Deserialize<string>(reader), out var color))
			{
				return color;
			}
			throw new SerializationException("Unrecognized color code.");
		}

		public static bool TryParse(string? value, out ParameterColorValue color)
		{
			if (value == null)
			{
				color = default(ParameterColorValue);
				return false;
			}
			value = value.TrimStart(new char[1] { '#' });
			switch (value.Length)
			{
			case 6:
			{
				string[] array2 = value.Chop(2);
				byte result2;
				byte red3 = (byte)(byte.TryParse(array2[0], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result2) ? result2 : 0);
				byte green3 = (byte)(byte.TryParse(array2[1], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result2) ? result2 : 0);
				byte blue3 = (byte)(byte.TryParse(array2[2], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result2) ? result2 : 0);
				color = ParameterColorValue.FromArgb(red3, green3, blue3);
				return true;
			}
			case 8:
			{
				string[] array = value.Chop(2);
				byte result;
				byte alpha2 = (byte)(byte.TryParse(array[0], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				byte red2 = (byte)(byte.TryParse(array[1], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				byte green2 = (byte)(byte.TryParse(array[2], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				byte blue2 = (byte)(byte.TryParse(array[3], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				color = ParameterColorValue.FromArgb(alpha2, red2, green2, blue2);
				return true;
			}
			case 3:
			{
				byte value3;
				byte red4 = (byte)(CHAR_LOOKUP.TryGetValue(value[0], out value3) ? checked((byte)(value3 * 16)) : 0);
				byte green4 = (byte)(CHAR_LOOKUP.TryGetValue(value[1], out value3) ? checked((byte)(value3 * 16)) : 0);
				byte blue4 = (byte)(CHAR_LOOKUP.TryGetValue(value[2], out value3) ? checked((byte)(value3 * 16)) : 0);
				color = ParameterColorValue.FromArgb(red4, green4, blue4);
				return true;
			}
			case 4:
			{
				byte value2;
				byte alpha = (byte)(CHAR_LOOKUP.TryGetValue(value[0], out value2) ? checked((byte)(value2 * 16)) : 0);
				byte red = (byte)(CHAR_LOOKUP.TryGetValue(value[1], out value2) ? checked((byte)(value2 * 16)) : 0);
				byte green = (byte)(CHAR_LOOKUP.TryGetValue(value[2], out value2) ? checked((byte)(value2 * 16)) : 0);
				byte blue = (byte)(CHAR_LOOKUP.TryGetValue(value[3], out value2) ? checked((byte)(value2 * 16)) : 0);
				color = ParameterColorValue.FromArgb(alpha, red, green, blue);
				return true;
			}
			default:
				color = default(ParameterColorValue);
				return false;
			}
		}
	}
	internal static class IEnumerableEx
	{
		internal static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> values) where TKey : notnull
		{
			Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> value in values)
			{
				dictionary.Add(value.Key, value.Value);
			}
			return dictionary;
		}
	}
	public interface IParameterValue
	{
		string ID { get; }

		string Name { get; }

		ParameterBase.ParameterType Type { get; }

		object? Value { get; }
	}
	public class LoginRequest : SimpleJSONRequest
	{
		public string? login;

		public string? password;
	}
	public class MessageRequest : SimpleJSONRequest
	{
		public string? message;
	}
	public class MessageResponse : SimpleJSONResponse
	{
		public string? message;
	}
	internal static class ObjectEx
	{
		internal static T2? IfNotNull<T1, T2>(this T1? value, Func<T1, T2?> selector) where T2 : class
		{
			if (value == null)
			{
				return null;
			}
			return selector(value);
		}
	}
	public abstract class ParameterBase
	{
		[JsonConverter(typeof(ParameterTypeConverter))]
		public enum ParameterType
		{
			Options,
			HexColor
		}

		private class ParameterTypeConverter : JsonConverter<ParameterType>
		{
			public override void WriteJson(JsonWriter writer, ParameterType value, JsonSerializer serializer)
			{
				writer.WriteValue(value switch
				{
					ParameterType.Options => "options", 
					ParameterType.HexColor => "hex-color", 
					_ => throw new SerializationException("Unknown parameter type."), 
				});
			}

			public override ParameterType ReadJson(JsonReader reader, Type objectType, ParameterType existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				switch (reader.Value?.ToString().ToLowerInvariant())
				{
				case "options":
					return ParameterType.Options;
				case "hexcolor":
				case "hex-color":
					return ParameterType.HexColor;
				default:
					throw new SerializationException("Unknown parameter type.");
				}
			}
		}

		[JsonIgnore]
		public readonly string ID;

		[JsonProperty(PropertyName = "title")]
		public readonly string Name;

		[JsonProperty(PropertyName = "type")]
		public readonly ParameterType Type;

		protected ParameterBase(string name, string id, ParameterType type)
		{
			ID = id;
			Name = name;
			Type = type;
		}
	}
	public class ParameterColor : ParameterBase, IParameterValue
	{
		[JsonProperty(PropertyName = "value")]
		[JsonConverter(typeof(HexColorConverter))]
		public ParameterColorValue Value;

		[JsonIgnore]
		string IParameterValue.ID => ID;

		[JsonIgnore]
		string IParameterValue.Name => Name;

		[JsonIgnore]
		ParameterType IParameterValue.Type => Type;

		[JsonIgnore]
		object? IParameterValue.Value => Value;

		[JsonConstructor]
		public ParameterColor(string name, string id, ParameterColorValue value)
			: base(name, id, ParameterType.HexColor)
		{
			Value = value;
		}

		[JsonConstructor]
		public ParameterColor(string name, string id, string value)
			: base(name, id, ParameterType.HexColor)
		{
			if (!HexColorConverter.TryParse(value, out Value))
			{
				throw new ArgumentException("Unknown color code.", "value");
			}
		}
	}
	[DebuggerDisplay("{NameAndARGBValue}")]
	public readonly struct ParameterColorValue : IEquatable<ParameterColorValue>
	{
		public static readonly ParameterColorValue Empty;

		private const short StateARGBValueValid = 2;

		private const short StateValueMask = 2;

		private const short StateNameValid = 8;

		private const long NotDefinedValue = 0L;

		internal const int ARGBAlphaShift = 24;

		internal const int ARGBRedShift = 16;

		internal const int ARGBGreenShift = 8;

		internal const int ARGBBlueShift = 0;

		internal const uint ARGBAlphaMask = 4278190080u;

		internal const uint ARGBRedMask = 16711680u;

		internal const uint ARGBGreenMask = 65280u;

		internal const uint ARGBBlueMask = 255u;

		private readonly long value;

		private readonly short state;

		public byte R => (byte)(Value >> 16);

		public byte G => (byte)(Value >> 8);

		public byte B => (byte)Value;

		public byte A => (byte)(Value >> 24);

		public bool IsEmpty => state == 0;

		private long Value
		{
			get
			{
				if ((state & 2) != 0)
				{
					return value;
				}
				return 0L;
			}
		}

		private ParameterColorValue(long value, short state)
		{
			this.value = value;
			this.state = state;
		}

		private static ParameterColorValue FromArgb(uint argb)
		{
			return new ParameterColorValue(argb, 2);
		}

		public static ParameterColorValue FromArgb(int argb)
		{
			return FromArgb((uint)argb);
		}

		public static ParameterColorValue FromArgb(byte alpha, byte red, byte green, byte blue)
		{
			return FromArgb((uint)((alpha << 24) | (red << 16) | (green << 8) | blue));
		}

		public static ParameterColorValue FromArgb(int alpha, ParameterColorValue baseColor)
		{
			return FromArgb(checked(((uint)alpha << 24) | ((uint)baseColor.Value & 0xFFFFFF)));
		}

		public static ParameterColorValue FromArgb(byte red, byte green, byte blue)
		{
			return FromArgb(byte.MaxValue, red, green, blue);
		}

		private void GetRgbValues(out byte r, out byte g, out byte b)
		{
			checked
			{
				uint num = (uint)Value;
				r = (byte)((num & 0xFF0000) >> 16);
				g = (byte)((num & 0xFF00) >> 8);
				b = (byte)(num & 0xFF);
			}
		}

		public float GetBrightness()
		{
			GetRgbValues(out var r, out var g, out var b);
			int num = Math.Min(Math.Min(r, g), b);
			return (float)checked(Math.Max(Math.Max(r, g), b) + num) / 510f;
		}

		public float GetHue()
		{
			GetRgbValues(out var r, out var g, out var b);
			if (r == g && g == b)
			{
				return 0f;
			}
			int num = Math.Min(Math.Min(r, g), b);
			int num2 = Math.Max(Math.Max(r, g), b);
			checked
			{
				float num3 = num2 - num;
				float num4 = ((r == num2) ? ((float)(g - b) / num3) : ((g != num2) ? ((float)(r - g) / num3 + 4f) : ((float)(b - r) / num3 + 2f)));
				num4 *= 60f;
				if (num4 < 0f)
				{
					num4 += 360f;
				}
				return num4;
			}
		}

		public float GetSaturation()
		{
			GetRgbValues(out var r, out var g, out var b);
			if (r == g && g == b)
			{
				return 0f;
			}
			int num = Math.Min(Math.Min(r, g), b);
			int num2 = Math.Max(Math.Max(r, g), b);
			checked
			{
				int num3 = num2 + num;
				if (num3 > 255)
				{
					num3 = 510 - num2 - num;
				}
				return (float)(num2 - num) / (float)num3;
			}
		}

		public int ToArgb()
		{
			return (int)Value;
		}

		public override string ToString()
		{
			if ((state & 2) != 0)
			{
				return "ParameterColorValue [A=" + A + ", R=" + R + ", G=" + G + ", B=" + B + "]";
			}
			return "ParameterColorValue [Empty]";
		}

		public static bool operator ==(ParameterColorValue left, ParameterColorValue right)
		{
			if (left.value == right.value)
			{
				return left.state == right.state;
			}
			return false;
		}

		public static bool operator !=(ParameterColorValue left, ParameterColorValue right)
		{
			return !(left == right);
		}

		public override bool Equals(object? obj)
		{
			if (obj is ParameterColorValue other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(ParameterColorValue other)
		{
			return this == other;
		}

		public override int GetHashCode()
		{
			long num = value;
			int num2 = num.GetHashCode() * 397;
			short num3 = state;
			return num2 ^ num3.GetHashCode();
		}
	}
	public class ParameterValue<TValue> : ParameterBase, IParameterValue
	{
		[JsonProperty(PropertyName = "value")]
		public TValue? Value;

		[JsonIgnore]
		string IParameterValue.ID => ID;

		[JsonIgnore]
		string IParameterValue.Name => Name;

		[JsonIgnore]
		ParameterType IParameterValue.Type => Type;

		[JsonIgnore]
		object? IParameterValue.Value => Value;

		[JsonConstructor]
		public ParameterValue(string name, string id, TValue? value)
			: base(name, id, ParameterType.Options)
		{
			Value = value;
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public class PlayerInfo : SimpleJSONRequest
	{
		public JObject? player;

		public PlayerInfo()
		{
			type = RequestType.PlayerInfo;
		}
	}
	[JsonConverter(typeof(Converter))]
	public class RequestParameters : IEnumerable<IParameterValue>, IEnumerable
	{
		private class Converter : JsonConverter<RequestParameters>
		{
			public override void WriteJson(JsonWriter writer, RequestParameters? value, JsonSerializer serializer)
			{
				serializer.Serialize(writer, (object)value?._parameters);
			}

			public override RequestParameters? ReadJson(JsonReader reader, Type objectType, RequestParameters? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				JObject obj = JObject.Load(reader);
				List<IParameterValue> list = new List<IParameterValue>();
				foreach (KeyValuePair<string, JToken> item in obj)
				{
					string key = item.Key;
					string name = Extensions.Value<string>((IEnumerable<JToken>)item.Value[(object)"name"]);
					switch (Extensions.Value<ParameterBase.ParameterType>((IEnumerable<JToken>)item.Value[(object)"type"]))
					{
					case ParameterBase.ParameterType.Options:
					{
						string value = Extensions.Value<string>((IEnumerable<JToken>)item.Value[(object)"value"]);
						list.Add(new ParameterValue<string>(name, key, value));
						break;
					}
					case ParameterBase.ParameterType.HexColor:
					{
						if (HexColorConverter.TryParse(Extensions.Value<string>((IEnumerable<JToken>)item.Value[(object)"value"]), out var color))
						{
							list.Add(new ParameterColor(name, key, color));
						}
						break;
					}
					default:
						throw new SerializationException();
					}
				}
				return new RequestParameters(list);
			}
		}

		private readonly Dictionary<string, IParameterValue> _parameters;

		private readonly List<string> _parameter_list;

		public string this[int index] => _parameter_list[index];

		public IParameterValue this[string key] => _parameters[key];

		public IEnumerable<string> Keys => _parameters.Keys;

		public IEnumerable<IParameterValue> Values => _parameters.Values;

		public int Count => _parameters.Count;

		private RequestParameters()
		{
			_parameters = new Dictionary<string, IParameterValue>();
			_parameter_list = new List<string>();
		}

		public RequestParameters(IEnumerable<IParameterValue> parameters)
		{
			parameters = parameters.ToArray();
			_parameters = parameters.ToDictionary((IParameterValue d) => d.ID);
			_parameter_list = parameters.Select((IParameterValue v) => v.Value.ToString()).ToList();
		}

		public RequestParameters(IEnumerable<KeyValuePair<string, IParameterValue>> parameters)
		{
			_parameters = parameters.ToDictionary();
			_parameter_list = _parameters.Values.Select((IParameterValue p) => p.Value.ToString()).ToList();
		}

		public IEnumerator<IParameterValue> GetEnumerator()
		{
			return _parameters.Values.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public bool ContainsKey(string key)
		{
			return _parameters.ContainsKey(key);
		}

		public bool TryGetValue(string key, out IParameterValue value)
		{
			return _parameters.TryGetValue(key, out value);
		}

		public IEnumerable<string> Where(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).Where(predicate);
		}

		public IEnumerable<TResult> Select<TResult>(Func<string, TResult> selector)
		{
			return ((IEnumerable<string>)this).Select(selector);
		}

		public IEnumerable<TResult> SelectMany<TResult>(Func<string, IEnumerable<TResult>> selector)
		{
			return ((IEnumerable<string>)this).SelectMany(selector);
		}

		public IEnumerable<TResult> SelectMany<TResult>(Func<string, int, IEnumerable<TResult>> selector)
		{
			return ((IEnumerable<string>)this).SelectMany(selector);
		}

		public string First()
		{
			return ((IEnumerable<string>)this).First();
		}

		public string First(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).First(predicate);
		}

		public string? FirstOrDefault()
		{
			return ((IEnumerable<string>)this).FirstOrDefault();
		}

		public string FirstOrDefault(string defaultValue)
		{
			return ((IEnumerable<string>)this).FirstOrDefault() ?? defaultValue;
		}

		public string? FirstOrDefault(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).FirstOrDefault(predicate);
		}

		public string FirstOrDefault(Func<string, bool> predicate, string defaultValue)
		{
			return ((IEnumerable<string>)this).FirstOrDefault(predicate) ?? defaultValue;
		}

		public bool Any()
		{
			return ((IEnumerable<string>)this).Any();
		}

		public bool Any(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).Any(predicate);
		}
	}
	public enum RequestType : byte
	{
		EffectTest = 0,
		EffectStart = 1,
		EffectStop = 2,
		[Obsolete("Use EffectTest instead.")]
		Test = 0,
		[Obsolete("Use EffectStart instead.")]
		Start = 1,
		[Obsolete("Use EffectStop instead.")]
		Stop = 2,
		GenericEvent = 16,
		DataRequest = 32,
		RpcResponse = 208,
		PlayerInfo = 224,
		Login = 240,
		Version = 252,
		GameUpdate = 253,
		KeepAlive = byte.MaxValue
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum ResponseType : byte
	{
		EffectRequest = 0,
		EffectStatus = 1,
		GenericEvent = 16,
		LoadEvent = 24,
		SaveEvent = 25,
		DataResponse = 32,
		RpcRequest = 208,
		Login = 240,
		LoginSuccess = 241,
		Version = 252,
		GameUpdate = 253,
		Disconnect = 254,
		KeepAlive = byte.MaxValue
	}
	public class RpcRequest : SimpleJSONResponse
	{
		public string? method;

		public object?[]? args;

		public RpcTarget? target;

		public RpcRequest()
		{
			type = ResponseType.RpcRequest;
		}
	}
	public class RpcResponse : SimpleJSONRequest
	{
		public object? value;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public bool exception;

		public RpcResponse()
		{
			type = RequestType.RpcResponse;
		}
	}
	[Flags]
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum RpcTarget
	{
		Game = 1,
		Pack = 2,
		Native = 4,
		Client = 8,
		Server = 0x10
	}
	public abstract class SimpleJSONMessage
	{
		public static readonly JsonSerializerSettings JSON_SERIALIZER_SETTINGS = new JsonSerializerSettings
		{
			NullValueHandling = (NullValueHandling)1,
			MissingMemberHandling = (MissingMemberHandling)0,
			Formatting = (Formatting)0
		};

		public static readonly JsonSerializer JSON_SERIALIZER = new JsonSerializer
		{
			NullValueHandling = JSON_SERIALIZER_SETTINGS.NullValueHandling,
			MissingMemberHandling = JSON_SERIALIZER_SETTINGS.MissingMemberHandling,
			Formatting = JSON_SERIALIZER_SETTINGS.Formatting
		};

		private static int _next_id = 0;

		public static uint NextID
		{
			get
			{
				uint result;
				while ((result = (uint)Interlocked.Increment(ref _next_id)) == 0)
				{
				}
				return result;
			}
		}

		public abstract uint ID { get; }

		public abstract bool IsKeepAlive { get; }

		public string Serialize()
		{
			return JsonConvert.SerializeObject((object)this, JSON_SERIALIZER_SETTINGS);
		}
	}
	public class SimpleJSONRequest : SimpleJSONMessage
	{
		public uint id = SimpleJSONMessage.NextID;

		public RequestType type;

		[JsonIgnore]
		public override uint ID => id;

		[JsonIgnore]
		public override bool IsKeepAlive => type == RequestType.KeepAlive;

		public static bool TryParse(string json, out SimpleJSONRequest? request)
		{
			return TryParse(JObject.Parse(json), out request);
		}

		public static bool TryParse(JObject j, out SimpleJSONRequest? request)
		{
			try
			{
				JToken value = j.GetValue("type");
				switch ((value != null) ? ((RequestType)(object)CamelCaseStringEnumConverter.ReadJToken(value, typeof(RequestType))) : RequestType.EffectTest)
				{
				case RequestType.EffectTest:
				case RequestType.EffectStart:
					request = ((JToken)j).ToObject<EffectRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.EffectStop:
					request = ((JToken)j).ToObject<EffectRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.DataRequest:
					request = ((JToken)j).ToObject<DataRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.RpcResponse:
					request = ((JToken)j).ToObject<RpcResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.PlayerInfo:
					request = ((JToken)j).ToObject<PlayerInfo>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.Login:
					request = ((JToken)j).ToObject<MessageRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.Version:
					request = ((JToken)j).ToObject<EmptyRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.GameUpdate:
					request = ((JToken)j).ToObject<EmptyRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.KeepAlive:
					request = ((JToken)j).ToObject<EmptyRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				}
			}
			catch
			{
			}
			request = null;
			return false;
		}
	}
	public class SimpleJSONResponse : SimpleJSONMessage
	{
		public uint id;

		public ResponseType type;

		[JsonIgnore]
		public override uint ID => id;

		[JsonIgnore]
		public override bool IsKeepAlive => type == ResponseType.KeepAlive;

		[JsonIgnore]
		public static SimpleJSONResponse KeepAlive { get; } = new EmptyResponse
		{
			type = ResponseType.KeepAlive
		};

		public static bool TryParse(string json, out SimpleJSONResponse? response)
		{
			return TryParse(JObject.Parse(json), out response);
		}

		public static bool TryParse(JObject j, out SimpleJSONResponse? response)
		{
			try
			{
				JToken value = j.GetValue("type");
				ResponseType responseType = ((value != null) ? ((ResponseType)(object)CamelCaseStringEnumConverter.ReadJToken(value, typeof(ResponseType))) : ResponseType.EffectRequest);
				switch (responseType)
				{
				case ResponseType.EffectStatus:
					if (responseType != ResponseType.EffectStatus)
					{
						break;
					}
					response = ((JToken)j).ToObject<EffectUpdate>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.EffectRequest:
					response = ((JToken)j).ToObject<EffectResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.RpcRequest:
					response = ((JToken)j).ToObject<RpcRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.GenericEvent:
					response = ((JToken)j).ToObject<GenericEventResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.DataResponse:
					response = ((JToken)j).ToObject<DataResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.Login:
					response = ((JToken)j).ToObject<EmptyResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.LoginSuccess:
					response = ((JToken)j).ToObject<EmptyResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.Version:
					response = ((JToken)j).ToObject<VersionResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.GameUpdate:
					response = ((JToken)j).ToObject<GameUpdate>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.Disconnect:
					response = ((JToken)j).ToObject<MessageResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.KeepAlive:
					response = ((JToken)j).ToObject<EmptyResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				}
			}
			catch
			{
			}
			response = null;
			return false;
		}
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum StandardErrors
	{
		Unknown = 0,
		ExceptionThrown = 1,
		BadRequest = 4096,
		EffectUnknown = 4097,
		[Obsolete("Use EffectUnknown instead.")]
		UnknownEffect = 4097,
		EffectDisabled = 4098,
		AlreadyFailed = 4099,
		CannotParseNumber = 4112,
		UnknownSelection = 4113,
		ConnectorError = 8192,
		ConnectorReadFailure = 8193,
		ConnectorWriteFailure = 8194,
		ConnectorNotConnected = 8195,
		ConnectorNotSupported = 8196,
		NoResponse = 8448,
		SettingsError = 12288,
		CooldownPerEffect = 12545,
		CooldownGlobal = 12546,
		RetryMaxTime = 12291,
		RetryMaxAttempts = 12292,
		NoSession = 20480,
		SessionEnding = 20481,
		BadGameState = 16384,
		GameObjectNotFound = 16640,
		PlayerNotFound = 16641,
		CharacterNotFound = 16642,
		EnemyNotFound = 16643,
		ObjectNotFound = 16644,
		PrerequisiteNotFound = 16645,
		ObjectStateError = 16896,
		AlreadyInState = 16897,
		AlreadyAcquired = 16898,
		AlreadyFinished = 16899,
		NoEmptyContainers = 16912,
		PartyFull = 16913,
		InvalidArea = 16928,
		InvalidTarget = 16929,
		NoValidTargets = 16930,
		SpawnNotAllowedHere = 16932,
		RangeError = 17152,
		AlreadyMinimum = 17153,
		AlreadyMaximum = 17154,
		EffectNotImplemented = 24576,
		PackResourceMissing = 24577,
		EmulatorNotSupported = 28672,
		EmulatorInvalidSetting = 28673,
		ConflictingEffectRunning = 32768,
		UnqueueablePending = 32769
	}
	internal static class StringEx
	{
		public static bool IsNullOrWhiteSpace(this string? input)
		{
			if (input == null)
			{
				return true;
			}
			for (int i = 0; i < input.Length; i = checked(i + 1))
			{
				if (!char.IsWhiteSpace(input[i]))
				{
					return false;
				}
			}
			return true;
		}

		internal static string ToCamelCase(this string input)
		{
			bool flag = false;
			string text = "";
			checked
			{
				for (int i = 0; i < input.Length; i++)
				{
					if (char.IsUpper(input[i]))
					{
						if (flag)
						{
							text += input.Substring(i);
							break;
						}
						text += char.ToLower(input[i]);
					}
					else
					{
						flag = true;
						text = ((i <= 1 || !char.IsUpper(input[i - 1]) || !char.IsUpper(input[i - 2])) ? (text + input[i]) : (text.Substring(0, text.Length - 1) + char.ToUpper(input[i - 1]) + input[i]));
					}
				}
				return text;
			}
		}

		internal unsafe static string[] Chop(this string value, int chopLength)
		{
			int length = value.Length;
			char* ptr = stackalloc char[chopLength];
			string[] array = new string[length];
			for (int i = 0; i < length; i = checked(i + chopLength))
			{
				int j;
				for (j = 0; j < chopLength; j = checked(j + 1))
				{
					int num = checked(i + j);
					if (num >= length)
					{
						break;
					}
					*(char*)((byte*)ptr + checked(unchecked((nint)j) * (nint)2)) = value[num];
				}
				array[i / chopLength] = new string(ptr, 0, j);
			}
			return array;
		}
	}
	public static class TypeEx
	{
		public static bool IsAssignableTo(this Type? type, Type? targetType)
		{
			if ((object)type != null && (object)targetType != null)
			{
				return targetType.IsAssignableFrom(type);
			}
			return false;
		}
	}
	[Serializable]
	[JsonConverter(typeof(Converter))]
	public class VersionNumber : IEquatable<VersionNumber>, IComparable<VersionNumber>
	{
		private class Converter : JsonConverter<VersionNumber>
		{
			public override void WriteJson(JsonWriter writer, VersionNumber? value, JsonSerializer serializer)
			{
				if (value == null)
				{
					writer.WriteNull();
				}
				else
				{
					writer.WriteValue((string)value);
				}
			}

			public override VersionNumber? ReadJson(JsonReader reader, Type objectType, VersionNumber? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				object value = reader.Value;
				if (value == null)
				{
					return null;
				}
				if (!(value is string value2))
				{
					return null;
				}
				return new VersionNumber(value2);
			}
		}

		public static readonly VersionNumber Zero = new VersionNumber(default(uint));

		public static readonly VersionNumber One = new VersionNumber(1u);

		private readonly uint[] _version;

		public VersionNumber(string value)
		{
			_version = (from v in value.Split(new char[1] { '.' })
				select uint.TryParse(Sanitize(v), out var result) ? result : 0u).ToArray();
		}

		public VersionNumber(IEnumerable<uint> values)
		{
			_version = values.ToArray();
		}

		public VersionNumber(VersionNumber version)
		{
			_version = version._version.ToArray();
		}

		public VersionNumber(params uint[] values)
		{
			_version = values.ToArray();
		}

		public static implicit operator VersionNumber(string value)
		{
			return new VersionNumber(value);
		}

		public static implicit operator VersionNumber(uint value)
		{
			return new VersionNumber(value);
		}

		public static implicit operator VersionNumber(uint[] values)
		{
			return new VersionNumber(values);
		}

		public static implicit operator VersionNumber(List<uint> values)
		{
			return new VersionNumber((IEnumerable<uint>)values);
		}

		public static implicit operator string(VersionNumber value)
		{
			return value.ToString();
		}

		public static implicit operator uint[](VersionNumber value)
		{
			return value._version.ToArray();
		}

		public static bool operator ==(VersionNumber? a, VersionNumber? b)
		{
			return Equals(a, b);
		}

		public static bool operator !=(VersionNumber? a, VersionNumber? b)
		{
			return !Equals(a, b);
		}

		public static bool operator <(VersionNumber? a, VersionNumber? b)
		{
			return CompareTo(a, b) < 0;
		}

		public static bool operator >(VersionNumber? a, VersionNumber? b)
		{
			return CompareTo(a, b) > 0;
		}

		public static bool operator <=(VersionNumber? a, VersionNumber? b)
		{
			return CompareTo(a, b) <= 0;
		}

		public static bool operator >=(VersionNumber? a, VersionNumber? b)
		{
			return CompareTo(a, b) >= 0;
		}

		public override string ToString()
		{
			return string.Join(".", _version.Select((uint v) => v.ToString("D")).ToArray());
		}

		public static bool Equals(VersionNumber? a, VersionNumber? b)
		{
			return a?.Equals(b) ?? ((object)b == null);
		}

		public override bool Equals(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (TypeEx.IsAssignableTo(obj.GetType(), typeof(VersionNumber)))
			{
				return false;
			}
			return Equals((VersionNumber)obj);
		}

		public override int GetHashCode()
		{
			return _version.GetHashCode();
		}

		public bool Equals(VersionNumber? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			int num = _version.Length;
			if (num != other._version.Length)
			{
				return false;
			}
			for (int i = 0; i < num; i = checked(i + 1))
			{
				if (_version[i] != other._version[i])
				{
					return false;
				}
			}
			return true;
		}

		public static int CompareTo(VersionNumber? a, VersionNumber? b)
		{
			if ((object)a == null)
			{
				if ((object)b != null)
				{
					return -1;
				}
				return 0;
			}
			return a.CompareTo(b);
		}

		public int CompareTo(VersionNumber? other)
		{
			if ((object)other == null)
			{
				return 1;
			}
			int num = _version.Length;
			int num2 = other._version.Length;
			int num3 = Math.Min(num, num2);
			checked
			{
				int i;
				for (i = 0; i < num3; i++)
				{
					uint num4 = _version[i];
					uint num5 = other._version[i];
					if (num4 != num5)
					{
						if (num4 > num5)
						{
							return 1;
						}
						return -1;
					}
				}
				if (num == num2)
				{
					return 0;
				}
				if (num > num2)
				{
					for (; i < num; i++)
					{
						if (_version[i] != 0)
						{
							return 1;
						}
					}
					return 0;
				}
				for (; i < num2; i++)
				{
					if (other._version[i] != 0)
					{
						return -1;
					}
				}
				return 0;
			}
		}

		private static string Sanitize(string value)
		{
			for (int i = 0; i < value.Length; i = checked(i + 1))
			{
				if (!char.IsDigit(value[i]))
				{
					return value.Substring(0, i);
				}
			}
			return value;
		}
	}
	public class VersionResponse : SimpleJSONResponse
	{
		public VersionNumber version;

		[JsonConstructor]
		public VersionResponse(VersionNumber version)
		{
			this.version = version;
			type = ResponseType.Version;
		}

		public VersionResponse(uint id, VersionNumber version)
		{
			base.id = id;
			this.version = version;
			type = ResponseType.Version;
		}
	}
}