#define UNITY_EDITOR
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Cysharp.Threading.Tasks.CompilerServices;
using Cysharp.Threading.Tasks.Internal;
using Cysharp.Threading.Tasks.Triggers;
using Microsoft.CodeAnalysis;
using Unity.Jobs;
using UnityEditor;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.LowLevel;
using UnityEngine.Networking;
using UnityEngine.ParticleSystemJobs;
using UnityEngine.PlayerLoop;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("UniTask.Linq")]
[assembly: InternalsVisibleTo("UniTask.Addressables")]
[assembly: InternalsVisibleTo("UniTask.DOTween")]
[assembly: InternalsVisibleTo("UniTask.TextMeshPro")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	internal sealed class AsyncMethodBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public AsyncMethodBuilderAttribute(Type builderType)
		{
			BuilderType = builderType;
		}
	}
}
namespace Cysharp.Threading.Tasks
{
	public class AsyncLazy
	{
		private static Action<object> continuation = SetCompletionSource;

		private Func<UniTask> taskFactory;

		private UniTaskCompletionSource completionSource;

		private UniTask.Awaiter awaiter;

		private object syncLock;

		private bool initialized;

		public UniTask Task
		{
			get
			{
				EnsureInitialized();
				return completionSource.Task;
			}
		}

		public AsyncLazy(Func<UniTask> taskFactory)
		{
			this.taskFactory = taskFactory;
			completionSource = new UniTaskCompletionSource();
			syncLock = new object();
			initialized = false;
		}

		internal AsyncLazy(UniTask task)
		{
			taskFactory = null;
			completionSource = new UniTaskCompletionSource();
			syncLock = null;
			initialized = true;
			UniTask.Awaiter awaiter = task.GetAwaiter();
			if (awaiter.IsCompleted)
			{
				SetCompletionSource(in awaiter);
				return;
			}
			this.awaiter = awaiter;
			awaiter.SourceOnCompleted(continuation, this);
		}

		public UniTask.Awaiter GetAwaiter()
		{
			return Task.GetAwaiter();
		}

		private void EnsureInitialized()
		{
			if (!Volatile.Read(ref initialized))
			{
				EnsureInitializedCore();
			}
		}

		private void EnsureInitializedCore()
		{
			lock (syncLock)
			{
				if (Volatile.Read(ref initialized))
				{
					return;
				}
				Func<UniTask> func = Interlocked.Exchange(ref taskFactory, null);
				if (func != null)
				{
					UniTask.Awaiter awaiter = func().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						SetCompletionSource(in awaiter);
					}
					else
					{
						this.awaiter = awaiter;
						awaiter.SourceOnCompleted(continuation, this);
					}
					Volatile.Write(ref initialized, value: true);
				}
			}
		}

		private void SetCompletionSource(in UniTask.Awaiter awaiter)
		{
			try
			{
				awaiter.GetResult();
				completionSource.TrySetResult();
			}
			catch (Exception exception)
			{
				completionSource.TrySetException(exception);
			}
		}

		private static void SetCompletionSource(object state)
		{
			AsyncLazy asyncLazy = (AsyncLazy)state;
			try
			{
				asyncLazy.awaiter.GetResult();
				asyncLazy.completionSource.TrySetResult();
			}
			catch (Exception exception)
			{
				asyncLazy.completionSource.TrySetException(exception);
			}
			finally
			{
				asyncLazy.awaiter = default(UniTask.Awaiter);
			}
		}
	}
	public class AsyncLazy<T>
	{
		private static Action<object> continuation = SetCompletionSource;

		private Func<UniTask<T>> taskFactory;

		private UniTaskCompletionSource<T> completionSource;

		private UniTask<T>.Awaiter awaiter;

		private object syncLock;

		private bool initialized;

		public UniTask<T> Task
		{
			get
			{
				EnsureInitialized();
				return completionSource.Task;
			}
		}

		public AsyncLazy(Func<UniTask<T>> taskFactory)
		{
			this.taskFactory = taskFactory;
			completionSource = new UniTaskCompletionSource<T>();
			syncLock = new object();
			initialized = false;
		}

		internal AsyncLazy(UniTask<T> task)
		{
			taskFactory = null;
			completionSource = new UniTaskCompletionSource<T>();
			syncLock = null;
			initialized = true;
			UniTask<T>.Awaiter awaiter = task.GetAwaiter();
			if (awaiter.IsCompleted)
			{
				SetCompletionSource(in awaiter);
				return;
			}
			this.awaiter = awaiter;
			awaiter.SourceOnCompleted(continuation, this);
		}

		public UniTask<T>.Awaiter GetAwaiter()
		{
			return Task.GetAwaiter();
		}

		private void EnsureInitialized()
		{
			if (!Volatile.Read(ref initialized))
			{
				EnsureInitializedCore();
			}
		}

		private void EnsureInitializedCore()
		{
			lock (syncLock)
			{
				if (Volatile.Read(ref initialized))
				{
					return;
				}
				Func<UniTask<T>> func = Interlocked.Exchange(ref taskFactory, null);
				if (func != null)
				{
					UniTask<T>.Awaiter awaiter = func().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						SetCompletionSource(in awaiter);
					}
					else
					{
						this.awaiter = awaiter;
						awaiter.SourceOnCompleted(continuation, this);
					}
					Volatile.Write(ref initialized, value: true);
				}
			}
		}

		private void SetCompletionSource(in UniTask<T>.Awaiter awaiter)
		{
			try
			{
				T result = awaiter.GetResult();
				completionSource.TrySetResult(result);
			}
			catch (Exception exception)
			{
				completionSource.TrySetException(exception);
			}
		}

		private static void SetCompletionSource(object state)
		{
			AsyncLazy<T> asyncLazy = (AsyncLazy<T>)state;
			try
			{
				T result = asyncLazy.awaiter.GetResult();
				asyncLazy.completionSource.TrySetResult(result);
			}
			catch (Exception exception)
			{
				asyncLazy.completionSource.TrySetException(exception);
			}
			finally
			{
				asyncLazy.awaiter = default(UniTask<T>.Awaiter);
			}
		}
	}
	public interface IReadOnlyAsyncReactiveProperty<T> : IUniTaskAsyncEnumerable<T>
	{
		T Value { get; }

		IUniTaskAsyncEnumerable<T> WithoutCurrent();

		UniTask<T> WaitAsync(CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface IAsyncReactiveProperty<T> : IReadOnlyAsyncReactiveProperty<T>, IUniTaskAsyncEnumerable<T>
	{
		new T Value { get; set; }
	}
	[Serializable]
	public class AsyncReactiveProperty<T> : IAsyncReactiveProperty<T>, IReadOnlyAsyncReactiveProperty<T>, IUniTaskAsyncEnumerable<T>, IDisposable
	{
		private sealed class WaitAsyncSource : IUniTaskSource<T>, IUniTaskSource, ITriggerHandler<T>, ITaskPoolNode<WaitAsyncSource>
		{
			private static Action<object> cancellationCallback;

			private static TaskPool<WaitAsyncSource> pool;

			private WaitAsyncSource nextNode;

			private AsyncReactiveProperty<T> parent;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration cancellationTokenRegistration;

			private UniTaskCompletionSourceCore<T> core;

			ref WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode => ref nextNode;

			ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }

			ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }

			static WaitAsyncSource()
			{
				cancellationCallback = CancellationCallback;
				TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size);
			}

			private WaitAsyncSource()
			{
			}

			public static IUniTaskSource<T> Create(AsyncReactiveProperty<T> parent, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<T>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitAsyncSource();
				}
				result.parent = parent;
				result.cancellationToken = cancellationToken;
				if (cancellationToken.CanBeCanceled)
				{
					result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, result);
				}
				result.parent.triggerEvent.Add(result);
				TaskTracker.TrackActiveTask(result, 3);
				token = result.core.Version;
				return result;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				cancellationTokenRegistration.Dispose();
				cancellationTokenRegistration = default(CancellationTokenRegistration);
				parent.triggerEvent.Remove(this);
				parent = null;
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}

			private static void CancellationCallback(object state)
			{
				WaitAsyncSource obj = (WaitAsyncSource)state;
				obj.OnCanceled(obj.cancellationToken);
			}

			public T GetResult(short token)
			{
				try
				{
					return core.GetResult(token);
				}
				finally
				{
					TryReturn();
				}
			}

			void IUniTaskSource.GetResult(short token)
			{
				GetResult(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				core.OnCompleted(continuation, state, token);
			}

			public UniTaskStatus GetStatus(short token)
			{
				return core.GetStatus(token);
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				return core.UnsafeGetStatus();
			}

			public void OnCanceled(CancellationToken cancellationToken)
			{
				core.TrySetCanceled(cancellationToken);
			}

			public void OnCompleted()
			{
				core.TrySetCanceled(CancellationToken.None);
			}

			public void OnError(Exception ex)
			{
				core.TrySetException(ex);
			}

			public void OnNext(T value)
			{
				core.TrySetResult(value);
			}
		}

		private sealed class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
		{
			private readonly AsyncReactiveProperty<T> parent;

			public WithoutCurrentEnumerable(AsyncReactiveProperty<T> parent)
			{
				this.parent = parent;
			}

			public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				return new Enumerator(parent, cancellationToken, publishCurrentValue: false);
			}
		}

		private sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable, ITriggerHandler<T>
		{
			private static Action<object> cancellationCallback = CancellationCallback;

			private readonly AsyncReactiveProperty<T> parent;

			private readonly CancellationToken cancellationToken;

			private readonly CancellationTokenRegistration cancellationTokenRegistration;

			private T value;

			private bool isDisposed;

			private bool firstCall;

			public T Current => value;

			ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }

			ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }

			public Enumerator(AsyncReactiveProperty<T> parent, CancellationToken cancellationToken, bool publishCurrentValue)
			{
				this.parent = parent;
				this.cancellationToken = cancellationToken;
				firstCall = publishCurrentValue;
				parent.triggerEvent.Add(this);
				TaskTracker.TrackActiveTask(this, 3);
				if (cancellationToken.CanBeCanceled)
				{
					cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (firstCall)
				{
					firstCall = false;
					value = parent.Value;
					return CompletedTasks.True;
				}
				completionSource.Reset();
				return new UniTask<bool>(this, completionSource.Version);
			}

			public UniTask DisposeAsync()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					TaskTracker.RemoveTracking(this);
					completionSource.TrySetCanceled(cancellationToken);
					parent.triggerEvent.Remove(this);
				}
				return default(UniTask);
			}

			public void OnNext(T value)
			{
				this.value = value;
				completionSource.TrySetResult(result: true);
			}

			public void OnCanceled(CancellationToken cancellationToken)
			{
				DisposeAsync().Forget();
			}

			public void OnCompleted()
			{
				completionSource.TrySetResult(result: false);
			}

			public void OnError(Exception ex)
			{
				completionSource.TrySetException(ex);
			}

			private static void CancellationCallback(object state)
			{
				((Enumerator)state).DisposeAsync().Forget();
			}
		}

		private TriggerEvent<T> triggerEvent;

		[SerializeField]
		private T latestValue;

		private static bool isValueType;

		public T Value
		{
			get
			{
				return latestValue;
			}
			set
			{
				latestValue = value;
				triggerEvent.SetResult(value);
			}
		}

		public AsyncReactiveProperty(T value)
		{
			latestValue = value;
			triggerEvent = default(TriggerEvent<T>);
		}

		public IUniTaskAsyncEnumerable<T> WithoutCurrent()
		{
			return new WithoutCurrentEnumerable(this);
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken)
		{
			return new Enumerator(this, cancellationToken, publishCurrentValue: true);
		}

		public void Dispose()
		{
			triggerEvent.SetCompleted();
		}

		public static implicit operator T(AsyncReactiveProperty<T> value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			if (isValueType)
			{
				return latestValue.ToString();
			}
			return latestValue?.ToString();
		}

		public UniTask<T> WaitAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			short token;
			return new UniTask<T>(WaitAsyncSource.Create(this, cancellationToken, out token), token);
		}

		static AsyncReactiveProperty()
		{
			isValueType = typeof(T).IsValueType;
		}
	}
	public class ReadOnlyAsyncReactiveProperty<T> : IReadOnlyAsyncReactiveProperty<T>, IUniTaskAsyncEnumerable<T>, IDisposable
	{
		private sealed class WaitAsyncSource : IUniTaskSource<T>, IUniTaskSource, ITriggerHandler<T>, ITaskPoolNode<WaitAsyncSource>
		{
			private static Action<object> cancellationCallback;

			private static TaskPool<WaitAsyncSource> pool;

			private WaitAsyncSource nextNode;

			private ReadOnlyAsyncReactiveProperty<T> parent;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration cancellationTokenRegistration;

			private UniTaskCompletionSourceCore<T> core;

			ref WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode => ref nextNode;

			ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }

			ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }

			static WaitAsyncSource()
			{
				cancellationCallback = CancellationCallback;
				TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size);
			}

			private WaitAsyncSource()
			{
			}

			public static IUniTaskSource<T> Create(ReadOnlyAsyncReactiveProperty<T> parent, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<T>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitAsyncSource();
				}
				result.parent = parent;
				result.cancellationToken = cancellationToken;
				if (cancellationToken.CanBeCanceled)
				{
					result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, result);
				}
				result.parent.triggerEvent.Add(result);
				TaskTracker.TrackActiveTask(result, 3);
				token = result.core.Version;
				return result;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				cancellationTokenRegistration.Dispose();
				cancellationTokenRegistration = default(CancellationTokenRegistration);
				parent.triggerEvent.Remove(this);
				parent = null;
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}

			private static void CancellationCallback(object state)
			{
				WaitAsyncSource obj = (WaitAsyncSource)state;
				obj.OnCanceled(obj.cancellationToken);
			}

			public T GetResult(short token)
			{
				try
				{
					return core.GetResult(token);
				}
				finally
				{
					TryReturn();
				}
			}

			void IUniTaskSource.GetResult(short token)
			{
				GetResult(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				core.OnCompleted(continuation, state, token);
			}

			public UniTaskStatus GetStatus(short token)
			{
				return core.GetStatus(token);
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				return core.UnsafeGetStatus();
			}

			public void OnCanceled(CancellationToken cancellationToken)
			{
				core.TrySetCanceled(cancellationToken);
			}

			public void OnCompleted()
			{
				core.TrySetCanceled(CancellationToken.None);
			}

			public void OnError(Exception ex)
			{
				core.TrySetException(ex);
			}

			public void OnNext(T value)
			{
				core.TrySetResult(value);
			}
		}

		private sealed class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
		{
			private readonly ReadOnlyAsyncReactiveProperty<T> parent;

			public WithoutCurrentEnumerable(ReadOnlyAsyncReactiveProperty<T> parent)
			{
				this.parent = parent;
			}

			public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				return new Enumerator(parent, cancellationToken, publishCurrentValue: false);
			}
		}

		private sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable, ITriggerHandler<T>
		{
			private static Action<object> cancellationCallback = CancellationCallback;

			private readonly ReadOnlyAsyncReactiveProperty<T> parent;

			private readonly CancellationToken cancellationToken;

			private readonly CancellationTokenRegistration cancellationTokenRegistration;

			private T value;

			private bool isDisposed;

			private bool firstCall;

			public T Current => value;

			ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }

			ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }

			public Enumerator(ReadOnlyAsyncReactiveProperty<T> parent, CancellationToken cancellationToken, bool publishCurrentValue)
			{
				this.parent = parent;
				this.cancellationToken = cancellationToken;
				firstCall = publishCurrentValue;
				parent.triggerEvent.Add(this);
				TaskTracker.TrackActiveTask(this, 3);
				if (cancellationToken.CanBeCanceled)
				{
					cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (firstCall)
				{
					firstCall = false;
					value = parent.Value;
					return CompletedTasks.True;
				}
				completionSource.Reset();
				return new UniTask<bool>(this, completionSource.Version);
			}

			public UniTask DisposeAsync()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					TaskTracker.RemoveTracking(this);
					completionSource.TrySetCanceled(cancellationToken);
					parent.triggerEvent.Remove(this);
				}
				return default(UniTask);
			}

			public void OnNext(T value)
			{
				this.value = value;
				completionSource.TrySetResult(result: true);
			}

			public void OnCanceled(CancellationToken cancellationToken)
			{
				DisposeAsync().Forget();
			}

			public void OnCompleted()
			{
				completionSource.TrySetResult(result: false);
			}

			public void OnError(Exception ex)
			{
				completionSource.TrySetException(ex);
			}

			private static void CancellationCallback(object state)
			{
				((Enumerator)state).DisposeAsync().Forget();
			}
		}

		private TriggerEvent<T> triggerEvent;

		private T latestValue;

		private IUniTaskAsyncEnumerator<T> enumerator;

		private static bool isValueType;

		public T Value => latestValue;

		public ReadOnlyAsyncReactiveProperty(T initialValue, IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			latestValue = initialValue;
			ConsumeEnumerator(source, cancellationToken).Forget();
		}

		public ReadOnlyAsyncReactiveProperty(IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			ConsumeEnumerator(source, cancellationToken).Forget();
		}

		private async UniTaskVoid ConsumeEnumerator(IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			enumerator = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await enumerator.MoveNextAsync())
				{
					T result = (latestValue = enumerator.Current);
					triggerEvent.SetResult(result);
				}
			}
			finally
			{
				await enumerator.DisposeAsync();
				enumerator = null;
			}
		}

		public IUniTaskAsyncEnumerable<T> WithoutCurrent()
		{
			return new WithoutCurrentEnumerable(this);
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken)
		{
			return new Enumerator(this, cancellationToken, publishCurrentValue: true);
		}

		public void Dispose()
		{
			if (enumerator != null)
			{
				enumerator.DisposeAsync().Forget();
			}
			triggerEvent.SetCompleted();
		}

		public static implicit operator T(ReadOnlyAsyncReactiveProperty<T> value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			if (isValueType)
			{
				return latestValue.ToString();
			}
			return latestValue?.ToString();
		}

		public UniTask<T> WaitAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			short token;
			return new UniTask<T>(WaitAsyncSource.Create(this, cancellationToken, out token), token);
		}

		static ReadOnlyAsyncReactiveProperty()
		{
			isValueType = typeof(T).IsValueType;
		}
	}
	public static class StateExtensions
	{
		public static ReadOnlyAsyncReactiveProperty<T> ToReadOnlyAsyncReactiveProperty<T>(this IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			return new ReadOnlyAsyncReactiveProperty<T>(source, cancellationToken);
		}

		public static ReadOnlyAsyncReactiveProperty<T> ToReadOnlyAsyncReactiveProperty<T>(this IUniTaskAsyncEnumerable<T> source, T initialValue, CancellationToken cancellationToken)
		{
			return new ReadOnlyAsyncReactiveProperty<T>(initialValue, source, cancellationToken);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public readonly struct AsyncUnit : IEquatable<AsyncUnit>
	{
		public static readonly AsyncUnit Default;

		public override int GetHashCode()
		{
			return 0;
		}

		public bool Equals(AsyncUnit other)
		{
			return true;
		}

		public override string ToString()
		{
			return "()";
		}
	}
	public class CancellationTokenEqualityComparer : IEqualityComparer<CancellationToken>
	{
		public static readonly IEqualityComparer<CancellationToken> Default = new CancellationTokenEqualityComparer();

		public bool Equals(CancellationToken x, CancellationToken y)
		{
			return x.Equals(y);
		}

		public int GetHashCode(CancellationToken obj)
		{
			return obj.GetHashCode();
		}
	}
	public static class CancellationTokenExtensions
	{
		private static readonly Action<object> cancellationTokenCallback = Callback;

		private static readonly Action<object> disposeCallback = DisposeCallback;

		public static CancellationToken ToCancellationToken(this UniTask task)
		{
			CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
			ToCancellationTokenCore(task, cancellationTokenSource).Forget();
			return cancellationTokenSource.Token;
		}

		public static CancellationToken ToCancellationToken(this UniTask task, CancellationToken linkToken)
		{
			if (linkToken.IsCancellationRequested)
			{
				return linkToken;
			}
			if (!linkToken.CanBeCanceled)
			{
				return task.ToCancellationToken();
			}
			CancellationTokenSource cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { linkToken });
			ToCancellationTokenCore(task, cancellationTokenSource).Forget();
			return cancellationTokenSource.Token;
		}

		public static CancellationToken ToCancellationToken<T>(this UniTask<T> task)
		{
			return task.AsUniTask().ToCancellationToken();
		}

		public static CancellationToken ToCancellationToken<T>(this UniTask<T> task, CancellationToken linkToken)
		{
			return task.AsUniTask().ToCancellationToken(linkToken);
		}

		private static async UniTaskVoid ToCancellationTokenCore(UniTask task, CancellationTokenSource cts)
		{
			try
			{
				await task;
			}
			catch (Exception ex)
			{
				UniTaskScheduler.PublishUnobservedTaskException(ex);
			}
			cts.Cancel();
			cts.Dispose();
		}

		public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return (UniTask.FromCanceled(cancellationToken), default(CancellationTokenRegistration));
			}
			UniTaskCompletionSource uniTaskCompletionSource = new UniTaskCompletionSource();
			return (uniTaskCompletionSource.Task, cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, uniTaskCompletionSource));
		}

		private static void Callback(object state)
		{
			((UniTaskCompletionSource)state).TrySetResult();
		}

		public static CancellationTokenAwaitable WaitUntilCanceled(this CancellationToken cancellationToken)
		{
			return new CancellationTokenAwaitable(cancellationToken);
		}

		public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action callback)
		{
			bool flag = false;
			if (!ExecutionContext.IsFlowSuppressed())
			{
				ExecutionContext.SuppressFlow();
				flag = true;
			}
			try
			{
				return cancellationToken.Register(callback, useSynchronizationContext: false);
			}
			finally
			{
				if (flag)
				{
					ExecutionContext.RestoreFlow();
				}
			}
		}

		public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action<object> callback, object state)
		{
			bool flag = false;
			if (!ExecutionContext.IsFlowSuppressed())
			{
				ExecutionContext.SuppressFlow();
				flag = true;
			}
			try
			{
				return cancellationToken.Register(callback, state, useSynchronizationContext: false);
			}
			finally
			{
				if (flag)
				{
					ExecutionContext.RestoreFlow();
				}
			}
		}

		public static CancellationTokenRegistration AddTo(this IDisposable disposable, CancellationToken cancellationToken)
		{
			return cancellationToken.RegisterWithoutCaptureExecutionContext(disposeCallback, disposable);
		}

		private static void DisposeCallback(object state)
		{
			((IDisposable)state).Dispose();
		}
	}
	public struct CancellationTokenAwaitable
	{
		public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private CancellationToken cancellationToken;

			public bool IsCompleted
			{
				get
				{
					if (cancellationToken.CanBeCanceled)
					{
						return cancellationToken.IsCancellationRequested;
					}
					return true;
				}
			}

			public Awaiter(CancellationToken cancellationToken)
			{
				this.cancellationToken = cancellationToken;
			}

			public void GetResult()
			{
			}

			public void OnCompleted(Action continuation)
			{
				UnsafeOnCompleted(continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				cancellationToken.RegisterWithoutCaptureExecutionContext(continuation);
			}
		}

		private CancellationToken cancellationToken;

		public CancellationTokenAwaitable(CancellationToken cancellationToken)
		{
			this.cancellationToken = cancellationToken;
		}

		public Awaiter GetAwaiter()
		{
			return new Awaiter(cancellationToken);
		}
	}
	public static class CancellationTokenSourceExtensions
	{
		private static readonly Action<object> CancelCancellationTokenSourceStateDelegate = CancelCancellationTokenSourceState;

		private static void CancelCancellationTokenSourceState(object state)
		{
			((CancellationTokenSource)state).Cancel();
		}

		public static IDisposable CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
		{
			return cts.CancelAfterSlim(TimeSpan.FromMilliseconds(millisecondsDelay), delayType, delayTiming);
		}

		public static IDisposable CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
		{
			return PlayerLoopTimer.StartNew(delayTimeSpan, periodic: false, delayType, delayTiming, cts.Token, CancelCancellationTokenSourceStateDelegate, cts);
		}

		public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, Component component)
		{
			cts.RegisterRaiseCancelOnDestroy(component.gameObject);
		}

		public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, GameObject gameObject)
		{
			gameObject.GetAsyncDestroyTrigger().CancellationToken.RegisterWithoutCaptureExecutionContext(CancelCancellationTokenSourceStateDelegate, cts);
		}
	}
	public static class Channel
	{
		public static Channel<T> CreateSingleConsumerUnbounded<T>()
		{
			return new SingleConsumerUnboundedChannel<T>();
		}
	}
	public abstract class Channel<TWrite, TRead>
	{
		public ChannelReader<TRead> Reader { get; protected set; }

		public ChannelWriter<TWrite> Writer { get; protected set; }

		public static implicit operator ChannelReader<TRead>(Channel<TWrite, TRead> channel)
		{
			return channel.Reader;
		}

		public static implicit operator ChannelWriter<TWrite>(Channel<TWrite, TRead> channel)
		{
			return channel.Writer;
		}
	}
	public abstract class Channel<T> : Channel<T, T>
	{
	}
	public abstract class ChannelReader<T>
	{
		public abstract UniTask Completion { get; }

		public abstract bool TryRead(out T item);

		public abstract UniTask<bool> WaitToReadAsync(CancellationToken cancellationToken = default(CancellationToken));

		public virtual UniTask<T> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (TryRead(out var item))
			{
				return UniTask.FromResult(item);
			}
			return ReadAsyncCore(cancellationToken);
		}

		private async UniTask<T> ReadAsyncCore(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (await WaitToReadAsync(cancellationToken) && TryRead(out var item))
			{
				return item;
			}
			throw new ChannelClosedException();
		}

		public abstract IUniTaskAsyncEnumerable<T> ReadAllAsync(CancellationToken cancellationToken = default(CancellationToken));
	}
	public abstract class ChannelWriter<T>
	{
		public abstract bool TryWrite(T item);

		public abstract bool TryComplete(Exception error = null);

		public void Complete(Exception error = null)
		{
			if (!TryComplete(error))
			{
				throw new ChannelClosedException();
			}
		}
	}
	public class ChannelClosedException : InvalidOperationException
	{
		public ChannelClosedException()
			: base("Channel is already closed.")
		{
		}

		public ChannelClosedException(string message)
			: base(message)
		{
		}

		public ChannelClosedException(Exception innerException)
			: base("Channel is already closed", innerException)
		{
		}

		public ChannelClosedException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	internal class SingleConsumerUnboundedChannel<T> : Channel<T>
	{
		private sealed class SingleConsumerUnboundedChannelWriter : ChannelWriter<T>
		{
			private readonly SingleConsumerUnboundedChannel<T> parent;

			public SingleConsumerUnboundedChannelWriter(SingleConsumerUnboundedChannel<T> parent)
			{
				this.parent = parent;
			}

			public override bool TryWrite(T item)
			{
				bool isWaiting;
				lock (parent.items)
				{
					if (parent.closed)
					{
						return false;
					}
					parent.items.Enqueue(item);
					isWaiting = parent.readerSource.isWaiting;
				}
				if (isWaiting)
				{
					parent.readerSource.SingalContinuation();
				}
				return true;
			}

			public override bool TryComplete(Exception error = null)
			{
				lock (parent.items)
				{
					if (parent.closed)
					{
						return false;
					}
					parent.closed = true;
					bool isWaiting = parent.readerSource.isWaiting;
					if (parent.items.Count == 0)
					{
						if (error == null)
						{
							if (parent.completedTaskSource != null)
							{
								parent.completedTaskSource.TrySetResult();
							}
							else
							{
								parent.completedTask = UniTask.CompletedTask;
							}
						}
						else if (parent.completedTaskSource != null)
						{
							parent.completedTaskSource.TrySetException(error);
						}
						else
						{
							parent.completedTask = UniTask.FromException(error);
						}
						if (isWaiting)
						{
							parent.readerSource.SingalCompleted(error);
						}
					}
					parent.completionError = error;
				}
				return true;
			}
		}

		private sealed class SingleConsumerUnboundedChannelReader : ChannelReader<T>, IUniTaskSource<bool>, IUniTaskSource
		{
			private sealed class ReadAllAsyncEnumerable : IUniTaskAsyncEnumerable<T>, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
			{
				private readonly Action<object> CancellationCallback1Delegate = CancellationCallback1;

				private readonly Action<object> CancellationCallback2Delegate = CancellationCallback2;

				private readonly SingleConsumerUnboundedChannelReader parent;

				private CancellationToken cancellationToken1;

				private CancellationToken cancellationToken2;

				private CancellationTokenRegistration cancellationTokenRegistration1;

				private CancellationTokenRegistration cancellationTokenRegistration2;

				private T current;

				private bool cacheValue;

				private bool running;

				public T Current
				{
					get
					{
						if (cacheValue)
						{
							return current;
						}
						parent.TryRead(out current);
						return current;
					}
				}

				public ReadAllAsyncEnumerable(SingleConsumerUnboundedChannelReader parent, CancellationToken cancellationToken)
				{
					this.parent = parent;
					cancellationToken1 = cancellationToken;
				}

				public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
				{
					if (running)
					{
						throw new InvalidOperationException("Enumerator is already running, does not allow call GetAsyncEnumerator twice.");
					}
					if (cancellationToken1 != cancellationToken)
					{
						cancellationToken2 = cancellationToken;
					}
					if (cancellationToken1.CanBeCanceled)
					{
						cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancellationCallback1Delegate, this);
					}
					if (cancellationToken2.CanBeCanceled)
					{
						cancellationTokenRegistration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(CancellationCallback2Delegate, this);
					}
					running = true;
					return this;
				}

				public UniTask<bool> MoveNextAsync()
				{
					cacheValue = false;
					return parent.WaitToReadAsync(CancellationToken.None);
				}

				public UniTask DisposeAsync()
				{
					cancellationTokenRegistration1.Dispose();
					cancellationTokenRegistration2.Dispose();
					return default(UniTask);
				}

				private static void CancellationCallback1(object state)
				{
					ReadAllAsyncEnumerable readAllAsyncEnumerable = (ReadAllAsyncEnumerable)state;
					readAllAsyncEnumerable.parent.SingalCancellation(readAllAsyncEnumerable.cancellationToken1);
				}

				private static void CancellationCallback2(object state)
				{
					ReadAllAsyncEnumerable readAllAsyncEnumerable = (ReadAllAsyncEnumerable)state;
					readAllAsyncEnumerable.parent.SingalCancellation(readAllAsyncEnumerable.cancellationToken2);
				}
			}

			private readonly Action<object> CancellationCallbackDelegate = CancellationCallback;

			private readonly SingleConsumerUnboundedChannel<T> parent;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration cancellationTokenRegistration;

			private UniTaskCompletionSourceCore<bool> core;

			internal bool isWaiting;

			public override UniTask Completion
			{
				get
				{
					if (parent.completedTaskSource != null)
					{
						return parent.completedTaskSource.Task;
					}
					if (parent.closed)
					{
						return parent.completedTask;
					}
					parent.completedTaskSource = new UniTaskCompletionSource();
					return parent.completedTaskSource.Task;
				}
			}

			public SingleConsumerUnboundedChannelReader(SingleConsumerUnboundedChannel<T> parent)
			{
				this.parent = parent;
				TaskTracker.TrackActiveTask(this, 4);
			}

			public override bool TryRead(out T item)
			{
				lock (parent.items)
				{
					if (parent.items.Count == 0)
					{
						item = default(T);
						return false;
					}
					item = parent.items.Dequeue();
					if (parent.closed && parent.items.Count == 0)
					{
						if (parent.completionError != null)
						{
							if (parent.completedTaskSource != null)
							{
								parent.completedTaskSource.TrySetException(parent.completionError);
							}
							else
							{
								parent.completedTask = UniTask.FromException(parent.completionError);
							}
						}
						else if (parent.completedTaskSource != null)
						{
							parent.completedTaskSource.TrySetResult();
						}
						else
						{
							parent.completedTask = UniTask.CompletedTask;
						}
					}
				}
				return true;
			}

			public override UniTask<bool> WaitToReadAsync(CancellationToken cancellationToken)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return UniTask.FromCanceled<bool>(cancellationToken);
				}
				lock (parent.items)
				{
					if (parent.items.Count != 0)
					{
						return CompletedTasks.True;
					}
					if (parent.closed)
					{
						if (parent.completionError == null)
						{
							return CompletedTasks.False;
						}
						return UniTask.FromException<bool>(parent.completionError);
					}
					cancellationTokenRegistration.Dispose();
					core.Reset();
					isWaiting = true;
					this.cancellationToken = cancellationToken;
					if (this.cancellationToken.CanBeCanceled)
					{
						cancellationTokenRegistration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(CancellationCallbackDelegate, this);
					}
					return new UniTask<bool>(this, core.Version);
				}
			}

			public void SingalContinuation()
			{
				core.TrySetResult(result: true);
			}

			public void SingalCancellation(CancellationToken cancellationToken)
			{
				TaskTracker.RemoveTracking(this);
				core.TrySetCanceled(cancellationToken);
			}

			public void SingalCompleted(Exception error)
			{
				if (error != null)
				{
					TaskTracker.RemoveTracking(this);
					core.TrySetException(error);
				}
				else
				{
					TaskTracker.RemoveTracking(this);
					core.TrySetResult(result: false);
				}
			}

			public override IUniTaskAsyncEnumerable<T> ReadAllAsync(CancellationToken cancellationToken = default(CancellationToken))
			{
				return new ReadAllAsyncEnumerable(this, cancellationToken);
			}

			bool IUniTaskSource<bool>.GetResult(short token)
			{
				return core.GetResult(token);
			}

			void IUniTaskSource.GetResult(short token)
			{
				core.GetResult(token);
			}

			UniTaskStatus IUniTaskSource.GetStatus(short token)
			{
				return core.GetStatus(token);
			}

			void IUniTaskSource.OnCompleted(Action<object> continuation, object state, short token)
			{
				core.OnCompleted(continuation, state, token);
			}

			UniTaskStatus IUniTaskSource.UnsafeGetStatus()
			{
				return core.UnsafeGetStatus();
			}

			private static void CancellationCallback(object state)
			{
				SingleConsumerUnboundedChannelReader obj = (SingleConsumerUnboundedChannelReader)state;
				obj.SingalCancellation(obj.cancellationToken);
			}
		}

		private readonly Queue<T> items;

		private readonly SingleConsumerUnboundedChannelReader readerSource;

		private UniTaskCompletionSource completedTaskSource;

		private UniTask completedTask;

		private Exception completionError;

		private bool closed;

		public SingleConsumerUnboundedChannel()
		{
			items = new Queue<T>();
			base.Writer = new SingleConsumerUnboundedChannelWriter(this);
			readerSource = new SingleConsumerUnboundedChannelReader(this);
			base.Reader = readerSource;
		}
	}
	public static class EnumerableAsyncExtensions
	{
		public static IEnumerable<UniTask> Select<T>(this IEnumerable<T> source, Func<T, UniTask> selector)
		{
			return Enumerable.Select(source, selector);
		}

		public static IEnumerable<UniTask<TR>> Select<T, TR>(this IEnumerable<T> source, Func<T, UniTask<TR>> selector)
		{
			return Enumerable.Select(source, selector);
		}

		public static IEnumerable<UniTask> Select<T>(this IEnumerable<T> source, Func<T, int, UniTask> selector)
		{
			return Enumerable.Select(source, selector);
		}

		public static IEnumerable<UniTask<TR>> Select<T, TR>(this IEnumerable<T> source, Func<T, int, UniTask<TR>> selector)
		{
			return Enumerable.Select(source, selector);
		}
	}
	public static class EnumeratorAsyncExtensions
	{
		private sealed class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<EnumeratorPromise>
		{
			private static TaskPool<EnumeratorPromise> pool;

			private EnumeratorPromise nextNode;

			private IEnumerator innerEnumerator;

			private CancellationToken cancellationToken;

			private int initialFrame;

			private bool loopRunning;

			private bool calledGetResult;

			private UniTaskCompletionSourceCore<object> core;

			private static readonly FieldInfo waitForSeconds_Seconds;

			public ref EnumeratorPromise NextNode => ref nextNode;

			static EnumeratorPromise()
			{
				waitForSeconds_Seconds = typeof(WaitForSeconds).GetField("m_Seconds", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField);
				TaskPool.RegisterSizeGetter(typeof(EnumeratorPromise), () => pool.Size);
			}

			private EnumeratorPromise()
			{
			}

			public static IUniTaskSource Create(IEnumerator innerEnumerator, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new EnumeratorPromise();
				}
				TaskTracker.TrackActiveTask(result, 3);
				result.innerEnumerator = ConsumeEnumerator(innerEnumerator);
				result.cancellationToken = cancellationToken;
				result.loopRunning = true;
				result.calledGetResult = false;
				result.initialFrame = -1;
				token = result.core.Version;
				if (result.MoveNext())
				{
					PlayerLoopHelper.AddAction(timing, result);
				}
				return result;
			}

			public void GetResult(short token)
			{
				try
				{
					calledGetResult = true;
					core.GetResult(token);
				}
				finally
				{
					if (!loopRunning)
					{
						TryReturn();
					}
				}
			}

			public UniTaskStatus GetStatus(short token)
			{
				return core.GetStatus(token);
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				return core.UnsafeGetStatus();
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				core.OnCompleted(continuation, state, token);
			}

			public bool MoveNext()
			{
				if (calledGetResult)
				{
					loopRunning = false;
					TryReturn();
					return false;
				}
				if (innerEnumerator == null)
				{
					return false;
				}
				if (cancellationToken.IsCancellationRequested)
				{
					loopRunning = false;
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				if (initialFrame == -1)
				{
					if (PlayerLoopHelper.IsMainThread)
					{
						initialFrame = Time.frameCount;
					}
				}
				else if (initialFrame == Time.frameCount)
				{
					return true;
				}
				try
				{
					if (innerEnumerator.MoveNext())
					{
						return true;
					}
				}
				catch (Exception error)
				{
					loopRunning = false;
					core.TrySetException(error);
					return false;
				}
				loopRunning = false;
				core.TrySetResult(null);
				return false;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				innerEnumerator = null;
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}

			private static IEnumerator ConsumeEnumerator(IEnumerator enumerator)
			{
				while (enumerator.MoveNext())
				{
					object current = enumerator.Current;
					if (current == null)
					{
						yield return null;
						continue;
					}
					CustomYieldInstruction cyi = (CustomYieldInstruction)((current is CustomYieldInstruction) ? current : null);
					if (cyi != null)
					{
						while (cyi.keepWaiting)
						{
							yield return null;
						}
						continue;
					}
					if (current is YieldInstruction)
					{
						IEnumerator innerCoroutine2 = null;
						AsyncOperation val = (AsyncOperation)((current is AsyncOperation) ? current : null);
						if (val == null)
						{
							WaitForSeconds val2 = (WaitForSeconds)((current is WaitForSeconds) ? current : null);
							if (val2 != null)
							{
								innerCoroutine2 = UnwrapWaitForSeconds(val2);
							}
						}
						else
						{
							innerCoroutine2 = UnwrapWaitAsyncOperation(val);
						}
						if (innerCoroutine2 != null)
						{
							while (innerCoroutine2.MoveNext())
							{
								yield return null;
							}
							continue;
						}
					}
					else if (current is IEnumerator enumerator2)
					{
						IEnumerator innerCoroutine2 = ConsumeEnumerator(enumerator2);
						while (innerCoroutine2.MoveNext())
						{
							yield return null;
						}
						continue;
					}
					Debug.LogWarning((object)("yield " + current.GetType().Name + " is not supported on await IEnumerator or IEnumerator.ToUniTask(), please use ToUniTask(MonoBehaviour coroutineRunner) instead."));
					yield return null;
				}
			}

			private static IEnumerator UnwrapWaitForSeconds(WaitForSeconds waitForSeconds)
			{
				float second = (float)waitForSeconds_Seconds.GetValue(waitForSeconds);
				float elapsed = 0f;
				do
				{
					yield return null;
					elapsed += Time.deltaTime;
				}
				while (!(elapsed >= second));
			}

			private static IEnumerator UnwrapWaitAsyncOperation(AsyncOperation asyncOperation)
			{
				while (!asyncOperation.isDone)
				{
					yield return null;
				}
			}
		}

		public static UniTask.Awaiter GetAwaiter<T>(this T enumerator) where T : IEnumerator
		{
			object obj = enumerator;
			Error.ThrowArgumentNullException((IEnumerator)obj, "enumerator");
			short token;
			return new UniTask(EnumeratorPromise.Create((IEnumerator)obj, PlayerLoopTiming.Update, CancellationToken.None, out token), token).GetAwaiter();
		}

		public static UniTask WithCancellation(this IEnumerator enumerator, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(enumerator, "enumerator");
			short token;
			return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, cancellationToken, out token), token);
		}

		public static UniTask ToUniTask(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(enumerator, "enumerator");
			short token;
			return new UniTask(EnumeratorPromise.Create(enumerator, timing, cancellationToken, out token), token);
		}

		public static UniTask ToUniTask(this IEnumerator enumerator, MonoBehaviour coroutineRunner)
		{
			AutoResetUniTaskCompletionSource autoResetUniTaskCompletionSource = AutoResetUniTaskCompletionSource.Create();
			coroutineRunner.StartCoroutine(Core(enumerator, coroutineRunner, autoResetUniTaskCompletionSource));
			return autoResetUniTaskCompletionSource.Task;
		}

		private static IEnumerator Core(IEnumerator inner, MonoBehaviour coroutineRunner, AutoResetUniTaskCompletionSource source)
		{
			yield return coroutineRunner.StartCoroutine(inner);
			source.TrySetResult();
		}
	}
	public static class ExceptionExtensions
	{
		public static bool IsOperationCanceledException(this Exception exception)
		{
			return exception is OperationCanceledException;
		}
	}
	public interface IUniTaskAsyncEnumerable<out T>
	{
		IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface IUniTaskAsyncEnumerator<out T> : IUniTaskAsyncDisposable
	{
		T Current { get; }

		UniTask<bool> MoveNextAsync();
	}
	public interface IUniTaskAsyncDisposable
	{
		UniTask DisposeAsync();
	}
	public interface IUniTaskOrderedAsyncEnumerable<TElement> : IUniTaskAsyncEnumerable<TElement>
	{
		IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);

		IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending);

		IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending);
	}
	public interface IConnectableUniTaskAsyncEnumerable<out T> : IUniTaskAsyncEnumerable<T>
	{
		IDisposable Connect();
	}
	public static class UniTaskAsyncEnumerableExtensions
	{
		public static UniTaskCancelableAsyncEnumerable<T> WithCancellation<T>(this IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			return new UniTaskCancelableAsyncEnumerable<T>(source, cancellationToken);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct UniTaskCancelableAsyncEnumerable<T>
	{
		[StructLayout(LayoutKind.Auto)]
		public readonly struct Enumerator
		{
			private readonly IUniTaskAsyncEnumerator<T> enumerator;

			public T Current => enumerator.Current;

			internal Enumerator(IUniTaskAsyncEnumerator<T> enumerator)
			{
				this.enumerator = enumerator;
			}

			public UniTask<bool> MoveNextAsync()
			{
				return enumerator.MoveNextAsync();
			}

			public UniTask DisposeAsync()
			{
				return enumerator.DisposeAsync();
			}
		}

		private readonly IUniTaskAsyncEnumerable<T> enumerable;

		private readonly CancellationToken cancellationToken;

		internal UniTaskCancelableAsyncEnumerable(IUniTaskAsyncEnumerable<T> enumerable, CancellationToken cancellationToken)
		{
			this.enumerable = enumerable;
			this.cancellationToken = cancellationToken;
		}

		public Enumerator GetAsyncEnumerator()
		{
			return new Enumerator(enumerable.GetAsyncEnumerator(cancellationToken));
		}
	}
	public enum UniTaskStatus
	{
		Pending,
		Succeeded,
		Faulted,
		Canceled
	}
	public interface IUniTaskSource
	{
		UniTaskStatus GetStatus(short token);

		void OnCompleted(Action<object> continuation, object state, short token);

		void GetResult(short token);

		UniTaskStatus UnsafeGetStatus();
	}
	public interface IUniTaskSource<out T> : IUniTaskSource
	{
		new T GetResult(short token);
	}
	public static class UniTaskStatusExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCompleted(this UniTaskStatus status)
		{
			return status != UniTaskStatus.Pending;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCompletedSuccessfully(this UniTaskStatus status)
		{
			return status == UniTaskStatus.Succeeded;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCanceled(this UniTaskStatus status)
		{
			return status == UniTaskStatus.Canceled;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsFaulted(this UniTaskStatus status)
		{
			return status == UniTaskStatus.Faulted;
		}
	}
	public static class TaskTracker
	{
		public static class EditorEnableState
		{
			private static bool enableAutoReload;

			private static bool enableTracking;

			private static bool enableStackTrace;

			public static bool EnableAutoReload
			{
				get
				{
					return enableAutoReload;
				}
				set
				{
					enableAutoReload = value;
					EditorPrefs.SetBool("UniTaskTrackerWindow_EnableAutoReloadKey", value);
				}
			}

			public static bool EnableTracking
			{
				get
				{
					return enableTracking;
				}
				set
				{
					enableTracking = value;
					EditorPrefs.SetBool("UniTaskTrackerWindow_EnableTrackingKey", value);
				}
			}

			public static bool EnableStackTrace
			{
				get
				{
					return enableStackTrace;
				}
				set
				{
					enableStackTrace = value;
					EditorPrefs.SetBool("UniTaskTrackerWindow_EnableStackTraceKey", value);
				}
			}
		}

		private static int trackingId = 0;

		public const string EnableAutoReloadKey = "UniTaskTrackerWindow_EnableAutoReloadKey";

		public const string EnableTrackingKey = "UniTaskTrackerWindow_EnableTrackingKey";

		public const string EnableStackTraceKey = "UniTaskTrackerWindow_EnableStackTraceKey";

		private static List<KeyValuePair<IUniTaskSource, (string formattedType, int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IUniTaskSource, (string, int, DateTime, string)>>();

		private static readonly WeakDictionary<IUniTaskSource, (string formattedType, int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IUniTaskSource, (string, int, DateTime, string)>();

		private static bool dirty;

		[Conditional("UNITY_EDITOR")]
		public static void TrackActiveTask(IUniTaskSource task, int skipFrame)
		{
			dirty = true;
			if (EditorEnableState.EnableTracking)
			{
				string item = (EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame, fNeedFileInfo: true).CleanupAsyncStackTrace() : "");
				string item2;
				if (EditorEnableState.EnableStackTrace)
				{
					StringBuilder stringBuilder = new StringBuilder();
					TypeBeautify(task.GetType(), stringBuilder);
					item2 = stringBuilder.ToString();
				}
				else
				{
					item2 = task.GetType().Name;
				}
				tracking.TryAdd(task, (item2, Interlocked.Increment(ref trackingId), DateTime.UtcNow, item));
			}
		}

		[Conditional("UNITY_EDITOR")]
		public static void RemoveTracking(IUniTaskSource task)
		{
			dirty = true;
			if (EditorEnableState.EnableTracking)
			{
				tracking.TryRemove(task);
			}
		}

		public static bool CheckAndResetDirty()
		{
			bool result = dirty;
			dirty = false;
			return result;
		}

		public static void ForEachActiveTask(Action<int, string, UniTaskStatus, DateTime, string> action)
		{
			lock (listPool)
			{
				int num = tracking.ToList(ref listPool, clear: false);
				try
				{
					for (int i = 0; i < num; i++)
					{
						action(listPool[i].Value.trackingId, listPool[i].Value.formattedType, listPool[i].Key.UnsafeGetStatus(), listPool[i].Value.addTime, listPool[i].Value.stackTrace);
						listPool[i] = default(KeyValuePair<IUniTaskSource, (string, int, DateTime, string)>);
					}
				}
				catch
				{
					listPool.Clear();
					throw;
				}
			}
		}

		private static void TypeBeautify(Type type, StringBuilder sb)
		{
			if (type.IsNested)
			{
				sb.Append(type.DeclaringType.Name.ToString());
				sb.Append(".");
			}
			if (type.IsGenericType)
			{
				int num = type.Name.IndexOf("`");
				if (num != -1)
				{
					sb.Append(type.Name.Substring(0, num));
				}
				else
				{
					sb.Append(type.Name);
				}
				sb.Append("<");
				bool flag = true;
				Type[] genericArguments = type.GetGenericArguments();
				foreach (Type type2 in genericArguments)
				{
					if (!flag)
					{
						sb.Append(", ");
					}
					flag = false;
					TypeBeautify(type2, sb);
				}
				sb.Append(">");
			}
			else
			{
				sb.Append(type.Name);
			}
		}
	}
	public abstract class MoveNextSource : IUniTaskSource<bool>, IUniTaskSource
	{
		protected UniTaskCompletionSourceCore<bool> completionSource;

		public bool GetResult(short token)
		{
			return completionSource.GetResult(token);
		}

		public UniTaskStatus GetStatus(short token)
		{
			return completionSource.GetStatus(token);
		}

		public void OnCompleted(Action<object> continuation, object state, short token)
		{
			completionSource.OnCompleted(continuation, state, token);
		}

		public UniTaskStatus UnsafeGetStatus()
		{
			return completionSource.UnsafeGetStatus();
		}

		void IUniTaskSource.GetResult(short token)
		{
			completionSource.GetResult(token);
		}

		protected bool TryGetResult<T>(UniTask<T>.Awaiter awaiter, out T result)
		{
			try
			{
				result = awaiter.GetResult();
				return true;
			}
			catch (Exception error)
			{
				completionSource.TrySetException(error);
				result = default(T);
				return false;
			}
		}

		protected bool TryGetResult(UniTask.Awaiter awaiter)
		{
			try
			{
				awaiter.GetResult();
				return true;
			}
			catch (Exception error)
			{
				completionSource.TrySetException(error);
				return false;
			}
		}
	}
	public static class UniTaskLoopRunners
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerInitialization
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerEarlyUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerFixedUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerPreUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerPreLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerPostLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastInitialization
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastEarlyUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastFixedUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastPreUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastPreLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastPostLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldInitialization
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldEarlyUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldFixedUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldPreUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldPreLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldPostLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldInitialization
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldEarlyUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldFixedUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldPreUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldPreLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldPostLateUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerTimeUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastTimeUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerYieldTimeUpdate
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct UniTaskLoopRunnerLastYieldTimeUpdate
		{
		}
	}
	public enum PlayerLoopTiming
	{
		Initialization,
		LastInitialization,
		EarlyUpdate,
		LastEarlyUpdate,
		FixedUpdate,
		LastFixedUpdate,
		PreUpdate,
		LastPreUpdate,
		Update,
		LastUpdate,
		PreLateUpdate,
		LastPreLateUpdate,
		PostLateUpdate,
		LastPostLateUpdate,
		TimeUpdate,
		LastTimeUpdate
	}
	[Flags]
	public enum InjectPlayerLoopTimings
	{
		All = 0xFFFF,
		Standard = 0x7555,
		Minimum = 0x2110,
		Initialization = 1,
		LastInitialization = 2,
		EarlyUpdate = 4,
		LastEarlyUpdate = 8,
		FixedUpdate = 0x10,
		LastFixedUpdate = 0x20,
		PreUpdate = 0x40,
		LastPreUpdate = 0x80,
		Update = 0x100,
		LastUpdate = 0x200,
		PreLateUpdate = 0x400,
		LastPreLateUpdate = 0x800,
		PostLateUpdate = 0x1000,
		LastPostLateUpdate = 0x2000,
		TimeUpdate = 0x4000,
		LastTimeUpdate = 0x8000
	}
	public interface IPlayerLoopItem
	{
		bool MoveNext();
	}
	public static class PlayerLoopHelper
	{
		private static readonly ContinuationQueue ThrowMarkerContinuationQueue = new ContinuationQueue(PlayerLoopTiming.Initialization);

		private static readonly PlayerLoopRunner ThrowMarkerPlayerLoopRunner = new PlayerLoopRunner(PlayerLoopTiming.Initialization);

		private static int mainThreadId;

		private static string applicationDataPath;

		private static SynchronizationContext unitySynchronizationContext;

		private static ContinuationQueue[] yielders;

		private static PlayerLoopRunner[] runners;

		public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContext;

		public static int MainThreadId => mainThreadId;

		internal static string ApplicationDataPath => applicationDataPath;

		public static bool IsMainThread => Thread.CurrentThread.ManagedThreadId == mainThreadId;

		internal static bool IsEditorApplicationQuitting { get; private set; }

		private static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, bool injectOnFirst, Type loopRunnerYieldType, ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			EditorApplication.playModeStateChanged += delegate(PlayModeStateChange state)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Invalid comparison between Unknown and I4
				if ((int)state == 0 || (int)state == 1)
				{
					IsEditorApplicationQuitting = true;
					if (runner != null)
					{
						runner.Run();
						runner.Clear();
					}
					if (cq != null)
					{
						cq.Run();
						cq.Clear();
					}
					IsEditorApplicationQuitting = false;
				}
			};
			PlayerLoopSystem val = default(PlayerLoopSystem);
			val.type = loopRunnerYieldType;
			val.updateDelegate = new UpdateFunction(cq.Run);
			PlayerLoopSystem val2 = val;
			val = default(PlayerLoopSystem);
			val.type = loopRunnerType;
			val.updateDelegate = new UpdateFunction(runner.Run);
			PlayerLoopSystem val3 = val;
			PlayerLoopSystem[] array = RemoveRunner(loopSystem, loopRunnerYieldType, loopRunnerType);
			PlayerLoopSystem[] array2 = (PlayerLoopSystem[])(object)new PlayerLoopSystem[array.Length + 2];
			Array.Copy(array, 0, array2, injectOnFirst ? 2 : 0, array.Length);
			if (injectOnFirst)
			{
				array2[0] = val2;
				array2[1] = val3;
			}
			else
			{
				array2[^2] = val2;
				array2[^1] = val3;
			}
			return array2;
		}

		private static PlayerLoopSystem[] RemoveRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, Type loopRunnerType)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return loopSystem.subSystemList.Where((PlayerLoopSystem ls) => ls.type != loopRunnerYieldType && ls.type != loopRunnerType).ToArray();
		}

		private static PlayerLoopSystem[] InsertUniTaskSynchronizationContext(PlayerLoopSystem loopSystem)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			PlayerLoopSystem val = default(PlayerLoopSystem);
			val.type = typeof(UniTaskSynchronizationContext);
			val.updateDelegate = new UpdateFunction(UniTaskSynchronizationContext.Run);
			PlayerLoopSystem item = val;
			List<PlayerLoopSystem> list = new List<PlayerLoopSystem>(loopSystem.subSystemList.Where((PlayerLoopSystem ls) => ls.type != typeof(UniTaskSynchronizationContext)).ToArray());
			int num = list.FindIndex((PlayerLoopSystem x) => x.type.Name == "ScriptRunDelayedTasks");
			if (num == -1)
			{
				num = list.FindIndex((PlayerLoopSystem x) => x.type.Name == "UniTaskLoopRunnerUpdate");
			}
			list.Insert(num + 1, item);
			return list.ToArray();
		}

		[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
		private static void Init()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			unitySynchronizationContext = SynchronizationContext.Current;
			mainThreadId = Thread.CurrentThread.ManagedThreadId;
			try
			{
				applicationDataPath = Application.dataPath;
			}
			catch
			{
			}
			if ((EditorSettings.enterPlayModeOptionsEnabled && ((Enum)EditorSettings.enterPlayModeOptions).HasFlag((Enum)(object)(EnterPlayModeOptions)1)) || runners == null)
			{
				PlayerLoopSystem playerLoop = PlayerLoop.GetCurrentPlayerLoop();
				Initialize(ref playerLoop);
			}
		}

		[InitializeOnLoadMethod]
		private static void InitOnEditor()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			Init();
			EditorApplication.update = (CallbackFunction)Delegate.Combine((Delegate?)(object)EditorApplication.update, (Delegate?)new CallbackFunction(ForceEditorPlayerLoopUpdate));
		}

		private static void ForceEditorPlayerLoopUpdate()
		{
			if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating)
			{
				return;
			}
			if (yielders != null)
			{
				ContinuationQueue[] array = yielders;
				for (int i = 0; i < array.Length; i++)
				{
					array[i]?.Run();
				}
			}
			if (runners != null)
			{
				PlayerLoopRunner[] array2 = runners;
				for (int i = 0; i < array2.Length; i++)
				{
					array2[i]?.Run();
				}
			}
			UniTaskSynchronizationContext.Run();
		}

		private static int FindLoopSystemIndex(PlayerLoopSystem[] playerLoopList, Type systemType)
		{
			for (int i = 0; i < playerLoopList.Length; i++)
			{
				if (playerLoopList[i].type == systemType)
				{
					return i;
				}
			}
			throw new Exception("Target PlayerLoopSystem does not found. Type:" + systemType.FullName);
		}

		private static void InsertLoop(PlayerLoopSystem[] copyList, InjectPlayerLoopTimings injectTimings, Type loopType, InjectPlayerLoopTimings targetTimings, int index, bool injectOnFirst, Type loopRunnerYieldType, Type loopRunnerType, PlayerLoopTiming playerLoopTiming)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			int num = FindLoopSystemIndex(copyList, loopType);
			if ((injectTimings & targetTimings) == targetTimings)
			{
				copyList[num].subSystemList = InsertRunner(copyList[num], injectOnFirst, loopRunnerYieldType, yielders[index] = new ContinuationQueue(playerLoopTiming), loopRunnerType, runners[index] = new PlayerLoopRunner(playerLoopTiming));
			}
			else
			{
				copyList[num].subSystemList = RemoveRunner(copyList[num], loopRunnerYieldType, loopRunnerType);
			}
		}

		public static void Initialize(ref PlayerLoopSystem playerLoop, InjectPlayerLoopTimings injectTimings = InjectPlayerLoopTimings.All)
		{
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			yielders = new ContinuationQueue[16];
			runners = new PlayerLoopRunner[16];
			PlayerLoopSystem[] array = playerLoop.subSystemList.ToArray();
			InsertLoop(array, injectTimings, typeof(Initialization), InjectPlayerLoopTimings.Initialization, 0, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), PlayerLoopTiming.Initialization);
			InsertLoop(array, injectTimings, typeof(Initialization), InjectPlayerLoopTimings.LastInitialization, 1, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), PlayerLoopTiming.LastInitialization);
			InsertLoop(array, injectTimings, typeof(EarlyUpdate), InjectPlayerLoopTimings.EarlyUpdate, 2, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), PlayerLoopTiming.EarlyUpdate);
			InsertLoop(array, injectTimings, typeof(EarlyUpdate), InjectPlayerLoopTimings.LastEarlyUpdate, 3, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), PlayerLoopTiming.LastEarlyUpdate);
			InsertLoop(array, injectTimings, typeof(FixedUpdate), InjectPlayerLoopTimings.FixedUpdate, 4, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), PlayerLoopTiming.FixedUpdate);
			InsertLoop(array, injectTimings, typeof(FixedUpdate), InjectPlayerLoopTimings.LastFixedUpdate, 5, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), PlayerLoopTiming.LastFixedUpdate);
			InsertLoop(array, injectTimings, typeof(PreUpdate), InjectPlayerLoopTimings.PreUpdate, 6, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), PlayerLoopTiming.PreUpdate);
			InsertLoop(array, injectTimings, typeof(PreUpdate), InjectPlayerLoopTimings.LastPreUpdate, 7, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), PlayerLoopTiming.LastPreUpdate);
			InsertLoop(array, injectTimings, typeof(Update), InjectPlayerLoopTimings.Update, 8, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), PlayerLoopTiming.Update);
			InsertLoop(array, injectTimings, typeof(Update), InjectPlayerLoopTimings.LastUpdate, 9, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), PlayerLoopTiming.LastUpdate);
			InsertLoop(array, injectTimings, typeof(PreLateUpdate), InjectPlayerLoopTimings.PreLateUpdate, 10, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), PlayerLoopTiming.PreLateUpdate);
			InsertLoop(array, injectTimings, typeof(PreLateUpdate), InjectPlayerLoopTimings.LastPreLateUpdate, 11, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), PlayerLoopTiming.LastPreLateUpdate);
			InsertLoop(array, injectTimings, typeof(PostLateUpdate), InjectPlayerLoopTimings.PostLateUpdate, 12, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), PlayerLoopTiming.PostLateUpdate);
			InsertLoop(array, injectTimings, typeof(PostLateUpdate), InjectPlayerLoopTimings.LastPostLateUpdate, 13, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), PlayerLoopTiming.LastPostLateUpdate);
			InsertLoop(array, injectTimings, typeof(TimeUpdate), InjectPlayerLoopTimings.TimeUpdate, 14, injectOnFirst: true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldTimeUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerTimeUpdate), PlayerLoopTiming.TimeUpdate);
			InsertLoop(array, injectTimings, typeof(TimeUpdate), InjectPlayerLoopTimings.LastTimeUpdate, 15, injectOnFirst: false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldTimeUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastTimeUpdate), PlayerLoopTiming.LastTimeUpdate);
			int num = FindLoopSystemIndex(array, typeof(Update));
			array[num].subSystemList = InsertUniTaskSynchronizationContext(array[num]);
			playerLoop.subSystemList = array;
			PlayerLoop.SetPlayerLoop(playerLoop);
		}

		public static void AddAction(PlayerLoopTiming timing, IPlayerLoopItem action)
		{
			PlayerLoopRunner obj = runners[(int)timing];
			if (obj == null)
			{
				ThrowInvalidLoopTiming(timing);
			}
			obj.AddAction(action);
		}

		private static void ThrowInvalidLoopTiming(PlayerLoopTiming playerLoopTiming)
		{
			throw new InvalidOperationException("Target playerLoopTiming is not injected. Please check PlayerLoopHelper.Initialize. PlayerLoopTiming:" + playerLoopTiming);
		}

		public static void AddContinuation(PlayerLoopTiming timing, Action continuation)
		{
			ContinuationQueue obj = yielders[(int)timing];
			if (obj == null)
			{
				ThrowInvalidLoopTiming(timing);
			}
			obj.Enqueue(continuation);
		}

		public static void DumpCurrentPlayerLoop()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			PlayerLoopSystem currentPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("PlayerLoop List");
			PlayerLoopSystem[] subSystemList = currentPlayerLoop.subSystemList;
			for (int i = 0; i < subSystemList.Length; i++)
			{
				PlayerLoopSystem val = subSystemList[i];
				stringBuilder.AppendFormat("------{0}------", val.type.Name);
				stringBuilder.AppendLine();
				if (val.subSystemList == null)
				{
					stringBuilder.AppendFormat("{0} has no subsystems!", ((object)(PlayerLoopSystem)(ref val)).ToString());
					stringBuilder.AppendLine();
					continue;
				}
				PlayerLoopSystem[] subSystemList2 = val.subSystemList;
				foreach (PlayerLoopSystem val2 in subSystemList2)
				{
					stringBuilder.AppendFormat("{0}", val2.type.Name);
					stringBuilder.AppendLine();
					if (val2.subSystemList != null)
					{
						Debug.LogWarning((object)("More Subsystem:" + val2.subSystemList.Length));
					}
				}
			}
			Debug.Log((object)stringBuilder.ToString());
		}

		public static bool IsInjectedUniTaskPlayerLoop()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			PlayerLoopSystem[] subSystemList = PlayerLoop.GetCurrentPlayerLoop().subSystemList;
			foreach (PlayerLoopSystem val in subSystemList)
			{
				if (val.subSystemList == null)
				{
					continue;
				}
				PlayerLoopSystem[] subSystemList2 = val.subSystemList;
				for (int j = 0; j < subSystemList2.Length; j++)
				{
					if (subSystemList2[j].type == typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization))
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	public abstract class PlayerLoopTimer : IDisposable, IPlayerLoopItem
	{
		private readonly CancellationToken cancellationToken;

		private readonly Action<object> timerCallback;

		private readonly object state;

		private readonly PlayerLoopTiming playerLoopTiming;

		private readonly bool periodic;

		private bool isRunning;

		private bool tryStop;

		private bool isDisposed;

		protected PlayerLoopTimer(bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
		{
			this.periodic = periodic;
			this.playerLoopTiming = playerLoopTiming;
			this.cancellationToken = cancellationToken;
			this.timerCallback = timerCallback;
			this.state = state;
		}

		public static PlayerLoopTimer Create(TimeSpan interval, bool periodic, DelayType delayType, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
		{
			if (PlayerLoopHelper.IsMainThread && !EditorApplication.isPlaying)
			{
				delayType = DelayType.Realtime;
			}
			return delayType switch
			{
				DelayType.UnscaledDeltaTime => new IgnoreTimeScalePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state), 
				DelayType.Realtime => new RealtimePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state), 
				_ => new DeltaTimePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state), 
			};
		}

		public static PlayerLoopTimer StartNew(TimeSpan interval, bool periodic, DelayType delayType, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
		{
			PlayerLoopTimer playerLoopTimer = Create(interval, periodic, delayType, playerLoopTiming, cancellationToken, timerCallback, state);
			playerLoopTimer.Restart();
			return playerLoopTimer;
		}

		public void Restart()
		{
			if (isDisposed)
			{
				throw new ObjectDisposedException(null);
			}
			ResetCore(null);
			if (!isRunning)
			{
				isRunning = true;
				PlayerLoopHelper.AddAction(playerLoopTiming, this);
			}
			tryStop = false;
		}

		public void Restart(TimeSpan interval)
		{
			if (isDisposed)
			{
				throw new ObjectDisposedException(null);
			}
			ResetCore(interval);
			if (!isRunning)
			{
				isRunning = true;
				PlayerLoopHelper.AddAction(playerLoopTiming, this);
			}
			tryStop = false;
		}

		public void Stop()
		{
			tryStop = true;
		}

		protected abstract void ResetCore(TimeSpan? newInterval);

		public void Dispose()
		{
			isDisposed = true;
		}

		bool IPlayerLoopItem.MoveNext()
		{
			if (isDisposed)
			{
				isRunning = false;
				return false;
			}
			if (tryStop)
			{
				isRunning = false;
				return false;
			}
			CancellationToken cancellationToken = this.cancellationToken;
			if (cancellationToken.IsCancellationRequested)
			{
				isRunning = false;
				return false;
			}
			if (!MoveNextCore())
			{
				timerCallback(state);
				if (periodic)
				{
					ResetCore(null);
					return true;
				}
				isRunning = false;
				return false;
			}
			return true;
		}

		protected abstract bool MoveNextCore();
	}
	internal sealed class DeltaTimePlayerLoopTimer : PlayerLoopTimer
	{
		private int initialFrame;

		private float elapsed;

		private float interval;

		public DeltaTimePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
			: base(periodic, playerLoopTiming, cancellationToken, timerCallback, state)
		{
			ResetCore(interval);
		}

		protected override bool MoveNextCore()
		{
			if (elapsed == 0f && initialFrame == Time.frameCount)
			{
				return true;
			}
			elapsed += Time.deltaTime;
			if (elapsed >= interval)
			{
				return false;
			}
			return true;
		}

		protected override void ResetCore(TimeSpan? interval)
		{
			elapsed = 0f;
			initialFrame = (PlayerLoopHelper.IsMainThread ? Time.frameCount : (-1));
			if (interval.HasValue)
			{
				this.interval = (float)interval.Value.TotalSeconds;
			}
		}
	}
	internal sealed class IgnoreTimeScalePlayerLoopTimer : PlayerLoopTimer
	{
		private int initialFrame;

		private float elapsed;

		private float interval;

		public IgnoreTimeScalePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
			: base(periodic, playerLoopTiming, cancellationToken, timerCallback, state)
		{
			ResetCore(interval);
		}

		protected override bool MoveNextCore()
		{
			if (elapsed == 0f && initialFrame == Time.frameCount)
			{
				return true;
			}
			elapsed += Time.unscaledDeltaTime;
			if (elapsed >= interval)
			{
				return false;
			}
			return true;
		}

		protected override void ResetCore(TimeSpan? interval)
		{
			elapsed = 0f;
			initialFrame = (PlayerLoopHelper.IsMainThread ? Time.frameCount : (-1));
			if (interval.HasValue)
			{
				this.interval = (float)interval.Value.TotalSeconds;
			}
		}
	}
	internal sealed class RealtimePlayerLoopTimer : PlayerLoopTimer
	{
		private ValueStopwatch stopwatch;

		private long intervalTicks;

		public RealtimePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
			: base(periodic, playerLoopTiming, cancellationToken, timerCallback, state)
		{
			ResetCore(interval);
		}

		protected override bool MoveNextCore()
		{
			if (stopwatch.ElapsedTicks >= intervalTicks)
			{
				return false;
			}
			return true;
		}

		protected override void ResetCore(TimeSpan? interval)
		{
			stopwatch = ValueStopwatch.StartNew();
			if (interval.HasValue)
			{
				intervalTicks = interval.Value.Ticks;
			}
		}
	}
	public static class Progress
	{
		private sealed class NullProgress<T> : IProgress<T>
		{
			public static readonly IProgress<T> Instance = new NullProgress<T>();

			private NullProgress()
			{
			}

			public void Report(T value)
			{
			}
		}

		private sealed class AnonymousProgress<T> : IProgress<T>
		{
			private readonly Action<T> action;

			public AnonymousProgress(Action<T> action)
			{
				this.action = action;
			}

			public void Report(T value)
			{
				action(value);
			}
		}

		private sealed class OnlyValueChangedProgress<T> : IProgress<T>
		{
			private readonly Action<T> action;

			private readonly IEqualityComparer<T> comparer;

			private bool isFirstCall;

			private T latestValue;

			public OnlyValueChangedProgress(Action<T> action, IEqualityComparer<T> comparer)
			{
				this.action = action;
				this.comparer = comparer;
				isFirstCall = true;
			}

			public void Report(T value)
			{
				if (isFirstCall)
				{
					isFirstCall = false;
				}
				else if (comparer.Equals(value, latestValue))
				{
					return;
				}
				latestValue = value;
				action(value);
			}
		}

		public static IProgress<T> Create<T>(Action<T> handler)
		{
			if (handler == null)
			{
				return NullProgress<T>.Instance;
			}
			return new AnonymousProgress<T>(handler);
		}

		public static IProgress<T> CreateOnlyValueChanged<T>(Action<T> handler, IEqualityComparer<T> comparer = null)
		{
			if (handler == null)
			{
				return NullProgress<T>.Instance;
			}
			return new OnlyValueChangedProgress<T>(handler, comparer ?? UnityEqualityComparer.GetDefault<T>());
		}
	}
	public static class TaskPool
	{
		internal static int MaxPoolSize;

		private static Dictionary<Type, Func<int>> sizes;

		static TaskPool()
		{
			sizes = new Dictionary<Type, Func<int>>();
			try
			{
				string environmentVariable = Environment.GetEnvironmentVariable("UNITASK_MAX_POOLSIZE");
				if (environmentVariable != null && int.TryParse(environmentVariable, out var result))
				{
					MaxPoolSize = result;
					return;
				}
			}
			catch
			{
			}
			MaxPoolSize = int.MaxValue;
		}

		public static void SetMaxPoolSize(int maxPoolSize)
		{
			MaxPoolSize = maxPoolSize;
		}

		public static IEnumerable<(Type, int)> GetCacheSizeInfo()
		{
			lock (sizes)
			{
				foreach (KeyValuePair<Type, Func<int>> size in sizes)
				{
					yield return (size.Key, size.Value());
				}
			}
		}

		public static void RegisterSizeGetter(Type type, Func<int> getSize)
		{
			lock (sizes)
			{
				sizes[type] = getSize;
			}
		}
	}
	public interface ITaskPoolNode<T>
	{
		ref T NextNode { get; }
	}
	[StructLayout(LayoutKind.Auto)]
	public struct TaskPool<T> where T : class, ITaskPoolNode<T>
	{
		private int gate;

		private int size;

		private T root;

		public int Size => size;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryPop(out T result)
		{
			if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
			{
				T val = root;
				if (val != null)
				{
					ref T nextNode = ref val.NextNode;
					root = nextNode;
					nextNode = null;
					size--;
					result = val;
					Volatile.Write(ref gate, 0);
					return true;
				}
				Volatile.Write(ref gate, 0);
			}
			result = null;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryPush(T item)
		{
			if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
			{
				if (size < TaskPool.MaxPoolSize)
				{
					item.NextNode = root;
					root = item;
					size++;
					Volatile.Write(ref gate, 0);
					return true;
				}
				Volatile.Write(ref gate, 0);
			}
			return false;
		}
	}
	public sealed class TimeoutController : IDisposable
	{
		private static readonly Action<object> CancelCancellationTokenSourceStateDelegate = CancelCancellationTokenSourceState;

		private CancellationTokenSource timeoutSource;

		private CancellationTokenSource linkedSource;

		private PlayerLoopTimer timer;

		private bool isDisposed;

		private readonly DelayType delayType;

		private readonly PlayerLoopTiming delayTiming;

		private readonly CancellationTokenSource originalLinkCancellationTokenSource;

		private static void CancelCancellationTokenSourceState(object state)
		{
			((CancellationTokenSource)state).Cancel();
		}

		public TimeoutController(DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
		{
			timeoutSource = new CancellationTokenSource();
			originalLinkCancellationTokenSource = null;
			linkedSource = null;
			this.delayType = delayType;
			this.delayTiming = delayTiming;
		}

		public TimeoutController(CancellationTokenSource linkCancellationTokenSource, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
		{
			timeoutSource = new CancellationTokenSource();
			originalLinkCancellationTokenSource = linkCancellationTokenSource;
			linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, linkCancellationTokenSource.Token);
			this.delayType = delayType;
			this.delayTiming = delayTiming;
		}

		public CancellationToken Timeout(int millisecondsTimeout)
		{
			return Timeout(TimeSpan.FromMilliseconds(millisecondsTimeout));
		}

		public CancellationToken Timeout(TimeSpan timeout)
		{
			if (originalLinkCancellationTokenSource != null && originalLinkCancellationTokenSource.IsCancellationRequested)
			{
				return originalLinkCancellationTokenSource.Token;
			}
			if (timeoutSource.IsCancellationRequested)
			{
				timeoutSource.Dispose();
				timeoutSource = new CancellationTokenSource();
				if (linkedSource != null)
				{
					linkedSource.Cancel();
					linkedSource.Dispose();
					linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, originalLinkCancellationTokenSource.Token);
				}
				timer?.Dispose();
				timer = null;
			}
			CancellationToken token = ((linkedSource != null) ? linkedSource : timeoutSource).Token;
			if (timer == null)
			{
				timer = PlayerLoopTimer.StartNew(timeout, periodic: false, delayType, delayTiming, token, CancelCancellationTokenSourceStateDelegate, timeoutSource);
			}
			else
			{
				timer.Restart(timeout);
			}
			return token;
		}

		public bool IsTimeout()
		{
			return timeoutSource.IsCancellationRequested;
		}

		public void Reset()
		{
			timer?.Stop();
		}

		public void Dispose()
		{
			if (isDisposed)
			{
				return;
			}
			try
			{
				timer?.Dispose();
				timeoutSource.Cancel();
				timeoutSource.Dispose();
				if (linkedSource != null)
				{
					linkedSource.Cancel();
					linkedSource.Dispose();
				}
			}
			finally
			{
				isDisposed = true;
			}
		}
	}
	public interface ITriggerHandler<T>
	{
		ITriggerHandler<T> Prev { get; set; }

		ITriggerHandler<T> Next { get; set; }

		void OnNext(T value);

		void OnError(Exception ex);

		void OnCompleted();

		void OnCanceled(CancellationToken cancellationToken);
	}
	public struct TriggerEvent<T>
	{
		private ITriggerHandler<T> head;

		private ITriggerHandler<T> iteratingHead;

		private bool preserveRemoveSelf;

		private ITriggerHandler<T> iteratingNode;

		private void LogError(Exception ex)
		{
			Debug.LogException(ex);
		}

		public void SetResult(T value)
		{
			if (iteratingNode != null)
			{
				throw new InvalidOperationException("Can not trigger itself in iterating.");
			}
			ITriggerHandler<T> triggerHandler = head;
			while (triggerHandler != null)
			{
				iteratingNode = triggerHandler;
				try
				{
					triggerHandler.OnNext(value);
				}
				catch (Exception ex)
				{
					LogError(ex);
					Remove(triggerHandler);
				}
				if (preserveRemoveSelf)
				{
					preserveRemoveSelf = false;
					iteratingNode = null;
					ITriggerHandler<T> next = triggerHandler.Next;
					Remove(triggerHandler);
					triggerHandler = next;
				}
				else
				{
					triggerHandler = triggerHandler.Next;
				}
			}
			iteratingNode = null;
			if (iteratingHead != null)
			{
				Add(iteratingHead);
				iteratingHead = null;
			}
		}

		public void SetCanceled(CancellationToken cancellationToken)
		{
			if (iteratingNode != null)
			{
				throw new InvalidOperationException("Can not trigger itself in iterating.");
			}
			ITriggerHandler<T> triggerHandler = head;
			while (triggerHandler != null)
			{
				iteratingNode = triggerHandler;
				try
				{
					triggerHandler.OnCanceled(cancellationToken);
				}
				catch (Exception ex)
				{
					LogError(ex);
				}
				preserveRemoveSelf = false;
				iteratingNode = null;
				ITriggerHandler<T> next = triggerHandler.Next;
				Remove(triggerHandler);
				triggerHandler = next;
			}
			iteratingNode = null;
			if (iteratingHead != null)
			{
				Add(iteratingHead);
				iteratingHead = null;
			}
		}

		public void SetCompleted()
		{
			if (iteratingNode != null)
			{
				throw new InvalidOperationException("Can not trigger itself in iterating.");
			}
			ITriggerHandler<T> triggerHandler = head;
			while (triggerHandler != null)
			{
				iteratingNode = triggerHandler;
				try
				{
					triggerHandler.OnCompleted();
				}
				catch (Exception ex)
				{
					LogError(ex);
				}
				preserveRemoveSelf = false;
				iteratingNode = null;
				ITriggerHandler<T> next = triggerHandler.Next;
				Remove(triggerHandler);
				triggerHandler = next;
			}
			iteratingNode = null;
			if (iteratingHead != null)
			{
				Add(iteratingHead);
				iteratingHead = null;
			}
		}

		public void SetError(Exception exception)
		{
			if (iteratingNode != null)
			{
				throw new InvalidOperationException("Can not trigger itself in iterating.");
			}
			ITriggerHandler<T> triggerHandler = head;
			while (triggerHandler != null)
			{
				iteratingNode = triggerHandler;
				try
				{
					triggerHandler.OnError(exception);
				}
				catch (Exception ex)
				{
					LogError(ex);
				}
				preserveRemoveSelf = false;
				iteratingNode = null;
				ITriggerHandler<T> next = triggerHandler.Next;
				Remove(triggerHandler);
				triggerHandler = next;
			}
			iteratingNode = null;
			if (iteratingHead != null)
			{
				Add(iteratingHead);
				iteratingHead = null;
			}
		}

		public void Add(ITriggerHandler<T> handler)
		{
			if (handler == null)
			{
				throw new ArgumentNullException("handler");
			}
			if (head == null)
			{
				head = handler;
			}
			else if (iteratingNode != null)
			{
				if (iteratingHead == null)
				{
					iteratingHead = handler;
					return;
				}
				ITriggerHandler<T> prev = iteratingHead.Prev;
				if (prev == null)
				{
					iteratingHead.Prev = handler;
					iteratingHead.Next = handler;
					handler.Prev = iteratingHead;
				}
				else
				{
					iteratingHead.Prev = handler;
					prev.Next = handler;
					handler.Prev = prev;
				}
			}
			else
			{
				ITriggerHandler<T> prev2 = head.Prev;
				if (prev2 == null)
				{
					head.Prev = handler;
					head.Next = handler;
					handler.Prev = head;
				}
				else
				{
					head.Prev = handler;
					prev2.Next = handler;
					handler.Prev = prev2;
				}
			}
		}

		public void Remove(ITriggerHandler<T> handler)
		{
			if (handler == null)
			{
				throw new ArgumentNullException("handler");
			}
			if (iteratingNode != null && iteratingNode == handler)
			{
				preserveRemoveSelf = true;
				return;
			}
			ITriggerHandler<T> prev = handler.Prev;
			ITriggerHandler<T> next = handler.Next;
			if (next != null)
			{
				next.Prev = prev;
			}
			if (handler == head)
			{
				head = next;
			}
			else if (handler == iteratingHead)
			{
				iteratingHead = next;
			}
			else if (prev != null)
			{
				prev.Next = next;
			}
			if (head != null && head.Prev == handler)
			{
				if (prev != head)
				{
					head.Prev = prev;
				}
				else
				{
					head.Prev = null;
				}
			}
			if (iteratingHead != null && iteratingHead.Prev == handler)
			{
				if (prev != iteratingHead.Prev)
				{
					iteratingHead.Prev = prev;
				}
				else
				{
					iteratingHead.Prev = null;
				}
			}
			handler.Prev = null;
			handler.Next = null;
		}
	}
	public static class UniTaskCancellationExtensions
	{
		public static CancellationToken GetCancellationTokenOnDestroy(this GameObject gameObject)
		{
			return gameObject.GetAsyncDestroyTrigger().CancellationToken;
		}

		public static CancellationToken GetCancellationTokenOnDestroy(this Component component)
		{
			return component.GetAsyncDestroyTrigger().CancellationToken;
		}
	}
	[StructLayout(LayoutKind.Auto)]
	[AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder))]
	public readonly struct UniTask
	{
		private sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<YieldPromise>
		{
			private static TaskPool<YieldPromise> pool;

			private YieldPromise nextNode;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			public ref YieldPromise NextNode => ref nextNode;

			static YieldPromise()
			{
				TaskPool.RegisterSizeGetter(typeof(YieldPromise), () => pool.Size);
			}

			private YieldPromise()
			{
			}

			public static IUniTaskSource Create(PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new YieldPromise();
				}
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

			public void GetResult(short token)
			{
				try
				{
					core.GetResult(token);
				}
				finally
				{
					TryReturn();
				}
			}

			public UniTaskStatus GetStatus(short token)
			{
				return core.GetStatus(token);
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				return core.UnsafeGetStatus();
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				core.OnCompleted(continuation, state, token);
			}

			public bool MoveNext()
			{
				if (cancellationToken.IsCancellationRequested)
				{
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				core.TrySetResult(null);
				return false;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}
		}

		private sealed class NextFramePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<NextFramePromise>
		{
			private static TaskPool<NextFramePromise> pool;

			private NextFramePromise nextNode;

			private int frameCount;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public ref NextFramePromise NextNode => ref nextNode;

			static NextFramePromise()
			{
				TaskPool.RegisterSizeGetter(typeof(NextFramePromise), () => pool.Size);
			}

			private NextFramePromise()
			{
			}

			public static IUniTaskSource Create(PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new NextFramePromise();
				}
				result.frameCount = (PlayerLoopHelper.IsMainThread ? Time.frameCount : (-1));
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

			public void GetResult(short token)
			{
				try
				{
					core.GetResult(token);
				}
				finally
				{
					TryReturn();
				}
			}

			public UniTaskStatus GetStatus(short token)
			{
				return core.GetStatus(token);
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				return core.UnsafeGetStatus();
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				core.OnCompleted(continuation, state, token);
			}

			public bool MoveNext()
			{
				if (cancellationToken.IsCancellationRequested)
				{
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				if (frameCount == Time.frameCount)
				{
					return true;
				}
				core.TrySetResult(AsyncUnit.Default);
				return false;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}
		}

		private sealed class WaitForEndOfFramePromise : IUniTaskSource, ITaskPoolNode<WaitForEndOfFramePromise>, IEnumerator
		{
			private static TaskPool<WaitForEndOfFramePromise> pool;

			private WaitForEndOfFramePromise nextNode;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			private static readonly WaitForEndOfFrame waitForEndOfFrameYieldInstruction;

			private bool isFirst = true;

			public ref WaitForEndOfFramePromise NextNode => ref nextNode;

			object IEnumerator.Current => waitForEndOfFrameYieldInstruction;

			st