#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;

			static WaitForEndOfFramePromise()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Expected O, but got Unknown
				waitForEndOfFrameYieldInstruction = new WaitForEndOfFrame();
				TaskPool.RegisterSizeGetter(typeof(WaitForEndOfFramePromise), () => pool.Size);
			}

			private WaitForEndOfFramePromise()
			{
			}

			public static IUniTaskSource Create(MonoBehaviour coroutineRunner, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitForEndOfFramePromise();
				}
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				coroutineRunner.StartCoroutine((IEnumerator)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);
			}

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

			bool IEnumerator.MoveNext()
			{
				if (isFirst)
				{
					isFirst = false;
					return true;
				}
				if (cancellationToken.IsCancellationRequested)
				{
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				core.TrySetResult(null);
				return false;
			}

			public void Reset()
			{
				isFirst = true;
			}
		}

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

			private DelayFramePromise nextNode;

			private int initialFrame;

			private int delayFrameCount;

			private CancellationToken cancellationToken;

			private int currentFrameCount;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public ref DelayFramePromise NextNode => ref nextNode;

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

			private DelayFramePromise()
			{
			}

			public static IUniTaskSource Create(int delayFrameCount, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new DelayFramePromise();
				}
				result.delayFrameCount = delayFrameCount;
				result.cancellationToken = cancellationToken;
				result.initialFrame = (PlayerLoopHelper.IsMainThread ? Time.frameCount : (-1));
				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 (currentFrameCount == 0)
				{
					if (delayFrameCount == 0)
					{
						core.TrySetResult(AsyncUnit.Default);
						return false;
					}
					if (initialFrame == Time.frameCount && (!PlayerLoopHelper.IsMainThread || EditorApplication.isPlaying))
					{
						return true;
					}
				}
				if (++currentFrameCount >= delayFrameCount)
				{
					core.TrySetResult(AsyncUnit.Default);
					return false;
				}
				return true;
			}

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

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

			private DelayPromise nextNode;

			private int initialFrame;

			private float delayTimeSpan;

			private float elapsed;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			public ref DelayPromise NextNode => ref nextNode;

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

			private DelayPromise()
			{
			}

			public static IUniTaskSource Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new DelayPromise();
				}
				result.elapsed = 0f;
				result.delayTimeSpan = (float)delayTimeSpan.TotalSeconds;
				result.cancellationToken = cancellationToken;
				result.initialFrame = (PlayerLoopHelper.IsMainThread ? Time.frameCount : (-1));
				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 (elapsed == 0f && initialFrame == Time.frameCount)
				{
					return true;
				}
				elapsed += Time.deltaTime;
				if (elapsed >= delayTimeSpan)
				{
					core.TrySetResult(null);
					return false;
				}
				return true;
			}

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

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

			private DelayIgnoreTimeScalePromise nextNode;

			private float delayFrameTimeSpan;

			private float elapsed;

			private int initialFrame;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			public ref DelayIgnoreTimeScalePromise NextNode => ref nextNode;

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

			private DelayIgnoreTimeScalePromise()
			{
			}

			public static IUniTaskSource Create(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new DelayIgnoreTimeScalePromise();
				}
				result.elapsed = 0f;
				result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
				result.initialFrame = (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 (elapsed == 0f && initialFrame == Time.frameCount)
				{
					return true;
				}
				elapsed += Time.unscaledDeltaTime;
				if (elapsed >= delayFrameTimeSpan)
				{
					core.TrySetResult(null);
					return false;
				}
				return true;
			}

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

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

			private DelayRealtimePromise nextNode;

			private long delayTimeSpanTicks;

			private ValueStopwatch stopwatch;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public ref DelayRealtimePromise NextNode => ref nextNode;

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

			private DelayRealtimePromise()
			{
			}

			public static IUniTaskSource Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new DelayRealtimePromise();
				}
				result.stopwatch = ValueStopwatch.StartNew();
				result.delayTimeSpanTicks = delayTimeSpan.Ticks;
				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 (stopwatch.IsInvalid)
				{
					core.TrySetResult(AsyncUnit.Default);
					return false;
				}
				if (stopwatch.ElapsedTicks >= delayTimeSpanTicks)
				{
					core.TrySetResult(AsyncUnit.Default);
					return false;
				}
				return true;
			}

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

		private static class CanceledUniTaskCache<T>
		{
			public static readonly UniTask<T> Task;

			static CanceledUniTaskCache()
			{
				Task = new UniTask<T>(new CanceledResultSource<T>(CancellationToken.None), 0);
			}
		}

		private sealed class ExceptionResultSource : IUniTaskSource
		{
			private readonly ExceptionDispatchInfo exception;

			private bool calledGet;

			public ExceptionResultSource(Exception exception)
			{
				this.exception = ExceptionDispatchInfo.Capture(exception);
			}

			public void GetResult(short token)
			{
				if (!calledGet)
				{
					calledGet = true;
					GC.SuppressFinalize(this);
				}
				exception.Throw();
			}

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

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

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

			~ExceptionResultSource()
			{
				if (!calledGet)
				{
					UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException);
				}
			}
		}

		private sealed class ExceptionResultSource<T> : IUniTaskSource<T>, IUniTaskSource
		{
			private readonly ExceptionDispatchInfo exception;

			private bool calledGet;

			public ExceptionResultSource(Exception exception)
			{
				this.exception = ExceptionDispatchInfo.Capture(exception);
			}

			public T GetResult(short token)
			{
				if (!calledGet)
				{
					calledGet = true;
					GC.SuppressFinalize(this);
				}
				exception.Throw();
				return default(T);
			}

			void IUniTaskSource.GetResult(short token)
			{
				if (!calledGet)
				{
					calledGet = true;
					GC.SuppressFinalize(this);
				}
				exception.Throw();
			}

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

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

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

			~ExceptionResultSource()
			{
				if (!calledGet)
				{
					UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException);
				}
			}
		}

		private sealed class CanceledResultSource : IUniTaskSource
		{
			private readonly CancellationToken cancellationToken;

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

			public void GetResult(short token)
			{
				throw new OperationCanceledException(cancellationToken);
			}

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

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

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

		private sealed class CanceledResultSource<T> : IUniTaskSource<T>, IUniTaskSource
		{
			private readonly CancellationToken cancellationToken;

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

			public T GetResult(short token)
			{
				throw new OperationCanceledException(cancellationToken);
			}

			void IUniTaskSource.GetResult(short token)
			{
				throw new OperationCanceledException(cancellationToken);
			}

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

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

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

		private sealed class DeferPromise : IUniTaskSource
		{
			private Func<UniTask> factory;

			private UniTask task;

			private Awaiter awaiter;

			public DeferPromise(Func<UniTask> factory)
			{
				this.factory = factory;
			}

			public void GetResult(short token)
			{
				awaiter.GetResult();
			}

			public UniTaskStatus GetStatus(short token)
			{
				Func<UniTask> func = Interlocked.Exchange(ref factory, null);
				if (func != null)
				{
					task = func();
					awaiter = task.GetAwaiter();
				}
				return task.Status;
			}

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

			public UniTaskStatus UnsafeGetStatus()
			{
				return task.Status;
			}
		}

		private sealed class DeferPromise<T> : IUniTaskSource<T>, IUniTaskSource
		{
			private Func<UniTask<T>> factory;

			private UniTask<T> task;

			private UniTask<T>.Awaiter awaiter;

			public DeferPromise(Func<UniTask<T>> factory)
			{
				this.factory = factory;
			}

			public T GetResult(short token)
			{
				return awaiter.GetResult();
			}

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

			public UniTaskStatus GetStatus(short token)
			{
				Func<UniTask<T>> func = Interlocked.Exchange(ref factory, null);
				if (func != null)
				{
					task = func();
					awaiter = task.GetAwaiter();
				}
				return task.Status;
			}

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

			public UniTaskStatus UnsafeGetStatus()
			{
				return task.Status;
			}
		}

		private sealed class NeverPromise<T> : IUniTaskSource<T>, IUniTaskSource
		{
			private static readonly Action<object> cancellationCallback = CancellationCallback;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<T> core;

			public NeverPromise(CancellationToken cancellationToken)
			{
				this.cancellationToken = cancellationToken;
				if (this.cancellationToken.CanBeCanceled)
				{
					this.cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
				}
			}

			private static void CancellationCallback(object state)
			{
				NeverPromise<T> neverPromise = (NeverPromise<T>)state;
				neverPromise.core.TrySetCanceled(neverPromise.cancellationToken);
			}

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

			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);
			}

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

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

			private WaitUntilPromise nextNode;

			private Func<bool> predicate;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			public ref WaitUntilPromise NextNode => ref nextNode;

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

			private WaitUntilPromise()
			{
			}

			public static IUniTaskSource Create(Func<bool> predicate, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitUntilPromise();
				}
				result.predicate = predicate;
				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;
				}
				try
				{
					if (!predicate())
					{
						return true;
					}
				}
				catch (Exception error)
				{
					core.TrySetException(error);
					return false;
				}
				core.TrySetResult(null);
				return false;
			}

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

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

			private WaitWhilePromise nextNode;

			private Func<bool> predicate;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			public ref WaitWhilePromise NextNode => ref nextNode;

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

			private WaitWhilePromise()
			{
			}

			public static IUniTaskSource Create(Func<bool> predicate, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitWhilePromise();
				}
				result.predicate = predicate;
				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;
				}
				try
				{
					if (predicate())
					{
						return true;
					}
				}
				catch (Exception error)
				{
					core.TrySetException(error);
					return false;
				}
				core.TrySetResult(null);
				return false;
			}

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

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

			private WaitUntilCanceledPromise nextNode;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<object> core;

			public ref WaitUntilCanceledPromise NextNode => ref nextNode;

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

			private WaitUntilCanceledPromise()
			{
			}

			public static IUniTaskSource Create(CancellationToken cancellationToken, PlayerLoopTiming timing, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitUntilCanceledPromise();
				}
				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.TrySetResult(null);
					return false;
				}
				return true;
			}

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

		private sealed class WaitUntilValueChangedUnityObjectPromise<T, U> : IUniTaskSource<U>, IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<WaitUntilValueChangedUnityObjectPromise<T, U>>
		{
			private static TaskPool<WaitUntilValueChangedUnityObjectPromise<T, U>> pool;

			private WaitUntilValueChangedUnityObjectPromise<T, U> nextNode;

			private T target;

			private Object targetAsUnityObject;

			private U currentValue;

			private Func<T, U> monitorFunction;

			private IEqualityComparer<U> equalityComparer;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<U> core;

			public ref WaitUntilValueChangedUnityObjectPromise<T, U> NextNode => ref nextNode;

			static WaitUntilValueChangedUnityObjectPromise()
			{
				TaskPool.RegisterSizeGetter(typeof(WaitUntilValueChangedUnityObjectPromise<T, U>), () => pool.Size);
			}

			private WaitUntilValueChangedUnityObjectPromise()
			{
			}

			public static IUniTaskSource<U> Create(T target, Func<T, U> monitorFunction, IEqualityComparer<U> equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<U>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitUntilValueChangedUnityObjectPromise<T, U>();
				}
				result.target = target;
				ref Object reference = ref result.targetAsUnityObject;
				object obj = target;
				reference = (Object)((obj is Object) ? obj : null);
				result.monitorFunction = monitorFunction;
				result.currentValue = monitorFunction(target);
				result.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault<U>();
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

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

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

			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 || targetAsUnityObject == (Object)null)
				{
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				U val = default(U);
				try
				{
					val = monitorFunction(target);
					if (equalityComparer.Equals(currentValue, val))
					{
						return true;
					}
				}
				catch (Exception error)
				{
					core.TrySetException(error);
					return false;
				}
				core.TrySetResult(val);
				return false;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				target = default(T);
				currentValue = default(U);
				monitorFunction = null;
				equalityComparer = null;
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}
		}

		private sealed class WaitUntilValueChangedStandardObjectPromise<T, U> : IUniTaskSource<U>, IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<WaitUntilValueChangedStandardObjectPromise<T, U>> where T : class
		{
			private static TaskPool<WaitUntilValueChangedStandardObjectPromise<T, U>> pool;

			private WaitUntilValueChangedStandardObjectPromise<T, U> nextNode;

			private WeakReference<T> target;

			private U currentValue;

			private Func<T, U> monitorFunction;

			private IEqualityComparer<U> equalityComparer;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<U> core;

			public ref WaitUntilValueChangedStandardObjectPromise<T, U> NextNode => ref nextNode;

			static WaitUntilValueChangedStandardObjectPromise()
			{
				TaskPool.RegisterSizeGetter(typeof(WaitUntilValueChangedStandardObjectPromise<T, U>), () => pool.Size);
			}

			private WaitUntilValueChangedStandardObjectPromise()
			{
			}

			public static IUniTaskSource<U> Create(T target, Func<T, U> monitorFunction, IEqualityComparer<U> equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<U>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new WaitUntilValueChangedStandardObjectPromise<T, U>();
				}
				result.target = new WeakReference<T>(target, trackResurrection: false);
				result.monitorFunction = monitorFunction;
				result.currentValue = monitorFunction(target);
				result.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault<U>();
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

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

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

			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 || !target.TryGetTarget(out var arg))
				{
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				U val = default(U);
				try
				{
					val = monitorFunction(arg);
					if (equalityComparer.Equals(currentValue, val))
					{
						return true;
					}
				}
				catch (Exception error)
				{
					core.TrySetException(error);
					return false;
				}
				core.TrySetResult(val);
				return false;
			}

			private bool TryReturn()
			{
				TaskTracker.RemoveTracking(this);
				core.Reset();
				target = null;
				currentValue = default(U);
				monitorFunction = null;
				equalityComparer = null;
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}
		}

		private sealed class WhenAllPromise<T1, T2> : IUniTaskSource<(T1, T2)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2>, UniTask<T1>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
					return;
				}
				awaiter2.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2>, UniTask<T2>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2>, UniTask<T2>.Awaiter>)state;
					TryInvokeContinuationT2(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter2));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 2)
				{
					self.core.TrySetResult((self.t1, self.t2));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 2)
				{
					self.core.TrySetResult((self.t1, self.t2));
				}
			}

			public (T1, T2) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3> : IUniTaskSource<(T1, T2, T3)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3>, UniTask<T1>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3>, UniTask<T2>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
					return;
				}
				awaiter3.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3>, UniTask<T3>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3>, UniTask<T3>.Awaiter>)state;
					TryInvokeContinuationT3(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter3));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 3)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 3)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 3)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3));
				}
			}

			public (T1, T2, T3) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4> : IUniTaskSource<(T1, T2, T3, T4)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T1>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T2>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T3>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
					return;
				}
				awaiter4.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T4>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4>, UniTask<T4>.Awaiter>)state;
					TryInvokeContinuationT4(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter4));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 4)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 4)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 4)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 4)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4));
				}
			}

			public (T1, T2, T3, T4) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5> : IUniTaskSource<(T1, T2, T3, T4, T5)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T1>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T2>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T3>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T4>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
					return;
				}
				awaiter5.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T5>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5>, UniTask<T5>.Awaiter>)state;
					TryInvokeContinuationT5(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter5));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 5)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 5)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 5)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 5)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 5)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5));
				}
			}

			public (T1, T2, T3, T4, T5) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6> : IUniTaskSource<(T1, T2, T3, T4, T5, T6)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T1>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T2>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T3>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T4>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T5>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
					return;
				}
				awaiter6.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T6>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6>, UniTask<T6>.Awaiter>)state;
					TryInvokeContinuationT6(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter6));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 6)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 6)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 6)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 6)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 6)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 6)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6));
				}
			}

			public (T1, T2, T3, T4, T5, T6) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T1>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T2>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T3>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T4>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T5>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T6>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
					return;
				}
				awaiter7.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T7>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T7>.Awaiter>)state;
					TryInvokeContinuationT7(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter7));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 7)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T1>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T2>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T3>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T4>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T5>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T6>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T7>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
					return;
				}
				awaiter8.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T8>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T8>.Awaiter>)state;
					TryInvokeContinuationT8(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter8));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 8)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T1>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T2>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T3>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T4>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T5>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T6>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T7>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T8>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
					return;
				}
				awaiter9.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T9>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T9>.Awaiter>)state;
					TryInvokeContinuationT9(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter9));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 9)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private T10 t10;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T1>.Awaiter> stateTuple10 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T2>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T3>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T4>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T5>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T6>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T7>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T8>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T9>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
					return;
				}
				awaiter10.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T10>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T10>.Awaiter>)state;
					TryInvokeContinuationT10(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter10));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			private static void TryInvokeContinuationT10(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T10>.Awaiter awaiter)
			{
				try
				{
					self.t10 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 10)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private T10 t10;

			private T11 t11;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T1>.Awaiter> stateTuple11 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T2>.Awaiter> stateTuple10 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T3>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T4>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T5>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T6>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T7>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T8>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T9>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T10>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
					return;
				}
				awaiter11.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T11>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T11>.Awaiter>)state;
					TryInvokeContinuationT11(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter11));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT10(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T10>.Awaiter awaiter)
			{
				try
				{
					self.t10 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			private static void TryInvokeContinuationT11(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T11>.Awaiter awaiter)
			{
				try
				{
					self.t11 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 11)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private T10 t10;

			private T11 t11;

			private T12 t12;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T1>.Awaiter> stateTuple12 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T2>.Awaiter> stateTuple11 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T3>.Awaiter> stateTuple10 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T4>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T5>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T6>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T7>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T8>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T9>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T10>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T11>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
					return;
				}
				awaiter12.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T12>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T12>.Awaiter>)state;
					TryInvokeContinuationT12(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter12));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT10(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T10>.Awaiter awaiter)
			{
				try
				{
					self.t10 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT11(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T11>.Awaiter awaiter)
			{
				try
				{
					self.t11 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			private static void TryInvokeContinuationT12(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T12>.Awaiter awaiter)
			{
				try
				{
					self.t12 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 12)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private T10 t10;

			private T11 t11;

			private T12 t12;

			private T13 t13;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T1>.Awaiter> stateTuple13 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple13.Item1, in stateTuple13.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T2>.Awaiter> stateTuple12 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T3>.Awaiter> stateTuple11 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T4>.Awaiter> stateTuple10 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T5>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T6>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T7>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T8>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T9>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T10>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T11>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
				}
				else
				{
					awaiter12.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T12>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T12>.Awaiter>)state;
						TryInvokeContinuationT12(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter12));
				}
				UniTask<T13>.Awaiter awaiter13 = task13.GetAwaiter();
				if (awaiter13.IsCompleted)
				{
					TryInvokeContinuationT13(this, in awaiter13);
					return;
				}
				awaiter13.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T13>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T13>.Awaiter>)state;
					TryInvokeContinuationT13(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter13));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT10(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T10>.Awaiter awaiter)
			{
				try
				{
					self.t10 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT11(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T11>.Awaiter awaiter)
			{
				try
				{
					self.t11 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT12(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T12>.Awaiter awaiter)
			{
				try
				{
					self.t12 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			private static void TryInvokeContinuationT13(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T13>.Awaiter awaiter)
			{
				try
				{
					self.t13 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 13)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private T10 t10;

			private T11 t11;

			private T12 t12;

			private T13 t13;

			private T14 t14;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T1>.Awaiter> stateTuple14 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple14.Item1, in stateTuple14.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T2>.Awaiter> stateTuple13 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple13.Item1, in stateTuple13.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T3>.Awaiter> stateTuple12 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T4>.Awaiter> stateTuple11 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T5>.Awaiter> stateTuple10 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T6>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T7>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T8>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T9>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T10>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T11>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
				}
				else
				{
					awaiter12.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T12>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T12>.Awaiter>)state;
						TryInvokeContinuationT12(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter12));
				}
				UniTask<T13>.Awaiter awaiter13 = task13.GetAwaiter();
				if (awaiter13.IsCompleted)
				{
					TryInvokeContinuationT13(this, in awaiter13);
				}
				else
				{
					awaiter13.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T13>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T13>.Awaiter>)state;
						TryInvokeContinuationT13(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter13));
				}
				UniTask<T14>.Awaiter awaiter14 = task14.GetAwaiter();
				if (awaiter14.IsCompleted)
				{
					TryInvokeContinuationT14(this, in awaiter14);
					return;
				}
				awaiter14.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T14>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T14>.Awaiter>)state;
					TryInvokeContinuationT14(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter14));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT10(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T10>.Awaiter awaiter)
			{
				try
				{
					self.t10 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT11(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T11>.Awaiter awaiter)
			{
				try
				{
					self.t11 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT12(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T12>.Awaiter awaiter)
			{
				try
				{
					self.t12 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT13(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T13>.Awaiter awaiter)
			{
				try
				{
					self.t13 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			private static void TryInvokeContinuationT14(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T14>.Awaiter awaiter)
			{
				try
				{
					self.t14 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 14)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>, IUniTaskSource
		{
			private T1 t1;

			private T2 t2;

			private T3 t3;

			private T4 t4;

			private T5 t5;

			private T6 t6;

			private T7 t7;

			private T8 t8;

			private T9 t9;

			private T10 t10;

			private T11 t11;

			private T12 t12;

			private T13 t13;

			private T14 t14;

			private T15 t15;

			private int completedCount;

			private UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> core;

			public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14, UniTask<T15> task15)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T1>.Awaiter> stateTuple15 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple15.Item1, in stateTuple15.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T2>.Awaiter> stateTuple14 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple14.Item1, in stateTuple14.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T3>.Awaiter> stateTuple13 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple13.Item1, in stateTuple13.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T4>.Awaiter> stateTuple12 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T5>.Awaiter> stateTuple11 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T6>.Awaiter> stateTuple10 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T7>.Awaiter> stateTuple9 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T8>.Awaiter> stateTuple8 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T9>.Awaiter> stateTuple7 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T10>.Awaiter> stateTuple6 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T11>.Awaiter> stateTuple5 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
				}
				else
				{
					awaiter12.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T12>.Awaiter> stateTuple4 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T12>.Awaiter>)state;
						TryInvokeContinuationT12(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter12));
				}
				UniTask<T13>.Awaiter awaiter13 = task13.GetAwaiter();
				if (awaiter13.IsCompleted)
				{
					TryInvokeContinuationT13(this, in awaiter13);
				}
				else
				{
					awaiter13.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T13>.Awaiter> stateTuple3 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T13>.Awaiter>)state;
						TryInvokeContinuationT13(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter13));
				}
				UniTask<T14>.Awaiter awaiter14 = task14.GetAwaiter();
				if (awaiter14.IsCompleted)
				{
					TryInvokeContinuationT14(this, in awaiter14);
				}
				else
				{
					awaiter14.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T14>.Awaiter> stateTuple2 = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T14>.Awaiter>)state;
						TryInvokeContinuationT14(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter14));
				}
				UniTask<T15>.Awaiter awaiter15 = task15.GetAwaiter();
				if (awaiter15.IsCompleted)
				{
					TryInvokeContinuationT15(this, in awaiter15);
					return;
				}
				awaiter15.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T15>.Awaiter> stateTuple = (StateTuple<WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T15>.Awaiter>)state;
					TryInvokeContinuationT15(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter15));
			}

			private static void TryInvokeContinuationT1(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T1>.Awaiter awaiter)
			{
				try
				{
					self.t1 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT2(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T2>.Awaiter awaiter)
			{
				try
				{
					self.t2 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT3(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T3>.Awaiter awaiter)
			{
				try
				{
					self.t3 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT4(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T4>.Awaiter awaiter)
			{
				try
				{
					self.t4 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT5(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T5>.Awaiter awaiter)
			{
				try
				{
					self.t5 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT6(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T6>.Awaiter awaiter)
			{
				try
				{
					self.t6 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT7(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T7>.Awaiter awaiter)
			{
				try
				{
					self.t7 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT8(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T8>.Awaiter awaiter)
			{
				try
				{
					self.t8 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT9(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T9>.Awaiter awaiter)
			{
				try
				{
					self.t9 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT10(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T10>.Awaiter awaiter)
			{
				try
				{
					self.t10 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT11(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T11>.Awaiter awaiter)
			{
				try
				{
					self.t11 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT12(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T12>.Awaiter awaiter)
			{
				try
				{
					self.t12 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT13(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T13>.Awaiter awaiter)
			{
				try
				{
					self.t13 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT14(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T14>.Awaiter awaiter)
			{
				try
				{
					self.t14 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			private static void TryInvokeContinuationT15(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T15>.Awaiter awaiter)
			{
				try
				{
					self.t15 = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 15)
				{
					self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15));
				}
			}

			public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise<T> : IUniTaskSource<T[]>, IUniTaskSource
		{
			private T[] result;

			private int completeCount;

			private UniTaskCompletionSourceCore<T[]> core;

			public WhenAllPromise(UniTask<T>[] tasks, int tasksLength)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completeCount = 0;
				if (tasksLength == 0)
				{
					result = Array.Empty<T>();
					core.TrySetResult(result);
					return;
				}
				result = new T[tasksLength];
				for (int i = 0; i < tasksLength; i++)
				{
					UniTask<T>.Awaiter awaiter;
					try
					{
						awaiter = tasks[i].GetAwaiter();
					}
					catch (Exception error)
					{
						core.TrySetException(error);
						continue;
					}
					if (awaiter.IsCompleted)
					{
						TryInvokeContinuation(this, in awaiter, i);
						continue;
					}
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise<T>, UniTask<T>.Awaiter, int> stateTuple = (StateTuple<WhenAllPromise<T>, UniTask<T>.Awaiter, int>)state;
						TryInvokeContinuation(stateTuple.Item1, in stateTuple.Item2, stateTuple.Item3);
					}, StateTuple.Create(this, awaiter, i));
				}
			}

			private static void TryInvokeContinuation(WhenAllPromise<T> self, in UniTask<T>.Awaiter awaiter, int i)
			{
				try
				{
					self.result[i] = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completeCount) == self.result.Length)
				{
					self.core.TrySetResult(self.result);
				}
			}

			public T[] GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

			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);
			}
		}

		private sealed class WhenAllPromise : IUniTaskSource
		{
			private int completeCount;

			private int tasksLength;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public WhenAllPromise(UniTask[] tasks, int tasksLength)
			{
				TaskTracker.TrackActiveTask(this, 3);
				this.tasksLength = tasksLength;
				completeCount = 0;
				if (tasksLength == 0)
				{
					core.TrySetResult(AsyncUnit.Default);
					return;
				}
				for (int i = 0; i < tasksLength; i++)
				{
					Awaiter awaiter;
					try
					{
						awaiter = tasks[i].GetAwaiter();
					}
					catch (Exception error)
					{
						core.TrySetException(error);
						continue;
					}
					if (awaiter.IsCompleted)
					{
						TryInvokeContinuation(this, in awaiter);
						continue;
					}
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAllPromise, Awaiter> stateTuple = (StateTuple<WhenAllPromise, Awaiter>)state;
						TryInvokeContinuation(stateTuple.Item1, in stateTuple.Item2);
					}, StateTuple.Create(this, awaiter));
				}
			}

			private static void TryInvokeContinuation(WhenAllPromise self, in Awaiter awaiter)
			{
				try
				{
					awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completeCount) == self.tasksLength)
				{
					self.core.TrySetResult(AsyncUnit.Default);
				}
			}

			public void GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				core.GetResult(token);
			}

			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);
			}
		}

		private sealed class WhenAnyPromise<T1, T2> : IUniTaskSource<(int, T1 result1, T2 result2)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2>, UniTask<T1>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
					return;
				}
				awaiter2.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2>, UniTask<T2>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2>, UniTask<T2>.Awaiter>)state;
					TryInvokeContinuationT2(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter2));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result));
				}
			}

			public (int, T1 result1, T2 result2) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3>, UniTask<T1>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3>, UniTask<T2>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
					return;
				}
				awaiter3.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3>, UniTask<T3>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3>, UniTask<T3>.Awaiter>)state;
					TryInvokeContinuationT3(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter3));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T1>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T2>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T3>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
					return;
				}
				awaiter4.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T4>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4>, UniTask<T4>.Awaiter>)state;
					TryInvokeContinuationT4(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter4));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T1>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T2>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T3>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T4>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
					return;
				}
				awaiter5.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T5>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5>, UniTask<T5>.Awaiter>)state;
					TryInvokeContinuationT5(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter5));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T1>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T2>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T3>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T4>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T5>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
					return;
				}
				awaiter6.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T6>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6>, UniTask<T6>.Awaiter>)state;
					TryInvokeContinuationT6(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter6));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T1>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T2>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T3>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T4>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T5>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T6>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
					return;
				}
				awaiter7.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T7>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>, UniTask<T7>.Awaiter>)state;
					TryInvokeContinuationT7(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter7));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T1>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T2>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T3>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T4>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T5>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T6>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T7>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
					return;
				}
				awaiter8.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T8>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>, UniTask<T8>.Awaiter>)state;
					TryInvokeContinuationT8(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter8));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T1>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T2>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T3>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T4>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T5>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T6>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T7>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T8>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
					return;
				}
				awaiter9.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T9>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>, UniTask<T9>.Awaiter>)state;
					TryInvokeContinuationT9(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter9));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T1>.Awaiter> stateTuple10 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T2>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T3>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T4>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T5>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T6>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T7>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T8>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T9>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
					return;
				}
				awaiter10.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T10>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, UniTask<T10>.Awaiter>)state;
					TryInvokeContinuationT10(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter10));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9), default(T10)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result, default(T10)));
				}
			}

			private static void TryInvokeContinuationT10(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> self, in UniTask<T10>.Awaiter awaiter)
			{
				T10 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((9, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T1>.Awaiter> stateTuple11 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T2>.Awaiter> stateTuple10 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T3>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T4>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T5>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T6>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T7>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T8>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T9>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T10>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
					return;
				}
				awaiter11.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T11>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, UniTask<T11>.Awaiter>)state;
					TryInvokeContinuationT11(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter11));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9), default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result, default(T10), default(T11)));
				}
			}

			private static void TryInvokeContinuationT10(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T10>.Awaiter awaiter)
			{
				T10 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((9, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), result, default(T11)));
				}
			}

			private static void TryInvokeContinuationT11(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> self, in UniTask<T11>.Awaiter awaiter)
			{
				T11 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((10, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T1>.Awaiter> stateTuple12 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T2>.Awaiter> stateTuple11 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T3>.Awaiter> stateTuple10 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T4>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T5>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T6>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T7>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T8>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T9>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T10>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T11>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
					return;
				}
				awaiter12.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T12>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, UniTask<T12>.Awaiter>)state;
					TryInvokeContinuationT12(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter12));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9), default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result, default(T10), default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT10(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T10>.Awaiter awaiter)
			{
				T10 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((9, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), result, default(T11), default(T12)));
				}
			}

			private static void TryInvokeContinuationT11(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T11>.Awaiter awaiter)
			{
				T11 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((10, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), result, default(T12)));
				}
			}

			private static void TryInvokeContinuationT12(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> self, in UniTask<T12>.Awaiter awaiter)
			{
				T12 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((11, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T1>.Awaiter> stateTuple13 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple13.Item1, in stateTuple13.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T2>.Awaiter> stateTuple12 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T3>.Awaiter> stateTuple11 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T4>.Awaiter> stateTuple10 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T5>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T6>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T7>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T8>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T9>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T10>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T11>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
				}
				else
				{
					awaiter12.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T12>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T12>.Awaiter>)state;
						TryInvokeContinuationT12(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter12));
				}
				UniTask<T13>.Awaiter awaiter13 = task13.GetAwaiter();
				if (awaiter13.IsCompleted)
				{
					TryInvokeContinuationT13(this, in awaiter13);
					return;
				}
				awaiter13.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T13>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, UniTask<T13>.Awaiter>)state;
					TryInvokeContinuationT13(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter13));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9), default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result, default(T10), default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT10(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T10>.Awaiter awaiter)
			{
				T10 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((9, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), result, default(T11), default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT11(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T11>.Awaiter awaiter)
			{
				T11 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((10, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), result, default(T12), default(T13)));
				}
			}

			private static void TryInvokeContinuationT12(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T12>.Awaiter awaiter)
			{
				T12 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((11, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), result, default(T13)));
				}
			}

			private static void TryInvokeContinuationT13(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> self, in UniTask<T13>.Awaiter awaiter)
			{
				T13 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((12, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T1>.Awaiter> stateTuple14 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple14.Item1, in stateTuple14.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T2>.Awaiter> stateTuple13 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple13.Item1, in stateTuple13.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T3>.Awaiter> stateTuple12 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T4>.Awaiter> stateTuple11 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T5>.Awaiter> stateTuple10 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T6>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T7>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T8>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T9>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T10>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T11>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
				}
				else
				{
					awaiter12.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T12>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T12>.Awaiter>)state;
						TryInvokeContinuationT12(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter12));
				}
				UniTask<T13>.Awaiter awaiter13 = task13.GetAwaiter();
				if (awaiter13.IsCompleted)
				{
					TryInvokeContinuationT13(this, in awaiter13);
				}
				else
				{
					awaiter13.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T13>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T13>.Awaiter>)state;
						TryInvokeContinuationT13(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter13));
				}
				UniTask<T14>.Awaiter awaiter14 = task14.GetAwaiter();
				if (awaiter14.IsCompleted)
				{
					TryInvokeContinuationT14(this, in awaiter14);
					return;
				}
				awaiter14.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T14>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, UniTask<T14>.Awaiter>)state;
					TryInvokeContinuationT14(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter14));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9), default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result, default(T10), default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT10(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T10>.Awaiter awaiter)
			{
				T10 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((9, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), result, default(T11), default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT11(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T11>.Awaiter awaiter)
			{
				T11 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((10, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), result, default(T12), default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT12(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T12>.Awaiter awaiter)
			{
				T12 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((11, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), result, default(T13), default(T14)));
				}
			}

			private static void TryInvokeContinuationT13(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T13>.Awaiter awaiter)
			{
				T13 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((12, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), result, default(T14)));
				}
			}

			private static void TryInvokeContinuationT14(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> self, in UniTask<T14>.Awaiter awaiter)
			{
				T14 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((13, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)> core;

			public WhenAnyPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14, UniTask<T15> task15)
			{
				TaskTracker.TrackActiveTask(this, 3);
				completedCount = 0;
				UniTask<T1>.Awaiter awaiter = task1.GetAwaiter();
				if (awaiter.IsCompleted)
				{
					TryInvokeContinuationT1(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T1>.Awaiter> stateTuple15 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T1>.Awaiter>)state;
						TryInvokeContinuationT1(stateTuple15.Item1, in stateTuple15.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				UniTask<T2>.Awaiter awaiter2 = task2.GetAwaiter();
				if (awaiter2.IsCompleted)
				{
					TryInvokeContinuationT2(this, in awaiter2);
				}
				else
				{
					awaiter2.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T2>.Awaiter> stateTuple14 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T2>.Awaiter>)state;
						TryInvokeContinuationT2(stateTuple14.Item1, in stateTuple14.Item2);
					}, StateTuple.Create(this, awaiter2));
				}
				UniTask<T3>.Awaiter awaiter3 = task3.GetAwaiter();
				if (awaiter3.IsCompleted)
				{
					TryInvokeContinuationT3(this, in awaiter3);
				}
				else
				{
					awaiter3.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T3>.Awaiter> stateTuple13 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T3>.Awaiter>)state;
						TryInvokeContinuationT3(stateTuple13.Item1, in stateTuple13.Item2);
					}, StateTuple.Create(this, awaiter3));
				}
				UniTask<T4>.Awaiter awaiter4 = task4.GetAwaiter();
				if (awaiter4.IsCompleted)
				{
					TryInvokeContinuationT4(this, in awaiter4);
				}
				else
				{
					awaiter4.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T4>.Awaiter> stateTuple12 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T4>.Awaiter>)state;
						TryInvokeContinuationT4(stateTuple12.Item1, in stateTuple12.Item2);
					}, StateTuple.Create(this, awaiter4));
				}
				UniTask<T5>.Awaiter awaiter5 = task5.GetAwaiter();
				if (awaiter5.IsCompleted)
				{
					TryInvokeContinuationT5(this, in awaiter5);
				}
				else
				{
					awaiter5.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T5>.Awaiter> stateTuple11 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T5>.Awaiter>)state;
						TryInvokeContinuationT5(stateTuple11.Item1, in stateTuple11.Item2);
					}, StateTuple.Create(this, awaiter5));
				}
				UniTask<T6>.Awaiter awaiter6 = task6.GetAwaiter();
				if (awaiter6.IsCompleted)
				{
					TryInvokeContinuationT6(this, in awaiter6);
				}
				else
				{
					awaiter6.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T6>.Awaiter> stateTuple10 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T6>.Awaiter>)state;
						TryInvokeContinuationT6(stateTuple10.Item1, in stateTuple10.Item2);
					}, StateTuple.Create(this, awaiter6));
				}
				UniTask<T7>.Awaiter awaiter7 = task7.GetAwaiter();
				if (awaiter7.IsCompleted)
				{
					TryInvokeContinuationT7(this, in awaiter7);
				}
				else
				{
					awaiter7.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T7>.Awaiter> stateTuple9 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T7>.Awaiter>)state;
						TryInvokeContinuationT7(stateTuple9.Item1, in stateTuple9.Item2);
					}, StateTuple.Create(this, awaiter7));
				}
				UniTask<T8>.Awaiter awaiter8 = task8.GetAwaiter();
				if (awaiter8.IsCompleted)
				{
					TryInvokeContinuationT8(this, in awaiter8);
				}
				else
				{
					awaiter8.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T8>.Awaiter> stateTuple8 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T8>.Awaiter>)state;
						TryInvokeContinuationT8(stateTuple8.Item1, in stateTuple8.Item2);
					}, StateTuple.Create(this, awaiter8));
				}
				UniTask<T9>.Awaiter awaiter9 = task9.GetAwaiter();
				if (awaiter9.IsCompleted)
				{
					TryInvokeContinuationT9(this, in awaiter9);
				}
				else
				{
					awaiter9.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T9>.Awaiter> stateTuple7 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T9>.Awaiter>)state;
						TryInvokeContinuationT9(stateTuple7.Item1, in stateTuple7.Item2);
					}, StateTuple.Create(this, awaiter9));
				}
				UniTask<T10>.Awaiter awaiter10 = task10.GetAwaiter();
				if (awaiter10.IsCompleted)
				{
					TryInvokeContinuationT10(this, in awaiter10);
				}
				else
				{
					awaiter10.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T10>.Awaiter> stateTuple6 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T10>.Awaiter>)state;
						TryInvokeContinuationT10(stateTuple6.Item1, in stateTuple6.Item2);
					}, StateTuple.Create(this, awaiter10));
				}
				UniTask<T11>.Awaiter awaiter11 = task11.GetAwaiter();
				if (awaiter11.IsCompleted)
				{
					TryInvokeContinuationT11(this, in awaiter11);
				}
				else
				{
					awaiter11.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T11>.Awaiter> stateTuple5 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T11>.Awaiter>)state;
						TryInvokeContinuationT11(stateTuple5.Item1, in stateTuple5.Item2);
					}, StateTuple.Create(this, awaiter11));
				}
				UniTask<T12>.Awaiter awaiter12 = task12.GetAwaiter();
				if (awaiter12.IsCompleted)
				{
					TryInvokeContinuationT12(this, in awaiter12);
				}
				else
				{
					awaiter12.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T12>.Awaiter> stateTuple4 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T12>.Awaiter>)state;
						TryInvokeContinuationT12(stateTuple4.Item1, in stateTuple4.Item2);
					}, StateTuple.Create(this, awaiter12));
				}
				UniTask<T13>.Awaiter awaiter13 = task13.GetAwaiter();
				if (awaiter13.IsCompleted)
				{
					TryInvokeContinuationT13(this, in awaiter13);
				}
				else
				{
					awaiter13.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T13>.Awaiter> stateTuple3 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T13>.Awaiter>)state;
						TryInvokeContinuationT13(stateTuple3.Item1, in stateTuple3.Item2);
					}, StateTuple.Create(this, awaiter13));
				}
				UniTask<T14>.Awaiter awaiter14 = task14.GetAwaiter();
				if (awaiter14.IsCompleted)
				{
					TryInvokeContinuationT14(this, in awaiter14);
				}
				else
				{
					awaiter14.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T14>.Awaiter> stateTuple2 = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T14>.Awaiter>)state;
						TryInvokeContinuationT14(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter14));
				}
				UniTask<T15>.Awaiter awaiter15 = task15.GetAwaiter();
				if (awaiter15.IsCompleted)
				{
					TryInvokeContinuationT15(this, in awaiter15);
					return;
				}
				awaiter15.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T15>.Awaiter> stateTuple = (StateTuple<WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, UniTask<T15>.Awaiter>)state;
					TryInvokeContinuationT15(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter15));
			}

			private static void TryInvokeContinuationT1(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T1>.Awaiter awaiter)
			{
				T1 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((0, result, default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT2(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T2>.Awaiter awaiter)
			{
				T2 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((1, default(T1), result, default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT3(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T3>.Awaiter awaiter)
			{
				T3 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((2, default(T1), default(T2), result, default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT4(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T4>.Awaiter awaiter)
			{
				T4 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((3, default(T1), default(T2), default(T3), result, default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT5(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T5>.Awaiter awaiter)
			{
				T5 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((4, default(T1), default(T2), default(T3), default(T4), result, default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT6(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T6>.Awaiter awaiter)
			{
				T6 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((5, default(T1), default(T2), default(T3), default(T4), default(T5), result, default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT7(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T7>.Awaiter awaiter)
			{
				T7 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((6, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), result, default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT8(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T8>.Awaiter awaiter)
			{
				T8 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((7, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), result, default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT9(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T9>.Awaiter awaiter)
			{
				T9 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((8, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), result, default(T10), default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT10(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T10>.Awaiter awaiter)
			{
				T10 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((9, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), result, default(T11), default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT11(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T11>.Awaiter awaiter)
			{
				T11 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((10, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), result, default(T12), default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT12(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T12>.Awaiter awaiter)
			{
				T12 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((11, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), result, default(T13), default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT13(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T13>.Awaiter awaiter)
			{
				T13 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((12, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), result, default(T14), default(T15)));
				}
			}

			private static void TryInvokeContinuationT14(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T14>.Awaiter awaiter)
			{
				T14 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((13, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), result, default(T15)));
				}
			}

			private static void TryInvokeContinuationT15(WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> self, in UniTask<T15>.Awaiter awaiter)
			{
				T15 result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((14, default(T1), default(T2), default(T3), default(T4), default(T5), default(T6), default(T7), default(T8), default(T9), default(T10), default(T11), default(T12), default(T13), default(T14), result));
				}
			}

			public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyLRPromise<T> : IUniTaskSource<(bool, T)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(bool, T)> core;

			public WhenAnyLRPromise(UniTask<T> leftTask, UniTask rightTask)
			{
				TaskTracker.TrackActiveTask(this, 3);
				UniTask<T>.Awaiter awaiter;
				try
				{
					awaiter = leftTask.GetAwaiter();
				}
				catch (Exception error)
				{
					core.TrySetException(error);
					goto IL_0068;
				}
				if (awaiter.IsCompleted)
				{
					TryLeftInvokeContinuation(this, in awaiter);
				}
				else
				{
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyLRPromise<T>, UniTask<T>.Awaiter> stateTuple2 = (StateTuple<WhenAnyLRPromise<T>, UniTask<T>.Awaiter>)state;
						TryLeftInvokeContinuation(stateTuple2.Item1, in stateTuple2.Item2);
					}, StateTuple.Create(this, awaiter));
				}
				goto IL_0068;
				IL_0068:
				Awaiter awaiter2;
				try
				{
					awaiter2 = rightTask.GetAwaiter();
				}
				catch (Exception error2)
				{
					core.TrySetException(error2);
					return;
				}
				if (awaiter2.IsCompleted)
				{
					TryRightInvokeContinuation(this, in awaiter2);
					return;
				}
				awaiter2.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<WhenAnyLRPromise<T>, Awaiter> stateTuple = (StateTuple<WhenAnyLRPromise<T>, Awaiter>)state;
					TryRightInvokeContinuation(stateTuple.Item1, in stateTuple.Item2);
				}, StateTuple.Create(this, awaiter2));
			}

			private static void TryLeftInvokeContinuation(WhenAnyLRPromise<T> self, in UniTask<T>.Awaiter awaiter)
			{
				T result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((true, result));
				}
			}

			private static void TryRightInvokeContinuation(WhenAnyLRPromise<T> self, in Awaiter awaiter)
			{
				try
				{
					awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((false, default(T)));
				}
			}

			public (bool, T) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise<T> : IUniTaskSource<(int, T)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(int, T)> core;

			public WhenAnyPromise(UniTask<T>[] tasks, int tasksLength)
			{
				if (tasksLength == 0)
				{
					throw new ArgumentException("The tasks argument contains no tasks.");
				}
				TaskTracker.TrackActiveTask(this, 3);
				for (int i = 0; i < tasksLength; i++)
				{
					UniTask<T>.Awaiter awaiter;
					try
					{
						awaiter = tasks[i].GetAwaiter();
					}
					catch (Exception error)
					{
						core.TrySetException(error);
						continue;
					}
					if (awaiter.IsCompleted)
					{
						TryInvokeContinuation(this, in awaiter, i);
						continue;
					}
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise<T>, UniTask<T>.Awaiter, int> stateTuple = (StateTuple<WhenAnyPromise<T>, UniTask<T>.Awaiter, int>)state;
						TryInvokeContinuation(stateTuple.Item1, in stateTuple.Item2, stateTuple.Item3);
					}, StateTuple.Create(this, awaiter, i));
				}
			}

			private static void TryInvokeContinuation(WhenAnyPromise<T> self, in UniTask<T>.Awaiter awaiter, int i)
			{
				T result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult((i, result));
				}
			}

			public (int, T) GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class WhenAnyPromise : IUniTaskSource<int>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<int> core;

			public WhenAnyPromise(UniTask[] tasks, int tasksLength)
			{
				if (tasksLength == 0)
				{
					throw new ArgumentException("The tasks argument contains no tasks.");
				}
				TaskTracker.TrackActiveTask(this, 3);
				for (int i = 0; i < tasksLength; i++)
				{
					Awaiter awaiter;
					try
					{
						awaiter = tasks[i].GetAwaiter();
					}
					catch (Exception error)
					{
						core.TrySetException(error);
						continue;
					}
					if (awaiter.IsCompleted)
					{
						TryInvokeContinuation(this, in awaiter, i);
						continue;
					}
					awaiter.SourceOnCompleted(delegate(object state)
					{
						using StateTuple<WhenAnyPromise, Awaiter, int> stateTuple = (StateTuple<WhenAnyPromise, Awaiter, int>)state;
						TryInvokeContinuation(stateTuple.Item1, in stateTuple.Item2, stateTuple.Item3);
					}, StateTuple.Create(this, awaiter, i));
				}
			}

			private static void TryInvokeContinuation(WhenAnyPromise self, in Awaiter awaiter, int i)
			{
				try
				{
					awaiter.GetResult();
				}
				catch (Exception error)
				{
					self.core.TrySetException(error);
					return;
				}
				if (Interlocked.Increment(ref self.completedCount) == 1)
				{
					self.core.TrySetResult(i);
				}
			}

			public int GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				GC.SuppressFinalize(this);
				return core.GetResult(token);
			}

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

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

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

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

		private sealed class AsyncUnitSource : IUniTaskSource<AsyncUnit>, IUniTaskSource
		{
			private readonly IUniTaskSource source;

			public AsyncUnitSource(IUniTaskSource source)
			{
				this.source = source;
			}

			public AsyncUnit GetResult(short token)
			{
				source.GetResult(token);
				return AsyncUnit.Default;
			}

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

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

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

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

		private sealed class IsCanceledSource : IUniTaskSource<bool>, IUniTaskSource
		{
			private readonly IUniTaskSource source;

			public IsCanceledSource(IUniTaskSource source)
			{
				this.source = source;
			}

			public bool GetResult(short token)
			{
				if (source.GetStatus(token) == UniTaskStatus.Canceled)
				{
					return true;
				}
				source.GetResult(token);
				return false;
			}

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

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

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

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

		private sealed class MemoizeSource : IUniTaskSource
		{
			private IUniTaskSource source;

			private ExceptionDispatchInfo exception;

			private UniTaskStatus status;

			public MemoizeSource(IUniTaskSource source)
			{
				this.source = source;
			}

			public void GetResult(short token)
			{
				if (source == null)
				{
					if (exception != null)
					{
						exception.Throw();
					}
					return;
				}
				try
				{
					source.GetResult(token);
					status = UniTaskStatus.Succeeded;
				}
				catch (Exception ex)
				{
					exception = ExceptionDispatchInfo.Capture(ex);
					if (ex is OperationCanceledException)
					{
						status = UniTaskStatus.Canceled;
					}
					else
					{
						status = UniTaskStatus.Faulted;
					}
					throw;
				}
				finally
				{
					source = null;
				}
			}

			public UniTaskStatus GetStatus(short token)
			{
				if (source == null)
				{
					return status;
				}
				return source.GetStatus(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				if (source == null)
				{
					continuation(state);
				}
				else
				{
					source.OnCompleted(continuation, state, token);
				}
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				if (source == null)
				{
					return status;
				}
				return source.UnsafeGetStatus();
			}
		}

		public readonly struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly UniTask task;

			public bool IsCompleted
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				[DebuggerHidden]
				get
				{
					return task.Status.IsCompleted();
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public Awaiter(in UniTask task)
			{
				this.task = task;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void GetResult()
			{
				if (task.source != null)
				{
					task.source.GetResult(task.token);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void OnCompleted(Action continuation)
			{
				if (task.source == null)
				{
					continuation();
				}
				else
				{
					task.source.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void UnsafeOnCompleted(Action continuation)
			{
				if (task.source == null)
				{
					continuation();
				}
				else
				{
					task.source.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void SourceOnCompleted(Action<object> continuation, object state)
			{
				if (task.source == null)
				{
					continuation(state);
				}
				else
				{
					task.source.OnCompleted(continuation, state, task.token);
				}
			}
		}

		private static readonly UniTask CanceledUniTask = ((Func<UniTask>)(() => new UniTask(new CanceledResultSource(CancellationToken.None), 0)))();

		public static readonly UniTask CompletedTask = default(UniTask);

		private readonly IUniTaskSource source;

		private readonly short token;

		public UniTaskStatus Status
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			get
			{
				if (source == null)
				{
					return UniTaskStatus.Succeeded;
				}
				return source.GetStatus(token);
			}
		}

		public static IEnumerator ToCoroutine(Func<UniTask> taskFactory)
		{
			return taskFactory().ToCoroutine();
		}

		public static YieldAwaitable Yield()
		{
			return new YieldAwaitable(PlayerLoopTiming.Update);
		}

		public static YieldAwaitable Yield(PlayerLoopTiming timing)
		{
			return new YieldAwaitable(timing);
		}

		public static UniTask Yield(CancellationToken cancellationToken)
		{
			short num;
			return new UniTask(YieldPromise.Create(PlayerLoopTiming.Update, cancellationToken, out num), num);
		}

		public static UniTask Yield(PlayerLoopTiming timing, CancellationToken cancellationToken)
		{
			short num;
			return new UniTask(YieldPromise.Create(timing, cancellationToken, out num), num);
		}

		public static UniTask NextFrame()
		{
			short num;
			return new UniTask(NextFramePromise.Create(PlayerLoopTiming.Update, CancellationToken.None, out num), num);
		}

		public static UniTask NextFrame(PlayerLoopTiming timing)
		{
			short num;
			return new UniTask(NextFramePromise.Create(timing, CancellationToken.None, out num), num);
		}

		public static UniTask NextFrame(CancellationToken cancellationToken)
		{
			short num;
			return new UniTask(NextFramePromise.Create(PlayerLoopTiming.Update, cancellationToken, out num), num);
		}

		public static UniTask NextFrame(PlayerLoopTiming timing, CancellationToken cancellationToken)
		{
			short num;
			return new UniTask(NextFramePromise.Create(timing, cancellationToken, out num), num);
		}

		[Obsolete("Use WaitForEndOfFrame(MonoBehaviour) instead or UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate). Equivalent for coroutine's WaitForEndOfFrame requires MonoBehaviour(runner of Coroutine).")]
		public static YieldAwaitable WaitForEndOfFrame()
		{
			return Yield(PlayerLoopTiming.LastPostLateUpdate);
		}

		[Obsolete("Use WaitForEndOfFrame(MonoBehaviour) instead or UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate). Equivalent for coroutine's WaitForEndOfFrame requires MonoBehaviour(runner of Coroutine).")]
		public static UniTask WaitForEndOfFrame(CancellationToken cancellationToken)
		{
			return Yield(PlayerLoopTiming.LastPostLateUpdate, cancellationToken);
		}

		public static UniTask WaitForEndOfFrame(MonoBehaviour coroutineRunner, CancellationToken cancellationToken = default(CancellationToken))
		{
			short num;
			return new UniTask(WaitForEndOfFramePromise.Create(coroutineRunner, cancellationToken, out num), num);
		}

		public static YieldAwaitable WaitForFixedUpdate()
		{
			return Yield(PlayerLoopTiming.LastFixedUpdate);
		}

		public static UniTask WaitForFixedUpdate(CancellationToken cancellationToken)
		{
			return Yield(PlayerLoopTiming.LastFixedUpdate, cancellationToken);
		}

		public static UniTask DelayFrame(int delayFrameCount, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (delayFrameCount < 0)
			{
				throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. delayFrameCount:" + delayFrameCount);
			}
			short num;
			return new UniTask(DelayFramePromise.Create(delayFrameCount, delayTiming, cancellationToken, out num), num);
		}

		public static UniTask Delay(int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			return Delay(TimeSpan.FromMilliseconds(millisecondsDelay), ignoreTimeScale, delayTiming, cancellationToken);
		}

		public static UniTask Delay(TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			DelayType delayType = (ignoreTimeScale ? DelayType.UnscaledDeltaTime : DelayType.DeltaTime);
			return Delay(delayTimeSpan, delayType, delayTiming, cancellationToken);
		}

		public static UniTask Delay(int millisecondsDelay, DelayType delayType, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			return Delay(TimeSpan.FromMilliseconds(millisecondsDelay), delayType, delayTiming, cancellationToken);
		}

		public static UniTask Delay(TimeSpan delayTimeSpan, DelayType delayType, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (delayTimeSpan < TimeSpan.Zero)
			{
				TimeSpan timeSpan = delayTimeSpan;
				throw new ArgumentOutOfRangeException("Delay does not allow minus delayTimeSpan. delayTimeSpan:" + timeSpan);
			}
			if (PlayerLoopHelper.IsMainThread && !EditorApplication.isPlaying)
			{
				delayType = DelayType.Realtime;
			}
			short num;
			short num2;
			short num3;
			return delayType switch
			{
				DelayType.UnscaledDeltaTime => new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out num), num), 
				DelayType.Realtime => new UniTask(DelayRealtimePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out num2), num2), 
				_ => new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out num3), num3), 
			};
		}

		public static UniTask FromException(Exception ex)
		{
			if (ex is OperationCanceledException ex2)
			{
				return FromCanceled(ex2.CancellationToken);
			}
			return new UniTask(new ExceptionResultSource(ex), 0);
		}

		public static UniTask<T> FromException<T>(Exception ex)
		{
			if (ex is OperationCanceledException ex2)
			{
				return FromCanceled<T>(ex2.CancellationToken);
			}
			return new UniTask<T>(new ExceptionResultSource<T>(ex), 0);
		}

		public static UniTask<T> FromResult<T>(T value)
		{
			return new UniTask<T>(value);
		}

		public static UniTask FromCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken == CancellationToken.None)
			{
				return CanceledUniTask;
			}
			return new UniTask(new CanceledResultSource(cancellationToken), 0);
		}

		public static UniTask<T> FromCanceled<T>(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken == CancellationToken.None)
			{
				return CanceledUniTaskCache<T>.Task;
			}
			return new UniTask<T>(new CanceledResultSource<T>(cancellationToken), 0);
		}

		public static UniTask Create(Func<UniTask> factory)
		{
			return factory();
		}

		public static UniTask<T> Create<T>(Func<UniTask<T>> factory)
		{
			return factory();
		}

		public static AsyncLazy Lazy(Func<UniTask> factory)
		{
			return new AsyncLazy(factory);
		}

		public static AsyncLazy<T> Lazy<T>(Func<UniTask<T>> factory)
		{
			return new AsyncLazy<T>(factory);
		}

		public static void Void(Func<UniTaskVoid> asyncAction)
		{
			asyncAction().Forget();
		}

		public static void Void(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
		{
			asyncAction(cancellationToken).Forget();
		}

		public static void Void<T>(Func<T, UniTaskVoid> asyncAction, T state)
		{
			asyncAction(state).Forget();
		}

		public static Action Action(Func<UniTaskVoid> asyncAction)
		{
			return delegate
			{
				asyncAction().Forget();
			};
		}

		public static Action Action(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
		{
			return delegate
			{
				asyncAction(cancellationToken).Forget();
			};
		}

		public static UnityAction UnityAction(Func<UniTaskVoid> asyncAction)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return (UnityAction)delegate
			{
				asyncAction().Forget();
			};
		}

		public static UnityAction UnityAction(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return (UnityAction)delegate
			{
				asyncAction(cancellationToken).Forget();
			};
		}

		public static UniTask Defer(Func<UniTask> factory)
		{
			return new UniTask(new DeferPromise(factory), 0);
		}

		public static UniTask<T> Defer<T>(Func<UniTask<T>> factory)
		{
			return new UniTask<T>(new DeferPromise<T>(factory), 0);
		}

		public static UniTask Never(CancellationToken cancellationToken)
		{
			return new UniTask<AsyncUnit>(new NeverPromise<AsyncUnit>(cancellationToken), 0);
		}

		public static UniTask<T> Never<T>(CancellationToken cancellationToken)
		{
			return new UniTask<T>(new NeverPromise<T>(cancellationToken), 0);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask Run(Action action, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(action, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask Run(Action<object> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(action, state, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask Run(Func<UniTask> action, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(action, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask Run(Func<object, UniTask> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(action, state, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask<T> Run<T>(Func<T> func, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(func, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask<T> Run<T>(Func<UniTask<T>> func, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(func, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(func, state, configureAwait, cancellationToken);
		}

		[Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")]
		public static UniTask<T> Run<T>(Func<object, UniTask<T>> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return RunOnThreadPool(func, state, configureAwait, cancellationToken);
		}

		public static async UniTask RunOnThreadPool(Action action, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (configureAwait)
			{
				try
				{
					action();
				}
				finally
				{
					await Yield();
				}
			}
			else
			{
				action();
			}
			cancellationToken.ThrowIfCancellationRequested();
		}

		public static async UniTask RunOnThreadPool(Action<object> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (configureAwait)
			{
				try
				{
					action(state);
				}
				finally
				{
					await Yield();
				}
			}
			else
			{
				action(state);
			}
			cancellationToken.ThrowIfCancellationRequested();
		}

		public static async UniTask RunOnThreadPool(Func<UniTask> action, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (!configureAwait)
			{
				await action();
			}
			else
			{
				try
				{
					await action();
				}
				finally
				{
					await Yield();
				}
			}
			cancellationToken.ThrowIfCancellationRequested();
		}

		public static async UniTask RunOnThreadPool(Func<object, UniTask> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (!configureAwait)
			{
				await action(state);
			}
			else
			{
				try
				{
					await action(state);
				}
				finally
				{
					await Yield();
				}
			}
			cancellationToken.ThrowIfCancellationRequested();
		}

		public static async UniTask<T> RunOnThreadPool<T>(Func<T> func, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (configureAwait)
			{
				T result;
				try
				{
					result = func();
				}
				finally
				{
					await Yield();
					cancellationToken.ThrowIfCancellationRequested();
				}
				return result;
			}
			return func();
		}

		public static async UniTask<T> RunOnThreadPool<T>(Func<UniTask<T>> func, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (configureAwait)
			{
				T result;
				try
				{
					result = await func();
				}
				finally
				{
					cancellationToken.ThrowIfCancellationRequested();
					await Yield();
					cancellationToken.ThrowIfCancellationRequested();
				}
				return result;
			}
			T result2 = await func();
			cancellationToken.ThrowIfCancellationRequested();
			return result2;
		}

		public static async UniTask<T> RunOnThreadPool<T>(Func<object, T> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (configureAwait)
			{
				T result;
				try
				{
					result = func(state);
				}
				finally
				{
					await Yield();
					cancellationToken.ThrowIfCancellationRequested();
				}
				return result;
			}
			return func(state);
		}

		public static async UniTask<T> RunOnThreadPool<T>(Func<object, UniTask<T>> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			cancellationToken.ThrowIfCancellationRequested();
			await SwitchToThreadPool();
			cancellationToken.ThrowIfCancellationRequested();
			if (configureAwait)
			{
				T result;
				try
				{
					result = await func(state);
				}
				finally
				{
					cancellationToken.ThrowIfCancellationRequested();
					await Yield();
					cancellationToken.ThrowIfCancellationRequested();
				}
				return result;
			}
			T result2 = await func(state);
			cancellationToken.ThrowIfCancellationRequested();
			return result2;
		}

		public static SwitchToMainThreadAwaitable SwitchToMainThread(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new SwitchToMainThreadAwaitable(PlayerLoopTiming.Update, cancellationToken);
		}

		public static SwitchToMainThreadAwaitable SwitchToMainThread(PlayerLoopTiming timing, CancellationToken cancellationToken = default(CancellationToken))
		{
			return new SwitchToMainThreadAwaitable(timing, cancellationToken);
		}

		public static ReturnToMainThread ReturnToMainThread(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new ReturnToMainThread(PlayerLoopTiming.Update, cancellationToken);
		}

		public static ReturnToMainThread ReturnToMainThread(PlayerLoopTiming timing, CancellationToken cancellationToken = default(CancellationToken))
		{
			return new ReturnToMainThread(timing, cancellationToken);
		}

		public static void Post(Action action, PlayerLoopTiming timing = PlayerLoopTiming.Update)
		{
			PlayerLoopHelper.AddContinuation(timing, action);
		}

		public static SwitchToThreadPoolAwaitable SwitchToThreadPool()
		{
			return default(SwitchToThreadPoolAwaitable);
		}

		public static SwitchToTaskPoolAwaitable SwitchToTaskPool()
		{
			return default(SwitchToTaskPoolAwaitable);
		}

		public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext synchronizationContext, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(synchronizationContext, "synchronizationContext");
			return new SwitchToSynchronizationContextAwaitable(synchronizationContext, cancellationToken);
		}

		public static ReturnToSynchronizationContext ReturnToSynchronizationContext(SynchronizationContext synchronizationContext, CancellationToken cancellationToken = default(CancellationToken))
		{
			return new ReturnToSynchronizationContext(synchronizationContext, dontPostWhenSameContext: false, cancellationToken);
		}

		public static ReturnToSynchronizationContext ReturnToCurrentSynchronizationContext(bool dontPostWhenSameContext = true, CancellationToken cancellationToken = default(CancellationToken))
		{
			return new ReturnToSynchronizationContext(SynchronizationContext.Current, dontPostWhenSameContext, cancellationToken);
		}

		public static UniTask WaitUntil(Func<bool> predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			short num;
			return new UniTask(WaitUntilPromise.Create(predicate, timing, cancellationToken, out num), num);
		}

		public static UniTask WaitWhile(Func<bool> predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			short num;
			return new UniTask(WaitWhilePromise.Create(predicate, timing, cancellationToken, out num), num);
		}

		public static UniTask WaitUntilCanceled(CancellationToken cancellationToken, PlayerLoopTiming timing = PlayerLoopTiming.Update)
		{
			short num;
			return new UniTask(WaitUntilCanceledPromise.Create(cancellationToken, timing, out num), num);
		}

		public static UniTask<U> WaitUntilValueChanged<T, U>(T target, Func<T, U> monitorFunction, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer<U> equalityComparer = null, CancellationToken cancellationToken = default(CancellationToken)) where T : class
		{
			short num;
			return new UniTask<U>((target is Object) ? WaitUntilValueChangedUnityObjectPromise<T, U>.Create(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken, out num) : WaitUntilValueChangedStandardObjectPromise<T, U>.Create(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken, out num), num);
		}

		public static UniTask<(T1, T2)> WhenAll<T1, T2>(UniTask<T1> task1, UniTask<T2> task2)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2)>(new WhenAllPromise<T1, T2>(task1, task2), 0);
		}

		public static UniTask<(T1, T2, T3)> WhenAll<T1, T2, T3>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3)>(new WhenAllPromise<T1, T2, T3>(task1, task2, task3), 0);
		}

		public static UniTask<(T1, T2, T3, T4)> WhenAll<T1, T2, T3, T4>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4)>(new WhenAllPromise<T1, T2, T3, T4>(task1, task2, task3, task4), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5)> WhenAll<T1, T2, T3, T4, T5>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5)>(new WhenAllPromise<T1, T2, T3, T4, T5>(task1, task2, task3, task4, task5), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6)> WhenAll<T1, T2, T3, T4, T5, T6>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6>(task1, task2, task3, task4, task5, task6), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7)> WhenAll<T1, T2, T3, T4, T5, T6, T7>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>(task1, task2, task3, task4, task5, task6, task7), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8>(task1, task2, task3, task4, task5, task6, task7, task8), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>(task1, task2, task3, task4, task5, task6, task7, task8, task9), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully() && task13.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult(), task13.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully() && task13.Status.IsCompletedSuccessfully() && task14.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult(), task13.GetAwaiter().GetResult(), task14.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14), 0);
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> WhenAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14, UniTask<T15> task15)
		{
			if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully() && task13.Status.IsCompletedSuccessfully() && task14.Status.IsCompletedSuccessfully() && task15.Status.IsCompletedSuccessfully())
			{
				return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult(), task13.GetAwaiter().GetResult(), task14.GetAwaiter().GetResult(), task15.GetAwaiter().GetResult()));
			}
			return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>(new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14, task15), 0);
		}

		public static UniTask<T[]> WhenAll<T>(params UniTask<T>[] tasks)
		{
			if (tasks.Length == 0)
			{
				return FromResult(Array.Empty<T>());
			}
			return new UniTask<T[]>(new WhenAllPromise<T>(tasks, tasks.Length), 0);
		}

		public static UniTask<T[]> WhenAll<T>(IEnumerable<UniTask<T>> tasks)
		{
			ArrayPoolUtil.RentArray<UniTask<T>> rentArray = ArrayPoolUtil.Materialize(tasks);
			try
			{
				return new UniTask<T[]>(new WhenAllPromise<T>(rentArray.Array, rentArray.Length), 0);
			}
			finally
			{
				((IDisposable)rentArray).Dispose();
			}
		}

		public static UniTask WhenAll(params UniTask[] tasks)
		{
			if (tasks.Length == 0)
			{
				return CompletedTask;
			}
			return new UniTask(new WhenAllPromise(tasks, tasks.Length), 0);
		}

		public static UniTask WhenAll(IEnumerable<UniTask> tasks)
		{
			ArrayPoolUtil.RentArray<UniTask> rentArray = ArrayPoolUtil.Materialize(tasks);
			try
			{
				return new UniTask(new WhenAllPromise(rentArray.Array, rentArray.Length), 0);
			}
			finally
			{
				((IDisposable)rentArray).Dispose();
			}
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2)> WhenAny<T1, T2>(UniTask<T1> task1, UniTask<T2> task2)
		{
			return new UniTask<(int, T1, T2)>(new WhenAnyPromise<T1, T2>(task1, task2), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3)> WhenAny<T1, T2, T3>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
		{
			return new UniTask<(int, T1, T2, T3)>(new WhenAnyPromise<T1, T2, T3>(task1, task2, task3), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4)> WhenAny<T1, T2, T3, T4>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
		{
			return new UniTask<(int, T1, T2, T3, T4)>(new WhenAnyPromise<T1, T2, T3, T4>(task1, task2, task3, task4), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> WhenAny<T1, T2, T3, T4, T5>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5)>(new WhenAnyPromise<T1, T2, T3, T4, T5>(task1, task2, task3, task4, task5), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> WhenAny<T1, T2, T3, T4, T5, T6>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6>(task1, task2, task3, task4, task5, task6), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> WhenAny<T1, T2, T3, T4, T5, T6, T7>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7>(task1, task2, task3, task4, task5, task6, task7), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8>(task1, task2, task3, task4, task5, task6, task7, task8), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9>(task1, task2, task3, task4, task5, task6, task7, task8, task9), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14), 0);
		}

		public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)> WhenAny<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14, UniTask<T15> task15)
		{
			return new UniTask<(int, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>(new WhenAnyPromise<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14, task15), 0);
		}

		public static UniTask<(bool hasResultLeft, T result)> WhenAny<T>(UniTask<T> leftTask, UniTask rightTask)
		{
			return new UniTask<(bool, T)>(new WhenAnyLRPromise<T>(leftTask, rightTask), 0);
		}

		public static UniTask<(int winArgumentIndex, T result)> WhenAny<T>(params UniTask<T>[] tasks)
		{
			return new UniTask<(int, T)>(new WhenAnyPromise<T>(tasks, tasks.Length), 0);
		}

		public static UniTask<(int winArgumentIndex, T result)> WhenAny<T>(IEnumerable<UniTask<T>> tasks)
		{
			ArrayPoolUtil.RentArray<UniTask<T>> rentArray = ArrayPoolUtil.Materialize(tasks);
			try
			{
				return new UniTask<(int, T)>(new WhenAnyPromise<T>(rentArray.Array, rentArray.Length), 0);
			}
			finally
			{
				((IDisposable)rentArray).Dispose();
			}
		}

		public static UniTask<int> WhenAny(params UniTask[] tasks)
		{
			return new UniTask<int>(new WhenAnyPromise(tasks, tasks.Length), 0);
		}

		public static UniTask<int> WhenAny(IEnumerable<UniTask> tasks)
		{
			ArrayPoolUtil.RentArray<UniTask> rentArray = ArrayPoolUtil.Materialize(tasks);
			try
			{
				return new UniTask<int>(new WhenAnyPromise(rentArray.Array, rentArray.Length), 0);
			}
			finally
			{
				((IDisposable)rentArray).Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public UniTask(IUniTaskSource source, short token)
		{
			this.source = source;
			this.token = token;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public Awaiter GetAwaiter()
		{
			return new Awaiter(in this);
		}

		public UniTask<bool> SuppressCancellationThrow()
		{
			return Status switch
			{
				UniTaskStatus.Succeeded => CompletedTasks.False, 
				UniTaskStatus.Canceled => CompletedTasks.True, 
				_ => new UniTask<bool>(new IsCanceledSource(source), token), 
			};
		}

		public override string ToString()
		{
			if (source == null)
			{
				return "()";
			}
			return "(" + source.UnsafeGetStatus().ToString() + ")";
		}

		public UniTask Preserve()
		{
			if (source == null)
			{
				return this;
			}
			return new UniTask(new MemoizeSource(source), token);
		}

		public UniTask<AsyncUnit> AsAsyncUnitUniTask()
		{
			if (source == null)
			{
				return CompletedTasks.AsyncUnit;
			}
			if (source.GetStatus(token).IsCompletedSuccessfully())
			{
				source.GetResult(token);
				return CompletedTasks.AsyncUnit;
			}
			if (source is IUniTaskSource<AsyncUnit> uniTaskSource)
			{
				return new UniTask<AsyncUnit>(uniTaskSource, token);
			}
			return new UniTask<AsyncUnit>(new AsyncUnitSource(source), token);
		}
	}
	public enum DelayType
	{
		DeltaTime,
		UnscaledDeltaTime,
		Realtime
	}
	public readonly struct YieldAwaitable
	{
		public readonly struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly PlayerLoopTiming timing;

			public bool IsCompleted => false;

			public Awaiter(PlayerLoopTiming timing)
			{
				this.timing = timing;
			}

			public void GetResult()
			{
			}

			public void OnCompleted(Action continuation)
			{
				PlayerLoopHelper.AddContinuation(timing, continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				PlayerLoopHelper.AddContinuation(timing, continuation);
			}
		}

		private readonly PlayerLoopTiming timing;

		public YieldAwaitable(PlayerLoopTiming timing)
		{
			this.timing = timing;
		}

		public Awaiter GetAwaiter()
		{
			return new Awaiter(timing);
		}

		public UniTask ToUniTask()
		{
			return UniTask.Yield(timing, CancellationToken.None);
		}
	}
	internal static class CompletedTasks
	{
		public static readonly UniTask<AsyncUnit> AsyncUnit = UniTask.FromResult(Cysharp.Threading.Tasks.AsyncUnit.Default);

		public static readonly UniTask<bool> True = UniTask.FromResult(value: true);

		public static readonly UniTask<bool> False = UniTask.FromResult(value: false);

		public static readonly UniTask<int> Zero = UniTask.FromResult(0);

		public static readonly UniTask<int> MinusOne = UniTask.FromResult(-1);

		public static readonly UniTask<int> One = UniTask.FromResult(1);
	}
	public struct SwitchToMainThreadAwaitable
	{
		public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly PlayerLoopTiming playerLoopTiming;

			private readonly CancellationToken cancellationToken;

			public bool IsCompleted
			{
				get
				{
					int managedThreadId = Thread.CurrentThread.ManagedThreadId;
					if (PlayerLoopHelper.MainThreadId == managedThreadId)
					{
						return true;
					}
					return false;
				}
			}

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

			public void GetResult()
			{
				CancellationToken cancellationToken = this.cancellationToken;
				cancellationToken.ThrowIfCancellationRequested();
			}

			public void OnCompleted(Action continuation)
			{
				PlayerLoopHelper.AddContinuation(playerLoopTiming, continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				PlayerLoopHelper.AddContinuation(playerLoopTiming, continuation);
			}
		}

		private readonly PlayerLoopTiming playerLoopTiming;

		private readonly CancellationToken cancellationToken;

		public SwitchToMainThreadAwaitable(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken)
		{
			this.playerLoopTiming = playerLoopTiming;
			this.cancellationToken = cancellationToken;
		}

		public Awaiter GetAwaiter()
		{
			return new Awaiter(playerLoopTiming, cancellationToken);
		}
	}
	public struct ReturnToMainThread
	{
		public readonly struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly PlayerLoopTiming timing;

			private readonly CancellationToken cancellationToken;

			public bool IsCompleted => PlayerLoopHelper.MainThreadId == Thread.CurrentThread.ManagedThreadId;

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

			public Awaiter GetAwaiter()
			{
				return this;
			}

			public void GetResult()
			{
				CancellationToken cancellationToken = this.cancellationToken;
				cancellationToken.ThrowIfCancellationRequested();
			}

			public void OnCompleted(Action continuation)
			{
				PlayerLoopHelper.AddContinuation(timing, continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				PlayerLoopHelper.AddContinuation(timing, continuation);
			}
		}

		private readonly PlayerLoopTiming playerLoopTiming;

		private readonly CancellationToken cancellationToken;

		public ReturnToMainThread(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken)
		{
			this.playerLoopTiming = playerLoopTiming;
			this.cancellationToken = cancellationToken;
		}

		public Awaiter DisposeAsync()
		{
			return new Awaiter(playerLoopTiming, cancellationToken);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct SwitchToThreadPoolAwaitable
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private static readonly WaitCallback switchToCallback = Callback;

			public bool IsCompleted => false;

			public void GetResult()
			{
			}

			public void OnCompleted(Action continuation)
			{
				ThreadPool.QueueUserWorkItem(switchToCallback, continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
			}

			private static void Callback(object state)
			{
				((Action)state)();
			}
		}

		public Awaiter GetAwaiter()
		{
			return default(Awaiter);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct SwitchToTaskPoolAwaitable
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private static readonly Action<object> switchToCallback = Callback;

			public bool IsCompleted => false;

			public void GetResult()
			{
			}

			public void OnCompleted(Action continuation)
			{
				Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			}

			private static void Callback(object state)
			{
				((Action)state)();
			}
		}

		public Awaiter GetAwaiter()
		{
			return default(Awaiter);
		}
	}
	public struct SwitchToSynchronizationContextAwaitable
	{
		public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private static readonly SendOrPostCallback switchToCallback = Callback;

			private readonly SynchronizationContext synchronizationContext;

			private readonly CancellationToken cancellationToken;

			public bool IsCompleted => false;

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

			public void GetResult()
			{
				CancellationToken cancellationToken = this.cancellationToken;
				cancellationToken.ThrowIfCancellationRequested();
			}

			public void OnCompleted(Action continuation)
			{
				synchronizationContext.Post(switchToCallback, continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				synchronizationContext.Post(switchToCallback, continuation);
			}

			private static void Callback(object state)
			{
				((Action)state)();
			}
		}

		private readonly SynchronizationContext synchronizationContext;

		private readonly CancellationToken cancellationToken;

		public SwitchToSynchronizationContextAwaitable(SynchronizationContext synchronizationContext, CancellationToken cancellationToken)
		{
			this.synchronizationContext = synchronizationContext;
			this.cancellationToken = cancellationToken;
		}

		public Awaiter GetAwaiter()
		{
			return new Awaiter(synchronizationContext, cancellationToken);
		}
	}
	public struct ReturnToSynchronizationContext
	{
		public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private static readonly SendOrPostCallback switchToCallback = Callback;

			private readonly SynchronizationContext synchronizationContext;

			private readonly bool dontPostWhenSameContext;

			private readonly CancellationToken cancellationToken;

			public bool IsCompleted
			{
				get
				{
					if (!dontPostWhenSameContext)
					{
						return false;
					}
					if (SynchronizationContext.Current == synchronizationContext)
					{
						return true;
					}
					return false;
				}
			}

			public Awaiter(SynchronizationContext synchronizationContext, bool dontPostWhenSameContext, CancellationToken cancellationToken)
			{
				this.synchronizationContext = synchronizationContext;
				this.dontPostWhenSameContext = dontPostWhenSameContext;
				this.cancellationToken = cancellationToken;
			}

			public Awaiter GetAwaiter()
			{
				return this;
			}

			public void GetResult()
			{
				CancellationToken cancellationToken = this.cancellationToken;
				cancellationToken.ThrowIfCancellationRequested();
			}

			public void OnCompleted(Action continuation)
			{
				synchronizationContext.Post(switchToCallback, continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				synchronizationContext.Post(switchToCallback, continuation);
			}

			private static void Callback(object state)
			{
				((Action)state)();
			}
		}

		private readonly SynchronizationContext syncContext;

		private readonly bool dontPostWhenSameContext;

		private readonly CancellationToken cancellationToken;

		public ReturnToSynchronizationContext(SynchronizationContext syncContext, bool dontPostWhenSameContext, CancellationToken cancellationToken)
		{
			this.syncContext = syncContext;
			this.dontPostWhenSameContext = dontPostWhenSameContext;
			this.cancellationToken = cancellationToken;
		}

		public Awaiter DisposeAsync()
		{
			return new Awaiter(syncContext, dontPostWhenSameContext, cancellationToken);
		}
	}
	internal static class AwaiterActions
	{
		internal static readonly Action<object> InvokeContinuationDelegate = Continuation;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		private static void Continuation(object state)
		{
			((Action)state)();
		}
	}
	[StructLayout(LayoutKind.Auto)]
	[AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder<>))]
	public readonly struct UniTask<T>
	{
		private sealed class IsCanceledSource : IUniTaskSource<(bool, T)>, IUniTaskSource
		{
			private readonly IUniTaskSource<T> source;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public IsCanceledSource(IUniTaskSource<T> source)
			{
				this.source = source;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public (bool, T) GetResult(short token)
			{
				if (source.GetStatus(token) == UniTaskStatus.Canceled)
				{
					return (true, default(T));
				}
				T result = source.GetResult(token);
				return (false, result);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			void IUniTaskSource.GetResult(short token)
			{
				GetResult(token);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public UniTaskStatus GetStatus(short token)
			{
				return source.GetStatus(token);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public UniTaskStatus UnsafeGetStatus()
			{
				return source.UnsafeGetStatus();
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				source.OnCompleted(continuation, state, token);
			}
		}

		private sealed class MemoizeSource : IUniTaskSource<T>, IUniTaskSource
		{
			private IUniTaskSource<T> source;

			private T result;

			private ExceptionDispatchInfo exception;

			private UniTaskStatus status;

			public MemoizeSource(IUniTaskSource<T> source)
			{
				this.source = source;
			}

			public T GetResult(short token)
			{
				if (source == null)
				{
					if (exception != null)
					{
						exception.Throw();
					}
					return result;
				}
				try
				{
					result = source.GetResult(token);
					status = UniTaskStatus.Succeeded;
					return result;
				}
				catch (Exception ex)
				{
					exception = ExceptionDispatchInfo.Capture(ex);
					if (ex is OperationCanceledException)
					{
						status = UniTaskStatus.Canceled;
					}
					else
					{
						status = UniTaskStatus.Faulted;
					}
					throw;
				}
				finally
				{
					source = null;
				}
			}

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

			public UniTaskStatus GetStatus(short token)
			{
				if (source == null)
				{
					return status;
				}
				return source.GetStatus(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token)
			{
				if (source == null)
				{
					continuation(state);
				}
				else
				{
					source.OnCompleted(continuation, state, token);
				}
			}

			public UniTaskStatus UnsafeGetStatus()
			{
				if (source == null)
				{
					return status;
				}
				return source.UnsafeGetStatus();
			}
		}

		public readonly struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly UniTask<T> task;

			public bool IsCompleted
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				[DebuggerHidden]
				get
				{
					return task.Status.IsCompleted();
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public Awaiter(in UniTask<T> task)
			{
				this.task = task;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public T GetResult()
			{
				IUniTaskSource<T> source = task.source;
				if (source == null)
				{
					return task.result;
				}
				return source.GetResult(task.token);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void OnCompleted(Action continuation)
			{
				IUniTaskSource<T> source = task.source;
				if (source == null)
				{
					continuation();
				}
				else
				{
					source.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void UnsafeOnCompleted(Action continuation)
			{
				IUniTaskSource<T> source = task.source;
				if (source == null)
				{
					continuation();
				}
				else
				{
					source.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			public void SourceOnCompleted(Action<object> continuation, object state)
			{
				IUniTaskSource<T> source = task.source;
				if (source == null)
				{
					continuation(state);
				}
				else
				{
					source.OnCompleted(continuation, state, task.token);
				}
			}
		}

		private readonly IUniTaskSource<T> source;

		private readonly T result;

		private readonly short token;

		public UniTaskStatus Status
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			get
			{
				if (source != null)
				{
					return source.GetStatus(token);
				}
				return UniTaskStatus.Succeeded;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public UniTask(T result)
		{
			source = null;
			token = 0;
			this.result = result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public UniTask(IUniTaskSource<T> source, short token)
		{
			this.source = source;
			this.token = token;
			result = default(T);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public Awaiter GetAwaiter()
		{
			return new Awaiter(in this);
		}

		public UniTask<T> Preserve()
		{
			if (source == null)
			{
				return this;
			}
			return new UniTask<T>(new MemoizeSource(source), token);
		}

		public UniTask AsUniTask()
		{
			if (source == null)
			{
				return UniTask.CompletedTask;
			}
			if (source.GetStatus(token).IsCompletedSuccessfully())
			{
				source.GetResult(token);
				return UniTask.CompletedTask;
			}
			return new UniTask(source, token);
		}

		public static implicit operator UniTask(UniTask<T> self)
		{
			return self.AsUniTask();
		}

		public UniTask<(bool IsCanceled, T Result)> SuppressCancellationThrow()
		{
			if (source == null)
			{
				return new UniTask<(bool, T)>((false, result));
			}
			return new UniTask<(bool, T)>(new IsCanceledSource(source), token);
		}

		public override string ToString()
		{
			if (source != null)
			{
				return "(" + source.UnsafeGetStatus().ToString() + ")";
			}
			return result?.ToString();
		}
	}
	public interface IResolvePromise
	{
		bool TrySetResult();
	}
	public interface IResolvePromise<T>
	{
		bool TrySetResult(T value);
	}
	public interface IRejectPromise
	{
		bool TrySetException(Exception exception);
	}
	public interface ICancelPromise
	{
		bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface IPromise<T> : IResolvePromise<T>, IRejectPromise, ICancelPromise
	{
	}
	public interface IPromise : IResolvePromise, IRejectPromise, ICancelPromise
	{
	}
	internal class ExceptionHolder
	{
		private ExceptionDispatchInfo exception;

		private bool calledGet;

		public ExceptionHolder(ExceptionDispatchInfo exception)
		{
			this.exception = exception;
		}

		public ExceptionDispatchInfo GetException()
		{
			if (!calledGet)
			{
				calledGet = true;
				GC.SuppressFinalize(this);
			}
			return exception;
		}

		~ExceptionHolder()
		{
			if (!calledGet)
			{
				UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException);
			}
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct UniTaskCompletionSourceCore<TResult>
	{
		private TResult result;

		private object error;

		private short version;

		private bool hasUnhandledError;

		private int completedCount;

		private Action<object> continuation;

		private object continuationState;

		[DebuggerHidden]
		public short Version => version;

		[DebuggerHidden]
		public void Reset()
		{
			ReportUnhandledError();
			version++;
			completedCount = 0;
			result = default(TResult);
			error = null;
			hasUnhandledError = false;
			continuation = null;
			continuationState = null;
		}

		private void ReportUnhandledError()
		{
			if (!hasUnhandledError)
			{
				return;
			}
			try
			{
				if (error is OperationCanceledException ex)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex);
				}
				else if (error is ExceptionHolder exceptionHolder)
				{
					UniTaskScheduler.PublishUnobservedTaskException(exceptionHolder.GetException().SourceException);
				}
			}
			catch
			{
			}
		}

		internal void MarkHandled()
		{
			hasUnhandledError = false;
		}

		[DebuggerHidden]
		public bool TrySetResult(TResult result)
		{
			if (Interlocked.Increment(ref completedCount) == 1)
			{
				this.result = result;
				if (continuation != null || Interlocked.CompareExchange(ref continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null)
				{
					continuation(continuationState);
					return true;
				}
			}
			return false;
		}

		[DebuggerHidden]
		public bool TrySetException(Exception error)
		{
			if (Interlocked.Increment(ref completedCount) == 1)
			{
				hasUnhandledError = true;
				if (error is OperationCanceledException)
				{
					this.error = error;
				}
				else
				{
					this.error = new ExceptionHolder(ExceptionDispatchInfo.Capture(error));
				}
				if (continuation != null || Interlocked.CompareExchange(ref continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null)
				{
					continuation(continuationState);
					return true;
				}
			}
			return false;
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (Interlocked.Increment(ref completedCount) == 1)
			{
				hasUnhandledError = true;
				error = new OperationCanceledException(cancellationToken);
				if (continuation != null || Interlocked.CompareExchange(ref continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null)
				{
					continuation(continuationState);
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public UniTaskStatus GetStatus(short token)
		{
			ValidateToken(token);
			if (continuation != null && completedCount != 0)
			{
				if (error != null)
				{
					if (!(error is OperationCanceledException))
					{
						return UniTaskStatus.Faulted;
					}
					return UniTaskStatus.Canceled;
				}
				return UniTaskStatus.Succeeded;
			}
			return UniTaskStatus.Pending;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			if (continuation != null && completedCount != 0)
			{
				if (error != null)
				{
					if (!(error is OperationCanceledException))
					{
						return UniTaskStatus.Faulted;
					}
					return UniTaskStatus.Canceled;
				}
				return UniTaskStatus.Succeeded;
			}
			return UniTaskStatus.Pending;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public TResult GetResult(short token)
		{
			ValidateToken(token);
			if (completedCount == 0)
			{
				throw new InvalidOperationException("Not yet completed, UniTask only allow to use await.");
			}
			if (error != null)
			{
				hasUnhandledError = false;
				if (error is OperationCanceledException ex)
				{
					throw ex;
				}
				if (error is ExceptionHolder exceptionHolder)
				{
					exceptionHolder.GetException().Throw();
				}
				throw new InvalidOperationException("Critical: invalid exception type was held.");
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void OnCompleted(Action<object> continuation, object state, short token)
		{
			if (continuation == null)
			{
				throw new ArgumentNullException("continuation");
			}
			ValidateToken(token);
			object obj = this.continuation;
			if (obj == null)
			{
				continuationState = state;
				obj = Interlocked.CompareExchange(ref this.continuation, continuation, null);
			}
			if (obj != null)
			{
				if (obj != UniTaskCompletionSourceCoreShared.s_sentinel)
				{
					throw new InvalidOperationException("Already continuation registered, can not await twice or get Status after await.");
				}
				continuation(state);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		private void ValidateToken(short token)
		{
			if (token != version)
			{
				throw new InvalidOperationException("Token version is not matched, can not await twice or get Status after await.");
			}
		}
	}
	internal static class UniTaskCompletionSourceCoreShared
	{
		internal static readonly Action<object> s_sentinel = CompletionSentinel;

		private static void CompletionSentinel(object _)
		{
			throw new InvalidOperationException("The sentinel delegate should never be invoked.");
		}
	}
	public class AutoResetUniTaskCompletionSource : IUniTaskSource, ITaskPoolNode<AutoResetUniTaskCompletionSource>, IPromise, IResolvePromise, IRejectPromise, ICancelPromise
	{
		private static TaskPool<AutoResetUniTaskCompletionSource> pool;

		private AutoResetUniTaskCompletionSource nextNode;

		private UniTaskCompletionSourceCore<AsyncUnit> core;

		public ref AutoResetUniTaskCompletionSource NextNode => ref nextNode;

		public UniTask Task
		{
			[DebuggerHidden]
			get
			{
				return new UniTask(this, core.Version);
			}
		}

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

		private AutoResetUniTaskCompletionSource()
		{
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource Create()
		{
			if (!pool.TryPop(out var result))
			{
				result = new AutoResetUniTaskCompletionSource();
			}
			TaskTracker.TrackActiveTask(result, 2);
			return result;
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource CreateFromCanceled(CancellationToken cancellationToken, out short token)
		{
			AutoResetUniTaskCompletionSource autoResetUniTaskCompletionSource = Create();
			autoResetUniTaskCompletionSource.TrySetCanceled(cancellationToken);
			token = autoResetUniTaskCompletionSource.core.Version;
			return autoResetUniTaskCompletionSource;
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource CreateFromException(Exception exception, out short token)
		{
			AutoResetUniTaskCompletionSource autoResetUniTaskCompletionSource = Create();
			autoResetUniTaskCompletionSource.TrySetException(exception);
			token = autoResetUniTaskCompletionSource.core.Version;
			return autoResetUniTaskCompletionSource;
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource CreateCompleted(out short token)
		{
			AutoResetUniTaskCompletionSource autoResetUniTaskCompletionSource = Create();
			autoResetUniTaskCompletionSource.TrySetResult();
			token = autoResetUniTaskCompletionSource.core.Version;
			return autoResetUniTaskCompletionSource;
		}

		[DebuggerHidden]
		public bool TrySetResult()
		{
			return core.TrySetResult(AsyncUnit.Default);
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			return core.TrySetCanceled(cancellationToken);
		}

		[DebuggerHidden]
		public bool TrySetException(Exception exception)
		{
			return core.TrySetException(exception);
		}

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

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

		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			return core.UnsafeGetStatus();
		}

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

		[DebuggerHidden]
		private bool TryReturn()
		{
			TaskTracker.RemoveTracking(this);
			core.Reset();
			return pool.TryPush(this);
		}
	}
	public class AutoResetUniTaskCompletionSource<T> : IUniTaskSource<T>, IUniTaskSource, ITaskPoolNode<AutoResetUniTaskCompletionSource<T>>, IPromise<T>, IResolvePromise<T>, IRejectPromise, ICancelPromise
	{
		private static TaskPool<AutoResetUniTaskCompletionSource<T>> pool;

		private AutoResetUniTaskCompletionSource<T> nextNode;

		private UniTaskCompletionSourceCore<T> core;

		public ref AutoResetUniTaskCompletionSource<T> NextNode => ref nextNode;

		public UniTask<T> Task
		{
			[DebuggerHidden]
			get
			{
				return new UniTask<T>(this, core.Version);
			}
		}

		static AutoResetUniTaskCompletionSource()
		{
			TaskPool.RegisterSizeGetter(typeof(AutoResetUniTaskCompletionSource<T>), () => pool.Size);
		}

		private AutoResetUniTaskCompletionSource()
		{
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource<T> Create()
		{
			if (!pool.TryPop(out var result))
			{
				result = new AutoResetUniTaskCompletionSource<T>();
			}
			TaskTracker.TrackActiveTask(result, 2);
			return result;
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource<T> CreateFromCanceled(CancellationToken cancellationToken, out short token)
		{
			AutoResetUniTaskCompletionSource<T> autoResetUniTaskCompletionSource = Create();
			autoResetUniTaskCompletionSource.TrySetCanceled(cancellationToken);
			token = autoResetUniTaskCompletionSource.core.Version;
			return autoResetUniTaskCompletionSource;
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource<T> CreateFromException(Exception exception, out short token)
		{
			AutoResetUniTaskCompletionSource<T> autoResetUniTaskCompletionSource = Create();
			autoResetUniTaskCompletionSource.TrySetException(exception);
			token = autoResetUniTaskCompletionSource.core.Version;
			return autoResetUniTaskCompletionSource;
		}

		[DebuggerHidden]
		public static AutoResetUniTaskCompletionSource<T> CreateFromResult(T result, out short token)
		{
			AutoResetUniTaskCompletionSource<T> autoResetUniTaskCompletionSource = Create();
			autoResetUniTaskCompletionSource.TrySetResult(result);
			token = autoResetUniTaskCompletionSource.core.Version;
			return autoResetUniTaskCompletionSource;
		}

		[DebuggerHidden]
		public bool TrySetResult(T result)
		{
			return core.TrySetResult(result);
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			return core.TrySetCanceled(cancellationToken);
		}

		[DebuggerHidden]
		public bool TrySetException(Exception exception)
		{
			return core.TrySetException(exception);
		}

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

		[DebuggerHidden]
		void IUniTaskSource.GetResult(short token)
		{
			GetResult(token);
		}

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

		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			return core.UnsafeGetStatus();
		}

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

		[DebuggerHidden]
		private bool TryReturn()
		{
			TaskTracker.RemoveTracking(this);
			core.Reset();
			return pool.TryPush(this);
		}
	}
	public class UniTaskCompletionSource : IUniTaskSource, IPromise, IResolvePromise, IRejectPromise, ICancelPromise
	{
		private CancellationToken cancellationToken;

		private ExceptionHolder exception;

		private object gate;

		private Action<object> singleContinuation;

		private object singleState;

		private List<(Action<object>, object)> secondaryContinuationList;

		private int intStatus;

		private bool handled;

		public UniTask Task
		{
			[DebuggerHidden]
			get
			{
				return new UniTask(this, 0);
			}
		}

		public UniTaskCompletionSource()
		{
			TaskTracker.TrackActiveTask(this, 2);
		}

		[DebuggerHidden]
		internal void MarkHandled()
		{
			if (!handled)
			{
				handled = true;
				TaskTracker.RemoveTracking(this);
			}
		}

		[DebuggerHidden]
		public bool TrySetResult()
		{
			return TrySignalCompletion(UniTaskStatus.Succeeded);
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (UnsafeGetStatus() != 0)
			{
				return false;
			}
			this.cancellationToken = cancellationToken;
			return TrySignalCompletion(UniTaskStatus.Canceled);
		}

		[DebuggerHidden]
		public bool TrySetException(Exception exception)
		{
			if (exception is OperationCanceledException ex)
			{
				return TrySetCanceled(ex.CancellationToken);
			}
			if (UnsafeGetStatus() != 0)
			{
				return false;
			}
			this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception));
			return TrySignalCompletion(UniTaskStatus.Faulted);
		}

		[DebuggerHidden]
		public void GetResult(short token)
		{
			MarkHandled();
			switch ((UniTaskStatus)intStatus)
			{
			case UniTaskStatus.Succeeded:
				break;
			case UniTaskStatus.Faulted:
				exception.GetException().Throw();
				break;
			case UniTaskStatus.Canceled:
				throw new OperationCanceledException(cancellationToken);
			default:
				throw new InvalidOperationException("not yet completed.");
			}
		}

		[DebuggerHidden]
		public UniTaskStatus GetStatus(short token)
		{
			return (UniTaskStatus)intStatus;
		}

		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			return (UniTaskStatus)intStatus;
		}

		[DebuggerHidden]
		public void OnCompleted(Action<object> continuation, object state, short token)
		{
			if (gate == null)
			{
				Interlocked.CompareExchange(ref gate, new object(), null);
			}
			lock (Thread.VolatileRead(ref gate))
			{
				if (intStatus != 0)
				{
					continuation(state);
					return;
				}
				if (singleContinuation == null)
				{
					singleContinuation = continuation;
					singleState = state;
					return;
				}
				if (secondaryContinuationList == null)
				{
					secondaryContinuationList = new List<(Action<object>, object)>();
				}
				secondaryContinuationList.Add((continuation, state));
			}
		}

		[DebuggerHidden]
		private bool TrySignalCompletion(UniTaskStatus status)
		{
			if (Interlocked.CompareExchange(ref intStatus, (int)status, 0) == 0)
			{
				if (gate == null)
				{
					Interlocked.CompareExchange(ref gate, new object(), null);
				}
				lock (Thread.VolatileRead(ref gate))
				{
					if (singleContinuation != null)
					{
						try
						{
							singleContinuation(singleState);
						}
						catch (Exception ex)
						{
							UniTaskScheduler.PublishUnobservedTaskException(ex);
						}
					}
					if (secondaryContinuationList != null)
					{
						foreach (var (action, obj) in secondaryContinuationList)
						{
							try
							{
								action(obj);
							}
							catch (Exception ex2)
							{
								UniTaskScheduler.PublishUnobservedTaskException(ex2);
							}
						}
					}
					singleContinuation = null;
					singleState = null;
					secondaryContinuationList = null;
				}
				return true;
			}
			return false;
		}
	}
	public class UniTaskCompletionSource<T> : IUniTaskSource<T>, IUniTaskSource, IPromise<T>, IResolvePromise<T>, IRejectPromise, ICancelPromise
	{
		private CancellationToken cancellationToken;

		private T result;

		private ExceptionHolder exception;

		private object gate;

		private Action<object> singleContinuation;

		private object singleState;

		private List<(Action<object>, object)> secondaryContinuationList;

		private int intStatus;

		private bool handled;

		public UniTask<T> Task
		{
			[DebuggerHidden]
			get
			{
				return new UniTask<T>(this, 0);
			}
		}

		public UniTaskCompletionSource()
		{
			TaskTracker.TrackActiveTask(this, 2);
		}

		[DebuggerHidden]
		internal void MarkHandled()
		{
			if (!handled)
			{
				handled = true;
				TaskTracker.RemoveTracking(this);
			}
		}

		[DebuggerHidden]
		public bool TrySetResult(T result)
		{
			if (UnsafeGetStatus() != 0)
			{
				return false;
			}
			this.result = result;
			return TrySignalCompletion(UniTaskStatus.Succeeded);
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (UnsafeGetStatus() != 0)
			{
				return false;
			}
			this.cancellationToken = cancellationToken;
			return TrySignalCompletion(UniTaskStatus.Canceled);
		}

		[DebuggerHidden]
		public bool TrySetException(Exception exception)
		{
			if (exception is OperationCanceledException ex)
			{
				return TrySetCanceled(ex.CancellationToken);
			}
			if (UnsafeGetStatus() != 0)
			{
				return false;
			}
			this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception));
			return TrySignalCompletion(UniTaskStatus.Faulted);
		}

		[DebuggerHidden]
		public T GetResult(short token)
		{
			MarkHandled();
			switch ((UniTaskStatus)intStatus)
			{
			case UniTaskStatus.Succeeded:
				return result;
			case UniTaskStatus.Faulted:
				exception.GetException().Throw();
				return default(T);
			case UniTaskStatus.Canceled:
				throw new OperationCanceledException(cancellationToken);
			default:
				throw new InvalidOperationException("not yet completed.");
			}
		}

		[DebuggerHidden]
		void IUniTaskSource.GetResult(short token)
		{
			GetResult(token);
		}

		[DebuggerHidden]
		public UniTaskStatus GetStatus(short token)
		{
			return (UniTaskStatus)intStatus;
		}

		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			return (UniTaskStatus)intStatus;
		}

		[DebuggerHidden]
		public void OnCompleted(Action<object> continuation, object state, short token)
		{
			if (gate == null)
			{
				Interlocked.CompareExchange(ref gate, new object(), null);
			}
			lock (Thread.VolatileRead(ref gate))
			{
				if (intStatus != 0)
				{
					continuation(state);
					return;
				}
				if (singleContinuation == null)
				{
					singleContinuation = continuation;
					singleState = state;
					return;
				}
				if (secondaryContinuationList == null)
				{
					secondaryContinuationList = new List<(Action<object>, object)>();
				}
				secondaryContinuationList.Add((continuation, state));
			}
		}

		[DebuggerHidden]
		private bool TrySignalCompletion(UniTaskStatus status)
		{
			if (Interlocked.CompareExchange(ref intStatus, (int)status, 0) == 0)
			{
				if (gate == null)
				{
					Interlocked.CompareExchange(ref gate, new object(), null);
				}
				lock (Thread.VolatileRead(ref gate))
				{
					if (singleContinuation != null)
					{
						try
						{
							singleContinuation(singleState);
						}
						catch (Exception ex)
						{
							UniTaskScheduler.PublishUnobservedTaskException(ex);
						}
					}
					if (secondaryContinuationList != null)
					{
						foreach (var (action, obj) in secondaryContinuationList)
						{
							try
							{
								action(obj);
							}
							catch (Exception ex2)
							{
								UniTaskScheduler.PublishUnobservedTaskException(ex2);
							}
						}
					}
					singleContinuation = null;
					singleState = null;
					secondaryContinuationList = null;
				}
				return true;
			}
			return false;
		}
	}
	public static class UniTaskExtensions
	{
		private sealed class AttachExternalCancellationSource : IUniTaskSource
		{
			private static readonly Action<object> cancellationCallbackDelegate = CancellationCallback;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration tokenRegistration;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public AttachExternalCancellationSource(UniTask task, CancellationToken cancellationToken)
			{
				this.cancellationToken = cancellationToken;
				tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this);
				RunTask(task).Forget();
			}

			private async UniTaskVoid RunTask(UniTask task)
			{
				try
				{
					await task;
					core.TrySetResult(AsyncUnit.Default);
				}
				catch (Exception error)
				{
					core.TrySetException(error);
				}
				finally
				{
					tokenRegistration.Dispose();
				}
			}

			private static void CancellationCallback(object state)
			{
				AttachExternalCancellationSource attachExternalCancellationSource = (AttachExternalCancellationSource)state;
				attachExternalCancellationSource.core.TrySetCanceled(attachExternalCancellationSource.cancellationToken);
			}

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

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

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

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

		private sealed class AttachExternalCancellationSource<T> : IUniTaskSource<T>, IUniTaskSource
		{
			private static readonly Action<object> cancellationCallbackDelegate = CancellationCallback;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration tokenRegistration;

			private UniTaskCompletionSourceCore<T> core;

			public AttachExternalCancellationSource(UniTask<T> task, CancellationToken cancellationToken)
			{
				this.cancellationToken = cancellationToken;
				tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this);
				RunTask(task).Forget();
			}

			private async UniTaskVoid RunTask(UniTask<T> task)
			{
				try
				{
					T result = await task;
					core.TrySetResult(result);
				}
				catch (Exception error)
				{
					core.TrySetException(error);
				}
				finally
				{
					tokenRegistration.Dispose();
				}
			}

			private static void CancellationCallback(object state)
			{
				AttachExternalCancellationSource<T> attachExternalCancellationSource = (AttachExternalCancellationSource<T>)state;
				attachExternalCancellationSource.core.TrySetCanceled(attachExternalCancellationSource.cancellationToken);
			}

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

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

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

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

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

		private sealed class ToCoroutineEnumerator : IEnumerator
		{
			private bool completed;

			private UniTask task;

			private Action<Exception> exceptionHandler;

			private bool isStarted;

			private ExceptionDispatchInfo exception;

			public object Current => null;

			public ToCoroutineEnumerator(UniTask task, Action<Exception> exceptionHandler)
			{
				completed = false;
				this.exceptionHandler = exceptionHandler;
				this.task = task;
			}

			private async UniTaskVoid RunTask(UniTask task)
			{
				try
				{
					await task;
				}
				catch (Exception ex)
				{
					if (exceptionHandler != null)
					{
						exceptionHandler(ex);
					}
					else
					{
						exception = ExceptionDispatchInfo.Capture(ex);
					}
				}
				finally
				{
					completed = true;
				}
			}

			public bool MoveNext()
			{
				if (!isStarted)
				{
					isStarted = true;
					RunTask(task).Forget();
				}
				if (exception != null)
				{
					exception.Throw();
					return false;
				}
				return !completed;
			}

			void IEnumerator.Reset()
			{
			}
		}

		private sealed class ToCoroutineEnumerator<T> : IEnumerator
		{
			private bool completed;

			private Action<T> resultHandler;

			private Action<Exception> exceptionHandler;

			private bool isStarted;

			private UniTask<T> task;

			private object current;

			private ExceptionDispatchInfo exception;

			public object Current => current;

			public ToCoroutineEnumerator(UniTask<T> task, Action<T> resultHandler, Action<Exception> exceptionHandler)
			{
				completed = false;
				this.task = task;
				this.resultHandler = resultHandler;
				this.exceptionHandler = exceptionHandler;
			}

			private async UniTaskVoid RunTask(UniTask<T> task)
			{
				try
				{
					T val = await task;
					current = val;
					if (resultHandler != null)
					{
						resultHandler(val);
					}
				}
				catch (Exception ex)
				{
					if (exceptionHandler != null)
					{
						exceptionHandler(ex);
					}
					else
					{
						exception = ExceptionDispatchInfo.Capture(ex);
					}
				}
				finally
				{
					completed = true;
				}
			}

			public bool MoveNext()
			{
				if (!isStarted)
				{
					isStarted = true;
					RunTask(task).Forget();
				}
				if (exception != null)
				{
					exception.Throw();
					return false;
				}
				return !completed;
			}

			void IEnumerator.Reset()
			{
			}
		}

		public static UniTask.Awaiter GetAwaiter(this UniTask[] tasks)
		{
			return UniTask.WhenAll(tasks).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this IEnumerable<UniTask> tasks)
		{
			return UniTask.WhenAll(tasks).GetAwaiter();
		}

		public static UniTask<T[]>.Awaiter GetAwaiter<T>(this UniTask<T>[] tasks)
		{
			return UniTask.WhenAll(tasks).GetAwaiter();
		}

		public static UniTask<T[]>.Awaiter GetAwaiter<T>(this IEnumerable<UniTask<T>> tasks)
		{
			return UniTask.WhenAll(tasks).GetAwaiter();
		}

		public static UniTask<(T1, T2)>.Awaiter GetAwaiter<T1, T2>(this (UniTask<T1> task1, UniTask<T2> task2) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3)>.Awaiter GetAwaiter<T1, T2, T3>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4)>.Awaiter GetAwaiter<T1, T2, T3, T4>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5, tasks.Rest.Item6).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5, tasks.Rest.Item6, tasks.Rest.Item7).GetAwaiter();
		}

		public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>.Awaiter GetAwaiter<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7, UniTask<T8> task8, UniTask<T9> task9, UniTask<T10> task10, UniTask<T11> task11, UniTask<T12> task12, UniTask<T13> task13, UniTask<T14> task14, UniTask<T15> task15) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5, tasks.Rest.Item6, tasks.Rest.Item7, tasks.Rest.Rest.Item1).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5, tasks.Rest.Item6).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5, tasks.Rest.Item6, tasks.Rest.Item7).GetAwaiter();
		}

		public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) tasks)
		{
			return UniTask.WhenAll(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7, tasks.Rest.Item1, tasks.Rest.Item2, tasks.Rest.Item3, tasks.Rest.Item4, tasks.Rest.Item5, tasks.Rest.Item6, tasks.Rest.Item7, tasks.Rest.Rest.Item1).GetAwaiter();
		}

		public static UniTask<T> AsUniTask<T>(this Task<T> task, bool useCurrentSynchronizationContext = true)
		{
			UniTaskCompletionSource<T> uniTaskCompletionSource = new UniTaskCompletionSource<T>();
			task.ContinueWith(delegate(Task<T> x, object state)
			{
				UniTaskCompletionSource<T> uniTaskCompletionSource2 = (UniTaskCompletionSource<T>)state;
				switch (x.Status)
				{
				case TaskStatus.Canceled:
					uniTaskCompletionSource2.TrySetCanceled();
					break;
				case TaskStatus.Faulted:
					uniTaskCompletionSource2.TrySetException(x.Exception);
					break;
				case TaskStatus.RanToCompletion:
					uniTaskCompletionSource2.TrySetResult(x.Result);
					break;
				default:
					throw new NotSupportedException();
				}
			}, uniTaskCompletionSource, useCurrentSynchronizationContext ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current);
			return uniTaskCompletionSource.Task;
		}

		public static UniTask AsUniTask(this Task task, bool useCurrentSynchronizationContext = true)
		{
			UniTaskCompletionSource uniTaskCompletionSource = new UniTaskCompletionSource();
			task.ContinueWith(delegate(Task x, object state)
			{
				UniTaskCompletionSource uniTaskCompletionSource2 = (UniTaskCompletionSource)state;
				switch (x.Status)
				{
				case TaskStatus.Canceled:
					uniTaskCompletionSource2.TrySetCanceled();
					break;
				case TaskStatus.Faulted:
					uniTaskCompletionSource2.TrySetException(x.Exception);
					break;
				case TaskStatus.RanToCompletion:
					uniTaskCompletionSource2.TrySetResult();
					break;
				default:
					throw new NotSupportedException();
				}
			}, uniTaskCompletionSource, useCurrentSynchronizationContext ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current);
			return uniTaskCompletionSource.Task;
		}

		public static Task<T> AsTask<T>(this UniTask<T> task)
		{
			try
			{
				UniTask<T>.Awaiter awaiter;
				try
				{
					awaiter = task.GetAwaiter();
				}
				catch (Exception exception)
				{
					return Task.FromException<T>(exception);
				}
				if (awaiter.IsCompleted)
				{
					try
					{
						return Task.FromResult(awaiter.GetResult());
					}
					catch (Exception exception2)
					{
						return Task.FromException<T>(exception2);
					}
				}
				TaskCompletionSource<T> taskCompletionSource = new TaskCompletionSource<T>();
				awaiter.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<TaskCompletionSource<T>, UniTask<T>.Awaiter> stateTuple = (StateTuple<TaskCompletionSource<T>, UniTask<T>.Awaiter>)state;
					var (taskCompletionSource3, awaiter3) = stateTuple;
					try
					{
						T result = awaiter3.GetResult();
						taskCompletionSource3.SetResult(result);
					}
					catch (Exception exception4)
					{
						taskCompletionSource3.SetException(exception4);
					}
				}, StateTuple.Create(taskCompletionSource, awaiter));
				return taskCompletionSource.Task;
			}
			catch (Exception exception3)
			{
				return Task.FromException<T>(exception3);
			}
		}

		public static Task AsTask(this UniTask task)
		{
			try
			{
				UniTask.Awaiter awaiter;
				try
				{
					awaiter = task.GetAwaiter();
				}
				catch (Exception exception)
				{
					return Task.FromException(exception);
				}
				if (awaiter.IsCompleted)
				{
					try
					{
						awaiter.GetResult();
						return Task.CompletedTask;
					}
					catch (Exception exception2)
					{
						return Task.FromException(exception2);
					}
				}
				TaskCompletionSource<object> taskCompletionSource = new TaskCompletionSource<object>();
				awaiter.SourceOnCompleted(delegate(object state)
				{
					using StateTuple<TaskCompletionSource<object>, UniTask.Awaiter> stateTuple = (StateTuple<TaskCompletionSource<object>, UniTask.Awaiter>)state;
					var (taskCompletionSource3, awaiter3) = stateTuple;
					try
					{
						awaiter3.GetResult();
						taskCompletionSource3.SetResult(null);
					}
					catch (Exception exception4)
					{
						taskCompletionSource3.SetException(exception4);
					}
				}, StateTuple.Create(taskCompletionSource, awaiter));
				return taskCompletionSource.Task;
			}
			catch (Exception exception3)
			{
				return Task.FromException(exception3);
			}
		}

		public static AsyncLazy ToAsyncLazy(this UniTask task)
		{
			return new AsyncLazy(task);
		}

		public static AsyncLazy<T> ToAsyncLazy<T>(this UniTask<T> task)
		{
			return new AsyncLazy<T>(task);
		}

		public static UniTask AttachExternalCancellation(this UniTask task, CancellationToken cancellationToken)
		{
			if (!cancellationToken.CanBeCanceled)
			{
				return task;
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled(cancellationToken);
			}
			if (task.Status.IsCompleted())
			{
				return task;
			}
			return new UniTask(new AttachExternalCancellationSource(task, cancellationToken), 0);
		}

		public static UniTask<T> AttachExternalCancellation<T>(this UniTask<T> task, CancellationToken cancellationToken)
		{
			if (!cancellationToken.CanBeCanceled)
			{
				return task;
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled<T>(cancellationToken);
			}
			if (task.Status.IsCompleted())
			{
				return task;
			}
			return new UniTask<T>(new AttachExternalCancellationSource<T>(task, cancellationToken), 0);
		}

		public static IEnumerator ToCoroutine<T>(this UniTask<T> task, Action<T> resultHandler = null, Action<Exception> exceptionHandler = null)
		{
			return new ToCoroutineEnumerator<T>(task, resultHandler, exceptionHandler);
		}

		public static IEnumerator ToCoroutine(this UniTask task, Action<Exception> exceptionHandler = null)
		{
			return new ToCoroutineEnumerator(task, exceptionHandler);
		}

		public static async UniTask Timeout(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
		{
			CancellationTokenSource delayCancellationTokenSource = new CancellationTokenSource();
			UniTask<bool> task2 = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
			int num;
			bool flag;
			try
			{
				(num, flag, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), task2);
			}
			catch
			{
				delayCancellationTokenSource.Cancel();
				delayCancellationTokenSource.Dispose();
				throw;
			}
			if (num == 1)
			{
				if (taskCancellationTokenSource != null)
				{
					taskCancellationTokenSource.Cancel();
					taskCancellationTokenSource.Dispose();
				}
				TimeSpan timeSpan = timeout;
				throw new TimeoutException("Exceed Timeout:" + timeSpan);
			}
			delayCancellationTokenSource.Cancel();
			delayCancellationTokenSource.Dispose();
			if (flag)
			{
				Error.ThrowOperationCanceledException();
			}
		}

		public static async UniTask<T> Timeout<T>(this UniTask<T> task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
		{
			CancellationTokenSource delayCancellationTokenSource = new CancellationTokenSource();
			UniTask<bool> task2 = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
			int num;
			(bool, T) tuple2;
			try
			{
				(num, tuple2, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), task2);
			}
			catch
			{
				delayCancellationTokenSource.Cancel();
				delayCancellationTokenSource.Dispose();
				throw;
			}
			if (num == 1)
			{
				if (taskCancellationTokenSource != null)
				{
					taskCancellationTokenSource.Cancel();
					taskCancellationTokenSource.Dispose();
				}
				TimeSpan timeSpan = timeout;
				throw new TimeoutException("Exceed Timeout:" + timeSpan);
			}
			delayCancellationTokenSource.Cancel();
			delayCancellationTokenSource.Dispose();
			if (tuple2.Item1)
			{
				Error.ThrowOperationCanceledException();
			}
			return tuple2.Item2;
		}

		public static async UniTask<bool> TimeoutWithoutException(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
		{
			CancellationTokenSource delayCancellationTokenSource = new CancellationTokenSource();
			UniTask<bool> task2 = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
			int num;
			bool flag;
			try
			{
				(num, flag, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), task2);
			}
			catch
			{
				delayCancellationTokenSource.Cancel();
				delayCancellationTokenSource.Dispose();
				return true;
			}
			if (num == 1)
			{
				if (taskCancellationTokenSource != null)
				{
					taskCancellationTokenSource.Cancel();
					taskCancellationTokenSource.Dispose();
				}
				return true;
			}
			delayCancellationTokenSource.Cancel();
			delayCancellationTokenSource.Dispose();
			if (flag)
			{
				return true;
			}
			return false;
		}

		public static async UniTask<(bool IsTimeout, T Result)> TimeoutWithoutException<T>(this UniTask<T> task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
		{
			CancellationTokenSource delayCancellationTokenSource = new CancellationTokenSource();
			UniTask<bool> task2 = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
			int num;
			(bool, T) tuple2;
			try
			{
				(num, tuple2, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), task2);
			}
			catch
			{
				delayCancellationTokenSource.Cancel();
				delayCancellationTokenSource.Dispose();
				return (true, default(T));
			}
			if (num == 1)
			{
				if (taskCancellationTokenSource != null)
				{
					taskCancellationTokenSource.Cancel();
					taskCancellationTokenSource.Dispose();
				}
				return (true, default(T));
			}
			delayCancellationTokenSource.Cancel();
			delayCancellationTokenSource.Dispose();
			if (tuple2.Item1)
			{
				return (true, default(T));
			}
			return (false, tuple2.Item2);
		}

		public static void Forget(this UniTask task)
		{
			UniTask.Awaiter awaiter = task.GetAwaiter();
			if (awaiter.IsCompleted)
			{
				try
				{
					awaiter.GetResult();
					return;
				}
				catch (Exception ex)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex);
					return;
				}
			}
			awaiter.SourceOnCompleted(delegate(object state)
			{
				using StateTuple<UniTask.Awaiter> stateTuple = (StateTuple<UniTask.Awaiter>)state;
				try
				{
					stateTuple.Item1.GetResult();
				}
				catch (Exception ex2)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
				}
			}, StateTuple.Create(awaiter));
		}

		public static void Forget(this UniTask task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread = true)
		{
			if (exceptionHandler == null)
			{
				task.Forget();
			}
			else
			{
				ForgetCoreWithCatch(task, exceptionHandler, handleExceptionOnMainThread).Forget();
			}
		}

		private static async UniTaskVoid ForgetCoreWithCatch(UniTask task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread)
		{
			try
			{
				await task;
			}
			catch (Exception ex)
			{
				try
				{
					if (handleExceptionOnMainThread)
					{
						await UniTask.SwitchToMainThread();
					}
					exceptionHandler(ex);
				}
				catch (Exception ex2)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
				}
			}
		}

		public static void Forget<T>(this UniTask<T> task)
		{
			UniTask<T>.Awaiter awaiter = task.GetAwaiter();
			if (awaiter.IsCompleted)
			{
				try
				{
					awaiter.GetResult();
					return;
				}
				catch (Exception ex)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex);
					return;
				}
			}
			awaiter.SourceOnCompleted(delegate(object state)
			{
				using StateTuple<UniTask<T>.Awaiter> stateTuple = (StateTuple<UniTask<T>.Awaiter>)state;
				try
				{
					stateTuple.Item1.GetResult();
				}
				catch (Exception ex2)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
				}
			}, StateTuple.Create(awaiter));
		}

		public static void Forget<T>(this UniTask<T> task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread = true)
		{
			if (exceptionHandler == null)
			{
				task.Forget();
			}
			else
			{
				ForgetCoreWithCatch(task, exceptionHandler, handleExceptionOnMainThread).Forget();
			}
		}

		private static async UniTaskVoid ForgetCoreWithCatch<T>(UniTask<T> task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread)
		{
			try
			{
				await task;
			}
			catch (Exception ex)
			{
				try
				{
					if (handleExceptionOnMainThread)
					{
						await UniTask.SwitchToMainThread();
					}
					exceptionHandler(ex);
				}
				catch (Exception ex2)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
				}
			}
		}

		public static async UniTask ContinueWith<T>(this UniTask<T> task, Action<T> continuationFunction)
		{
			continuationFunction(await task);
		}

		public static async UniTask ContinueWith<T>(this UniTask<T> task, Func<T, UniTask> continuationFunction)
		{
			await continuationFunction(await task);
		}

		public static async UniTask<TR> ContinueWith<T, TR>(this UniTask<T> task, Func<T, TR> continuationFunction)
		{
			return continuationFunction(await task);
		}

		public static async UniTask<TR> ContinueWith<T, TR>(this UniTask<T> task, Func<T, UniTask<TR>> continuationFunction)
		{
			return await continuationFunction(await task);
		}

		public static async UniTask ContinueWith(this UniTask task, Action continuationFunction)
		{
			await task;
			continuationFunction();
		}

		public static async UniTask ContinueWith(this UniTask task, Func<UniTask> continuationFunction)
		{
			await task;
			await continuationFunction();
		}

		public static async UniTask<T> ContinueWith<T>(this UniTask task, Func<T> continuationFunction)
		{
			await task;
			return continuationFunction();
		}

		public static async UniTask<T> ContinueWith<T>(this UniTask task, Func<UniTask<T>> continuationFunction)
		{
			await task;
			return await continuationFunction();
		}

		public static async UniTask<T> Unwrap<T>(this UniTask<UniTask<T>> task)
		{
			return await (await task);
		}

		public static async UniTask Unwrap(this UniTask<UniTask> task)
		{
			await (await task);
		}

		public static async UniTask<T> Unwrap<T>(this Task<UniTask<T>> task)
		{
			return await (await task);
		}

		public static async UniTask<T> Unwrap<T>(this Task<UniTask<T>> task, bool continueOnCapturedContext)
		{
			return await (await task.ConfigureAwait(continueOnCapturedContext));
		}

		public static async UniTask Unwrap(this Task<UniTask> task)
		{
			await (await task);
		}

		public static async UniTask Unwrap(this Task<UniTask> task, bool continueOnCapturedContext)
		{
			await (await task.ConfigureAwait(continueOnCapturedContext));
		}

		public static async UniTask<T> Unwrap<T>(this UniTask<Task<T>> task)
		{
			return await (await task);
		}

		public static async UniTask<T> Unwrap<T>(this UniTask<Task<T>> task, bool continueOnCapturedContext)
		{
			return await (await task).ConfigureAwait(continueOnCapturedContext);
		}

		public static async UniTask Unwrap(this UniTask<Task> task)
		{
			await (await task);
		}

		public static async UniTask Unwrap(this UniTask<Task> task, bool continueOnCapturedContext)
		{
			await (await task).ConfigureAwait(continueOnCapturedContext);
		}
	}
	public static class UniTaskObservableExtensions
	{
		private class ToUniTaskObserver<T> : IObserver<T>
		{
			private static readonly Action<object> callback = OnCanceled;

			private readonly UniTaskCompletionSource<T> promise;

			private readonly SingleAssignmentDisposable disposable;

			private readonly CancellationToken cancellationToken;

			private readonly CancellationTokenRegistration registration;

			private bool hasValue;

			private T latestValue;

			public ToUniTaskObserver(UniTaskCompletionSource<T> promise, SingleAssignmentDisposable disposable, CancellationToken cancellationToken)
			{
				this.promise = promise;
				this.disposable = disposable;
				this.cancellationToken = cancellationToken;
				if (this.cancellationToken.CanBeCanceled)
				{
					registration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(callback, this);
				}
			}

			private static void OnCanceled(object state)
			{
				ToUniTaskObserver<T> toUniTaskObserver = (ToUniTaskObserver<T>)state;
				toUniTaskObserver.disposable.Dispose();
				toUniTaskObserver.promise.TrySetCanceled(toUniTaskObserver.cancellationToken);
			}

			public void OnNext(T value)
			{
				hasValue = true;
				latestValue = value;
			}

			public void OnError(Exception error)
			{
				try
				{
					promise.TrySetException(error);
				}
				finally
				{
					CancellationTokenRegistration cancellationTokenRegistration = registration;
					cancellationTokenRegistration.Dispose();
					disposable.Dispose();
				}
			}

			public void OnCompleted()
			{
				try
				{
					if (hasValue)
					{
						promise.TrySetResult(latestValue);
					}
					else
					{
						promise.TrySetException(new InvalidOperationException("Sequence has no elements"));
					}
				}
				finally
				{
					CancellationTokenRegistration cancellationTokenRegistration = registration;
					cancellationTokenRegistration.Dispose();
					disposable.Dispose();
				}
			}
		}

		private class FirstValueToUniTaskObserver<T> : IObserver<T>
		{
			private static readonly Action<object> callback = OnCanceled;

			private readonly UniTaskCompletionSource<T> promise;

			private readonly SingleAssignmentDisposable disposable;

			private readonly CancellationToken cancellationToken;

			private readonly CancellationTokenRegistration registration;

			private bool hasValue;

			public FirstValueToUniTaskObserver(UniTaskCompletionSource<T> promise, SingleAssignmentDisposable disposable, CancellationToken cancellationToken)
			{
				this.promise = promise;
				this.disposable = disposable;
				this.cancellationToken = cancellationToken;
				if (this.cancellationToken.CanBeCanceled)
				{
					registration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(callback, this);
				}
			}

			private static void OnCanceled(object state)
			{
				FirstValueToUniTaskObserver<T> firstValueToUniTaskObserver = (FirstValueToUniTaskObserver<T>)state;
				firstValueToUniTaskObserver.disposable.Dispose();
				firstValueToUniTaskObserver.promise.TrySetCanceled(firstValueToUniTaskObserver.cancellationToken);
			}

			public void OnNext(T value)
			{
				hasValue = true;
				try
				{
					promise.TrySetResult(value);
				}
				finally
				{
					CancellationTokenRegistration cancellationTokenRegistration = registration;
					cancellationTokenRegistration.Dispose();
					disposable.Dispose();
				}
			}

			public void OnError(Exception error)
			{
				try
				{
					promise.TrySetException(error);
				}
				finally
				{
					CancellationTokenRegistration cancellationTokenRegistration = registration;
					cancellationTokenRegistration.Dispose();
					disposable.Dispose();
				}
			}

			public void OnCompleted()
			{
				try
				{
					if (!hasValue)
					{
						promise.TrySetException(new InvalidOperationException("Sequence has no elements"));
					}
				}
				finally
				{
					CancellationTokenRegistration cancellationTokenRegistration = registration;
					cancellationTokenRegistration.Dispose();
					disposable.Dispose();
				}
			}
		}

		private class ReturnObservable<T> : IObservable<T>
		{
			private readonly T value;

			public ReturnObservable(T value)
			{
				this.value = value;
			}

			public IDisposable Subscribe(IObserver<T> observer)
			{
				observer.OnNext(value);
				observer.OnCompleted();
				return EmptyDisposable.Instance;
			}
		}

		private class ThrowObservable<T> : IObservable<T>
		{
			private readonly Exception value;

			public ThrowObservable(Exception value)
			{
				this.value = value;
			}

			public IDisposable Subscribe(IObserver<T> observer)
			{
				observer.OnError(value);
				return EmptyDisposable.Instance;
			}
		}

		public static UniTask<T> ToUniTask<T>(this IObservable<T> source, bool useFirstValue = false, CancellationToken cancellationToken = default(CancellationToken))
		{
			UniTaskCompletionSource<T> uniTaskCompletionSource = new UniTaskCompletionSource<T>();
			SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable();
			IObserver<T> observer2;
			if (!useFirstValue)
			{
				IObserver<T> observer = new ToUniTaskObserver<T>(uniTaskCompletionSource, singleAssignmentDisposable, cancellationToken);
				observer2 = observer;
			}
			else
			{
				IObserver<T> observer = new FirstValueToUniTaskObserver<T>(uniTaskCompletionSource, singleAssignmentDisposable, cancellationToken);
				observer2 = observer;
			}
			IObserver<T> observer3 = observer2;
			try
			{
				singleAssignmentDisposable.Disposable = source.Subscribe(observer3);
			}
			catch (Exception exception)
			{
				uniTaskCompletionSource.TrySetException(exception);
			}
			return uniTaskCompletionSource.Task;
		}

		public static IObservable<T> ToObservable<T>(this UniTask<T> task)
		{
			if (task.Status.IsCompleted())
			{
				try
				{
					return new ReturnObservable<T>(task.GetAwaiter().GetResult());
				}
				catch (Exception value)
				{
					return new ThrowObservable<T>(value);
				}
			}
			AsyncSubject<T> asyncSubject = new AsyncSubject<T>();
			Fire(asyncSubject, task).Forget();
			return asyncSubject;
		}

		public static IObservable<AsyncUnit> ToObservable(this UniTask task)
		{
			if (task.Status.IsCompleted())
			{
				try
				{
					task.GetAwaiter().GetResult();
					return new ReturnObservable<AsyncUnit>(AsyncUnit.Default);
				}
				catch (Exception value)
				{
					return new ThrowObservable<AsyncUnit>(value);
				}
			}
			AsyncSubject<AsyncUnit> asyncSubject = new AsyncSubject<AsyncUnit>();
			Fire(asyncSubject, task).Forget();
			return asyncSubject;
		}

		private static async UniTaskVoid Fire<T>(AsyncSubject<T> subject, UniTask<T> task)
		{
			T value;
			try
			{
				value = await task;
			}
			catch (Exception error)
			{
				subject.OnError(error);
				return;
			}
			subject.OnNext(value);
			subject.OnCompleted();
		}

		private static async UniTaskVoid Fire(AsyncSubject<AsyncUnit> subject, UniTask task)
		{
			try
			{
				await task;
			}
			catch (Exception error)
			{
				subject.OnError(error);
				return;
			}
			subject.OnNext(AsyncUnit.Default);
			subject.OnCompleted();
		}
	}
	public static class UniTaskScheduler
	{
		public static bool PropagateOperationCanceledException = false;

		public static LogType UnobservedExceptionWriteLogType = (LogType)4;

		public static bool DispatchUnityMainThread = true;

		private static readonly SendOrPostCallback handleExceptionInvoke = InvokeUnobservedTaskException;

		public static event Action<Exception> UnobservedTaskException;

		private static void InvokeUnobservedTaskException(object state)
		{
			UniTaskScheduler.UnobservedTaskException((Exception)state);
		}

		internal static void PublishUnobservedTaskException(Exception ex)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected I4, but got Unknown
			if (ex == null || (!PropagateOperationCanceledException && ex is OperationCanceledException))
			{
				return;
			}
			if (UniTaskScheduler.UnobservedTaskException != null)
			{
				if (!DispatchUnityMainThread || Thread.CurrentThread.ManagedThreadId == PlayerLoopHelper.MainThreadId)
				{
					UniTaskScheduler.UnobservedTaskException(ex);
				}
				else
				{
					PlayerLoopHelper.UnitySynchronizationContext.Post(handleExceptionInvoke, ex);
				}
				return;
			}
			string text = null;
			if ((int)UnobservedExceptionWriteLogType != 4)
			{
				text = "UnobservedTaskException: " + ex.ToString();
			}
			LogType unobservedExceptionWriteLogType = UnobservedExceptionWriteLogType;
			switch ((int)unobservedExceptionWriteLogType)
			{
			case 0:
				Debug.LogError((object)text);
				break;
			case 1:
				Debug.LogAssertion((object)text);
				break;
			case 2:
				Debug.LogWarning((object)text);
				break;
			case 3:
				Debug.Log((object)text);
				break;
			case 4:
				Debug.LogException(ex);
				break;
			}
		}
	}
	public class UniTaskSynchronizationContext : SynchronizationContext
	{
		[StructLayout(LayoutKind.Auto)]
		private readonly struct Callback
		{
			private readonly SendOrPostCallback callback;

			private readonly object state;

			public Callback(SendOrPostCallback callback, object state)
			{
				this.callback = callback;
				this.state = state;
			}

			public void Invoke()
			{
				try
				{
					callback(state);
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
			}
		}

		private const int MaxArrayLength = 2146435071;

		private const int InitialSize = 16;

		private static SpinLock gate = new SpinLock(enableThreadOwnerTracking: false);

		private static bool dequing = false;

		private static int actionListCount = 0;

		private static Callback[] actionList = new Callback[16];

		private static int waitingListCount = 0;

		private static Callback[] waitingList = new Callback[16];

		private static int opCount;

		public override void Send(SendOrPostCallback d, object state)
		{
			d(state);
		}

		public override void Post(SendOrPostCallback d, object state)
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				if (dequing)
				{
					if (waitingList.Length == waitingListCount)
					{
						int num = waitingListCount * 2;
						if ((uint)num > 2146435071u)
						{
							num = 2146435071;
						}
						Callback[] destinationArray = new Callback[num];
						Array.Copy(waitingList, destinationArray, waitingListCount);
						waitingList = destinationArray;
					}
					waitingList[waitingListCount] = new Callback(d, state);
					waitingListCount++;
					return;
				}
				if (actionList.Length == actionListCount)
				{
					int num2 = actionListCount * 2;
					if ((uint)num2 > 2146435071u)
					{
						num2 = 2146435071;
					}
					Callback[] destinationArray2 = new Callback[num2];
					Array.Copy(actionList, destinationArray2, actionListCount);
					actionList = destinationArray2;
				}
				actionList[actionListCount] = new Callback(d, state);
				actionListCount++;
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}

		public override void OperationStarted()
		{
			Interlocked.Increment(ref opCount);
		}

		public override void OperationCompleted()
		{
			Interlocked.Decrement(ref opCount);
		}

		public override SynchronizationContext CreateCopy()
		{
			return this;
		}

		internal static void Run()
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				if (actionListCount == 0)
				{
					return;
				}
				dequing = true;
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
			for (int i = 0; i < actionListCount; i++)
			{
				Callback callback = actionList[i];
				actionList[i] = default(Callback);
				callback.Invoke();
			}
			bool lockTaken2 = false;
			try
			{
				gate.Enter(ref lockTaken2);
				dequing = false;
				Callback[] array = actionList;
				actionListCount = waitingListCount;
				actionList = waitingList;
				waitingListCount = 0;
				waitingList = array;
			}
			finally
			{
				if (lockTaken2)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	[AsyncMethodBuilder(typeof(AsyncUniTaskVoidMethodBuilder))]
	public readonly struct UniTaskVoid
	{
		public void Forget()
		{
		}
	}
	public static class UnityAsyncExtensions
	{
		public struct AssetBundleRequestAllAssetsAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private AssetBundleRequest asyncOperation;

			private Action<AsyncOperation> continuationAction;

			public bool IsCompleted => ((AsyncOperation)asyncOperation).isDone;

			public AssetBundleRequestAllAssetsAwaiter(AssetBundleRequest asyncOperation)
			{
				this.asyncOperation = asyncOperation;
				continuationAction = null;
			}

			public AssetBundleRequestAllAssetsAwaiter GetAwaiter()
			{
				return this;
			}

			public Object[] GetResult()
			{
				if (continuationAction != null)
				{
					((AsyncOperation)asyncOperation).completed -= continuationAction;
					continuationAction = null;
					Object[] allAssets = asyncOperation.allAssets;
					asyncOperation = null;
					return allAssets;
				}
				Object[] allAssets2 = asyncOperation.allAssets;
				asyncOperation = null;
				return allAssets2;
			}

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

			public void UnsafeOnCompleted(Action continuation)
			{
				Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
				continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
				((AsyncOperation)asyncOperation).completed += continuationAction;
			}
		}

		private sealed class AssetBundleRequestAllAssetsConfiguredSource : IUniTaskSource<Object[]>, IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsConfiguredSource>
		{
			private static TaskPool<AssetBundleRequestAllAssetsConfiguredSource> pool;

			private AssetBundleRequestAllAssetsConfiguredSource nextNode;

			private AssetBundleRequest asyncOperation;

			private IProgress<float> progress;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<Object[]> core;

			public ref AssetBundleRequestAllAssetsConfiguredSource NextNode => ref nextNode;

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

			private AssetBundleRequestAllAssetsConfiguredSource()
			{
			}

			public static IUniTaskSource<Object[]> Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<Object[]>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new AssetBundleRequestAllAssetsConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.progress = progress;
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

			public Object[] GetResult(short token)
			{
				try
				{
					return core.GetResult(token);
				}
				finally
				{
					TryReturn();
				}
			}

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

			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 (progress != null)
				{
					progress.Report(((AsyncOperation)asyncOperation).progress);
				}
				if (((AsyncOperation)asyncOperation).isDone)
				{
					core.TrySetResult(asyncOperation.allAssets);
					return false;
				}
				return true;
			}

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

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

			private AsyncGPUReadbackRequestAwaiterConfiguredSource nextNode;

			private AsyncGPUReadbackRequest asyncOperation;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<AsyncGPUReadbackRequest> core;

			public ref AsyncGPUReadbackRequestAwaiterConfiguredSource NextNode => ref nextNode;

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

			private AsyncGPUReadbackRequestAwaiterConfiguredSource()
			{
			}

			public static IUniTaskSource<AsyncGPUReadbackRequest> Create(AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<AsyncGPUReadbackRequest>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new AsyncGPUReadbackRequestAwaiterConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

			public AsyncGPUReadbackRequest GetResult(short token)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					return core.GetResult(token);
				}
				finally
				{
					TryReturn();
				}
			}

			void IUniTaskSource.GetResult(short token)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				GetResult(token);
			}

			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()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				if (cancellationToken.IsCancellationRequested)
				{
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				if (((AsyncGPUReadbackRequest)(ref asyncOperation)).hasError)
				{
					core.TrySetException(new Exception("AsyncGPUReadbackRequest.hasError = true"));
					return false;
				}
				if (((AsyncGPUReadbackRequest)(ref asyncOperation)).done)
				{
					core.TrySetResult(asyncOperation);
					return false;
				}
				return true;
			}

			private bool TryReturn()
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				TaskTracker.RemoveTracking(this);
				core.Reset();
				asyncOperation = default(AsyncGPUReadbackRequest);
				cancellationToken = default(CancellationToken);
				return pool.TryPush(this);
			}
		}

		private sealed class JobHandlePromise : IUniTaskSource, IPlayerLoopItem
		{
			private JobHandle jobHandle;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public static JobHandlePromise Create(JobHandle jobHandle, out short token)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				JobHandlePromise jobHandlePromise = new JobHandlePromise();
				jobHandlePromise.jobHandle = jobHandle;
				TaskTracker.TrackActiveTask(jobHandlePromise, 3);
				token = jobHandlePromise.core.Version;
				return jobHandlePromise;
			}

			public void GetResult(short token)
			{
				TaskTracker.RemoveTracking(this);
				core.GetResult(token);
			}

			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 (((JobHandle)(ref jobHandle)).IsCompleted | PlayerLoopHelper.IsEditorApplicationQuitting)
				{
					((JobHandle)(ref jobHandle)).Complete();
					core.TrySetResult(AsyncUnit.Default);
					return false;
				}
				return true;
			}
		}

		public struct AsyncOperationAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private AsyncOperation asyncOperation;

			private Action<AsyncOperation> continuationAction;

			public bool IsCompleted => asyncOperation.isDone;

			public AsyncOperationAwaiter(AsyncOperation asyncOperation)
			{
				this.asyncOperation = asyncOperation;
				continuationAction = null;
			}

			public void GetResult()
			{
				if (continuationAction != null)
				{
					asyncOperation.completed -= continuationAction;
					continuationAction = null;
					asyncOperation = null;
				}
				else
				{
					asyncOperation = null;
				}
			}

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

			public void UnsafeOnCompleted(Action continuation)
			{
				Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
				continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
				asyncOperation.completed += continuationAction;
			}
		}

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

			private AsyncOperationConfiguredSource nextNode;

			private AsyncOperation asyncOperation;

			private IProgress<float> progress;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public ref AsyncOperationConfiguredSource NextNode => ref nextNode;

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

			private AsyncOperationConfiguredSource()
			{
			}

			public static IUniTaskSource Create(AsyncOperation asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new AsyncOperationConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.progress = progress;
				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 (progress != null)
				{
					progress.Report(asyncOperation.progress);
				}
				if (asyncOperation.isDone)
				{
					core.TrySetResult(AsyncUnit.Default);
					return false;
				}
				return true;
			}

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

		public struct ResourceRequestAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private ResourceRequest asyncOperation;

			private Action<AsyncOperation> continuationAction;

			public bool IsCompleted => ((AsyncOperation)asyncOperation).isDone;

			public ResourceRequestAwaiter(ResourceRequest asyncOperation)
			{
				this.asyncOperation = asyncOperation;
				continuationAction = null;
			}

			public Object GetResult()
			{
				if (continuationAction != null)
				{
					((AsyncOperation)asyncOperation).completed -= continuationAction;
					continuationAction = null;
					Object asset = asyncOperation.asset;
					asyncOperation = null;
					return asset;
				}
				Object asset2 = asyncOperation.asset;
				asyncOperation = null;
				return asset2;
			}

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

			public void UnsafeOnCompleted(Action continuation)
			{
				Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
				continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
				((AsyncOperation)asyncOperation).completed += continuationAction;
			}
		}

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

			private ResourceRequestConfiguredSource nextNode;

			private ResourceRequest asyncOperation;

			private IProgress<float> progress;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<Object> core;

			public ref ResourceRequestConfiguredSource NextNode => ref nextNode;

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

			private ResourceRequestConfiguredSource()
			{
			}

			public static IUniTaskSource<Object> Create(ResourceRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<Object>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new ResourceRequestConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.progress = progress;
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

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

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

			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 (progress != null)
				{
					progress.Report(((AsyncOperation)asyncOperation).progress);
				}
				if (((AsyncOperation)asyncOperation).isDone)
				{
					core.TrySetResult(asyncOperation.asset);
					return false;
				}
				return true;
			}

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

		public struct AssetBundleRequestAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private AssetBundleRequest asyncOperation;

			private Action<AsyncOperation> continuationAction;

			public bool IsCompleted => ((AsyncOperation)asyncOperation).isDone;

			public AssetBundleRequestAwaiter(AssetBundleRequest asyncOperation)
			{
				this.asyncOperation = asyncOperation;
				continuationAction = null;
			}

			public Object GetResult()
			{
				if (continuationAction != null)
				{
					((AsyncOperation)asyncOperation).completed -= continuationAction;
					continuationAction = null;
					Object asset = asyncOperation.asset;
					asyncOperation = null;
					return asset;
				}
				Object asset2 = asyncOperation.asset;
				asyncOperation = null;
				return asset2;
			}

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

			public void UnsafeOnCompleted(Action continuation)
			{
				Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
				continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
				((AsyncOperation)asyncOperation).completed += continuationAction;
			}
		}

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

			private AssetBundleRequestConfiguredSource nextNode;

			private AssetBundleRequest asyncOperation;

			private IProgress<float> progress;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<Object> core;

			public ref AssetBundleRequestConfiguredSource NextNode => ref nextNode;

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

			private AssetBundleRequestConfiguredSource()
			{
			}

			public static IUniTaskSource<Object> Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<Object>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new AssetBundleRequestConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.progress = progress;
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

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

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

			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 (progress != null)
				{
					progress.Report(((AsyncOperation)asyncOperation).progress);
				}
				if (((AsyncOperation)asyncOperation).isDone)
				{
					core.TrySetResult(asyncOperation.asset);
					return false;
				}
				return true;
			}

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

		public struct AssetBundleCreateRequestAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private AssetBundleCreateRequest asyncOperation;

			private Action<AsyncOperation> continuationAction;

			public bool IsCompleted => ((AsyncOperation)asyncOperation).isDone;

			public AssetBundleCreateRequestAwaiter(AssetBundleCreateRequest asyncOperation)
			{
				this.asyncOperation = asyncOperation;
				continuationAction = null;
			}

			public AssetBundle GetResult()
			{
				if (continuationAction != null)
				{
					((AsyncOperation)asyncOperation).completed -= continuationAction;
					continuationAction = null;
					AssetBundle assetBundle = asyncOperation.assetBundle;
					asyncOperation = null;
					return assetBundle;
				}
				AssetBundle assetBundle2 = asyncOperation.assetBundle;
				asyncOperation = null;
				return assetBundle2;
			}

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

			public void UnsafeOnCompleted(Action continuation)
			{
				Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
				continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
				((AsyncOperation)asyncOperation).completed += continuationAction;
			}
		}

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

			private AssetBundleCreateRequestConfiguredSource nextNode;

			private AssetBundleCreateRequest asyncOperation;

			private IProgress<float> progress;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<AssetBundle> core;

			public ref AssetBundleCreateRequestConfiguredSource NextNode => ref nextNode;

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

			private AssetBundleCreateRequestConfiguredSource()
			{
			}

			public static IUniTaskSource<AssetBundle> Create(AssetBundleCreateRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<AssetBundle>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new AssetBundleCreateRequestConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.progress = progress;
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

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

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

			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 (progress != null)
				{
					progress.Report(((AsyncOperation)asyncOperation).progress);
				}
				if (((AsyncOperation)asyncOperation).isDone)
				{
					core.TrySetResult(asyncOperation.assetBundle);
					return false;
				}
				return true;
			}

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

		public struct UnityWebRequestAsyncOperationAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private UnityWebRequestAsyncOperation asyncOperation;

			private Action<AsyncOperation> continuationAction;

			public bool IsCompleted => ((AsyncOperation)asyncOperation).isDone;

			public UnityWebRequestAsyncOperationAwaiter(UnityWebRequestAsyncOperation asyncOperation)
			{
				this.asyncOperation = asyncOperation;
				continuationAction = null;
			}

			public UnityWebRequest GetResult()
			{
				if (continuationAction != null)
				{
					((AsyncOperation)asyncOperation).completed -= continuationAction;
					continuationAction = null;
					UnityWebRequest webRequest = asyncOperation.webRequest;
					asyncOperation = null;
					if (webRequest.IsError())
					{
						throw new UnityWebRequestException(webRequest);
					}
					return webRequest;
				}
				UnityWebRequest webRequest2 = asyncOperation.webRequest;
				asyncOperation = null;
				if (webRequest2.IsError())
				{
					throw new UnityWebRequestException(webRequest2);
				}
				return webRequest2;
			}

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

			public void UnsafeOnCompleted(Action continuation)
			{
				Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
				continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
				((AsyncOperation)asyncOperation).completed += continuationAction;
			}
		}

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

			private UnityWebRequestAsyncOperationConfiguredSource nextNode;

			private UnityWebRequestAsyncOperation asyncOperation;

			private IProgress<float> progress;

			private CancellationToken cancellationToken;

			private UniTaskCompletionSourceCore<UnityWebRequest> core;

			public ref UnityWebRequestAsyncOperationConfiguredSource NextNode => ref nextNode;

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

			private UnityWebRequestAsyncOperationConfiguredSource()
			{
			}

			public static IUniTaskSource<UnityWebRequest> Create(UnityWebRequestAsyncOperation asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return AutoResetUniTaskCompletionSource<UnityWebRequest>.CreateFromCanceled(cancellationToken, out token);
				}
				if (!pool.TryPop(out var result))
				{
					result = new UnityWebRequestAsyncOperationConfiguredSource();
				}
				result.asyncOperation = asyncOperation;
				result.progress = progress;
				result.cancellationToken = cancellationToken;
				TaskTracker.TrackActiveTask(result, 3);
				PlayerLoopHelper.AddAction(timing, result);
				token = result.core.Version;
				return result;
			}

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

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

			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)
				{
					asyncOperation.webRequest.Abort();
					core.TrySetCanceled(cancellationToken);
					return false;
				}
				if (progress != null)
				{
					progress.Report(((AsyncOperation)asyncOperation).progress);
				}
				if (((AsyncOperation)asyncOperation).isDone)
				{
					if (asyncOperation.webRequest.IsError())
					{
						core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest));
					}
					else
					{
						core.TrySetResult(asyncOperation.webRequest);
					}
					return false;
				}
				return true;
			}

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

		public static AssetBundleRequestAllAssetsAwaiter AwaitForAllAssets(this AssetBundleRequest asyncOperation)
		{
			Error.ThrowArgumentNullException<AssetBundleRequest>(asyncOperation, "asyncOperation");
			return new AssetBundleRequestAllAssetsAwaiter(asyncOperation);
		}

		public static UniTask<Object[]> AwaitForAllAssets(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
		{
			return asyncOperation.AwaitForAllAssets(null, PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask<Object[]> AwaitForAllAssets(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException<AssetBundleRequest>(asyncOperation, "asyncOperation");
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled<Object[]>(cancellationToken);
			}
			if (((AsyncOperation)asyncOperation).isDone)
			{
				return UniTask.FromResult(asyncOperation.allAssets);
			}
			short token;
			return new UniTask<Object[]>(AssetBundleRequestAllAssetsConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out token), token);
		}

		public static UniTask<AsyncGPUReadbackRequest>.Awaiter GetAwaiter(this AsyncGPUReadbackRequest asyncOperation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return asyncOperation.ToUniTask().GetAwaiter();
		}

		public static UniTask<AsyncGPUReadbackRequest> WithCancellation(this AsyncGPUReadbackRequest asyncOperation, CancellationToken cancellationToken)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return asyncOperation.ToUniTask(PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask<AsyncGPUReadbackRequest> ToUniTask(this AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (((AsyncGPUReadbackRequest)(ref asyncOperation)).done)
			{
				return UniTask.FromResult<AsyncGPUReadbackRequest>(asyncOperation);
			}
			short token;
			return new UniTask<AsyncGPUReadbackRequest>(AsyncGPUReadbackRequestAwaiterConfiguredSource.Create(asyncOperation, timing, cancellationToken, out token), token);
		}

		public static async UniTask WaitAsync(this JobHandle jobHandle, PlayerLoopTiming waitTiming, CancellationToken cancellationToken = default(CancellationToken))
		{
			//IL_0002: 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)
			await UniTask.Yield(waitTiming);
			((JobHandle)(ref jobHandle)).Complete();
			cancellationToken.ThrowIfCancellationRequested();
		}

		public static UniTask.Awaiter GetAwaiter(this JobHandle jobHandle)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			short token;
			JobHandlePromise jobHandlePromise = JobHandlePromise.Create(jobHandle, out token);
			PlayerLoopHelper.AddAction(PlayerLoopTiming.EarlyUpdate, jobHandlePromise);
			PlayerLoopHelper.AddAction(PlayerLoopTiming.PreUpdate, jobHandlePromise);
			PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, jobHandlePromise);
			PlayerLoopHelper.AddAction(PlayerLoopTiming.PreLateUpdate, jobHandlePromise);
			PlayerLoopHelper.AddAction(PlayerLoopTiming.PostLateUpdate, jobHandlePromise);
			return new UniTask(jobHandlePromise, token).GetAwaiter();
		}

		public static UniTask ToUniTask(this JobHandle jobHandle, PlayerLoopTiming waitTiming)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			short token;
			JobHandlePromise jobHandlePromise = JobHandlePromise.Create(jobHandle, out token);
			PlayerLoopHelper.AddAction(waitTiming, jobHandlePromise);
			return new UniTask(jobHandlePromise, token);
		}

		public static UniTask StartAsyncCoroutine(this MonoBehaviour monoBehaviour, Func<CancellationToken, UniTask> asyncCoroutine)
		{
			CancellationToken cancellationTokenOnDestroy = ((Component)(object)monoBehaviour).GetCancellationTokenOnDestroy();
			return asyncCoroutine(cancellationTokenOnDestroy);
		}

		public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation asyncOperation)
		{
			Error.ThrowArgumentNullException<AsyncOperation>(asyncOperation, "asyncOperation");
			return new AsyncOperationAwaiter(asyncOperation);
		}

		public static UniTask WithCancellation(this AsyncOperation asyncOperation, CancellationToken cancellationToken)
		{
			return asyncOperation.ToUniTask(null, PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask ToUniTask(this AsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException<AsyncOperation>(asyncOperation, "asyncOperation");
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled(cancellationToken);
			}
			if (asyncOperation.isDone)
			{
				return UniTask.CompletedTask;
			}
			short token;
			return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out token), token);
		}

		public static ResourceRequestAwaiter GetAwaiter(this ResourceRequest asyncOperation)
		{
			Error.ThrowArgumentNullException<ResourceRequest>(asyncOperation, "asyncOperation");
			return new ResourceRequestAwaiter(asyncOperation);
		}

		public static UniTask<Object> WithCancellation(this ResourceRequest asyncOperation, CancellationToken cancellationToken)
		{
			return asyncOperation.ToUniTask(null, PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask<Object> ToUniTask(this ResourceRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException<ResourceRequest>(asyncOperation, "asyncOperation");
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled<Object>(cancellationToken);
			}
			if (((AsyncOperation)asyncOperation).isDone)
			{
				return UniTask.FromResult<Object>(asyncOperation.asset);
			}
			short token;
			return new UniTask<Object>(ResourceRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out token), token);
		}

		public static AssetBundleRequestAwaiter GetAwaiter(this AssetBundleRequest asyncOperation)
		{
			Error.ThrowArgumentNullException<AssetBundleRequest>(asyncOperation, "asyncOperation");
			return new AssetBundleRequestAwaiter(asyncOperation);
		}

		public static UniTask<Object> WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
		{
			return asyncOperation.ToUniTask(null, PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask<Object> ToUniTask(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException<AssetBundleRequest>(asyncOperation, "asyncOperation");
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled<Object>(cancellationToken);
			}
			if (((AsyncOperation)asyncOperation).isDone)
			{
				return UniTask.FromResult<Object>(asyncOperation.asset);
			}
			short token;
			return new UniTask<Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out token), token);
		}

		public static AssetBundleCreateRequestAwaiter GetAwaiter(this AssetBundleCreateRequest asyncOperation)
		{
			Error.ThrowArgumentNullException<AssetBundleCreateRequest>(asyncOperation, "asyncOperation");
			return new AssetBundleCreateRequestAwaiter(asyncOperation);
		}

		public static UniTask<AssetBundle> WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken)
		{
			return asyncOperation.ToUniTask(null, PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException<AssetBundleCreateRequest>(asyncOperation, "asyncOperation");
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled<AssetBundle>(cancellationToken);
			}
			if (((AsyncOperation)asyncOperation).isDone)
			{
				return UniTask.FromResult<AssetBundle>(asyncOperation.assetBundle);
			}
			short token;
			return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out token), token);
		}

		public static UnityWebRequestAsyncOperationAwaiter GetAwaiter(this UnityWebRequestAsyncOperation asyncOperation)
		{
			Error.ThrowArgumentNullException<UnityWebRequestAsyncOperation>(asyncOperation, "asyncOperation");
			return new UnityWebRequestAsyncOperationAwaiter(asyncOperation);
		}

		public static UniTask<UnityWebRequest> WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken)
		{
			return asyncOperation.ToUniTask(null, PlayerLoopTiming.Update, cancellationToken);
		}

		public static UniTask<UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException<UnityWebRequestAsyncOperation>(asyncOperation, "asyncOperation");
			if (cancellationToken.IsCancellationRequested)
			{
				return UniTask.FromCanceled<UnityWebRequest>(cancellationToken);
			}
			if (((AsyncOperation)asyncOperation).isDone)
			{
				if (asyncOperation.webRequest.IsError())
				{
					return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
				}
				return UniTask.FromResult<UnityWebRequest>(asyncOperation.webRequest);
			}
			short token;
			return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out token), token);
		}

		public static AsyncUnityEventHandler GetAsyncEventHandler(this UnityEvent unityEvent, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler(unityEvent, cancellationToken, callOnce: false);
		}

		public static UniTask OnInvokeAsync(this UnityEvent unityEvent, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler(unityEvent, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<AsyncUnit> OnInvokeAsAsyncEnumerable(this UnityEvent unityEvent, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable(unityEvent, cancellationToken);
		}

		public static AsyncUnityEventHandler<T> GetAsyncEventHandler<T>(this UnityEvent<T> unityEvent, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<T>(unityEvent, cancellationToken, callOnce: false);
		}

		public static UniTask<T> OnInvokeAsync<T>(this UnityEvent<T> unityEvent, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<T>(unityEvent, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<T> OnInvokeAsAsyncEnumerable<T>(this UnityEvent<T> unityEvent, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<T>(unityEvent, cancellationToken);
		}

		public static IAsyncClickEventHandler GetAsyncClickEventHandler(this Button button)
		{
			return new AsyncUnityEventHandler((UnityEvent)(object)button.onClick, ((Component)(object)button).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncClickEventHandler GetAsyncClickEventHandler(this Button button, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler((UnityEvent)(object)button.onClick, cancellationToken, callOnce: false);
		}

		public static UniTask OnClickAsync(this Button button)
		{
			return new AsyncUnityEventHandler((UnityEvent)(object)button.onClick, ((Component)(object)button).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask OnClickAsync(this Button button, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler((UnityEvent)(object)button.onClick, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<AsyncUnit> OnClickAsAsyncEnumerable(this Button button)
		{
			return new UnityEventHandlerAsyncEnumerable((UnityEvent)(object)button.onClick, ((Component)(object)button).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<AsyncUnit> OnClickAsAsyncEnumerable(this Button button, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable((UnityEvent)(object)button.onClick, cancellationToken);
		}

		public static IAsyncValueChangedEventHandler<bool> GetAsyncValueChangedEventHandler(this Toggle toggle)
		{
			return new AsyncUnityEventHandler<bool>((UnityEvent<bool>)(object)toggle.onValueChanged, ((Component)(object)toggle).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncValueChangedEventHandler<bool> GetAsyncValueChangedEventHandler(this Toggle toggle, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<bool>((UnityEvent<bool>)(object)toggle.onValueChanged, cancellationToken, callOnce: false);
		}

		public static UniTask<bool> OnValueChangedAsync(this Toggle toggle)
		{
			return new AsyncUnityEventHandler<bool>((UnityEvent<bool>)(object)toggle.onValueChanged, ((Component)(object)toggle).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<bool> OnValueChangedAsync(this Toggle toggle, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<bool>((UnityEvent<bool>)(object)toggle.onValueChanged, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<bool> OnValueChangedAsAsyncEnumerable(this Toggle toggle)
		{
			return new UnityEventHandlerAsyncEnumerable<bool>((UnityEvent<bool>)(object)toggle.onValueChanged, ((Component)(object)toggle).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<bool> OnValueChangedAsAsyncEnumerable(this Toggle toggle, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<bool>((UnityEvent<bool>)(object)toggle.onValueChanged, cancellationToken);
		}

		public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Scrollbar scrollbar)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)scrollbar.onValueChanged, ((Component)(object)scrollbar).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Scrollbar scrollbar, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)scrollbar.onValueChanged, cancellationToken, callOnce: false);
		}

		public static UniTask<float> OnValueChangedAsync(this Scrollbar scrollbar)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)scrollbar.onValueChanged, ((Component)(object)scrollbar).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<float> OnValueChangedAsync(this Scrollbar scrollbar, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)scrollbar.onValueChanged, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<float> OnValueChangedAsAsyncEnumerable(this Scrollbar scrollbar)
		{
			return new UnityEventHandlerAsyncEnumerable<float>((UnityEvent<float>)(object)scrollbar.onValueChanged, ((Component)(object)scrollbar).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<float> OnValueChangedAsAsyncEnumerable(this Scrollbar scrollbar, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<float>((UnityEvent<float>)(object)scrollbar.onValueChanged, cancellationToken);
		}

		public static IAsyncValueChangedEventHandler<Vector2> GetAsyncValueChangedEventHandler(this ScrollRect scrollRect)
		{
			return new AsyncUnityEventHandler<Vector2>((UnityEvent<Vector2>)(object)scrollRect.onValueChanged, ((Component)(object)scrollRect).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncValueChangedEventHandler<Vector2> GetAsyncValueChangedEventHandler(this ScrollRect scrollRect, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<Vector2>((UnityEvent<Vector2>)(object)scrollRect.onValueChanged, cancellationToken, callOnce: false);
		}

		public static UniTask<Vector2> OnValueChangedAsync(this ScrollRect scrollRect)
		{
			return new AsyncUnityEventHandler<Vector2>((UnityEvent<Vector2>)(object)scrollRect.onValueChanged, ((Component)(object)scrollRect).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<Vector2> OnValueChangedAsync(this ScrollRect scrollRect, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<Vector2>((UnityEvent<Vector2>)(object)scrollRect.onValueChanged, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<Vector2> OnValueChangedAsAsyncEnumerable(this ScrollRect scrollRect)
		{
			return new UnityEventHandlerAsyncEnumerable<Vector2>((UnityEvent<Vector2>)(object)scrollRect.onValueChanged, ((Component)(object)scrollRect).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<Vector2> OnValueChangedAsAsyncEnumerable(this ScrollRect scrollRect, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<Vector2>((UnityEvent<Vector2>)(object)scrollRect.onValueChanged, cancellationToken);
		}

		public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Slider slider)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)slider.onValueChanged, ((Component)(object)slider).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Slider slider, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)slider.onValueChanged, cancellationToken, callOnce: false);
		}

		public static UniTask<float> OnValueChangedAsync(this Slider slider)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)slider.onValueChanged, ((Component)(object)slider).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<float> OnValueChangedAsync(this Slider slider, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<float>((UnityEvent<float>)(object)slider.onValueChanged, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<float> OnValueChangedAsAsyncEnumerable(this Slider slider)
		{
			return new UnityEventHandlerAsyncEnumerable<float>((UnityEvent<float>)(object)slider.onValueChanged, ((Component)(object)slider).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<float> OnValueChangedAsAsyncEnumerable(this Slider slider, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<float>((UnityEvent<float>)(object)slider.onValueChanged, cancellationToken);
		}

		public static IAsyncEndEditEventHandler<string> GetAsyncEndEditEventHandler(this InputField inputField)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onEndEdit, ((Component)(object)inputField).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncEndEditEventHandler<string> GetAsyncEndEditEventHandler(this InputField inputField, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onEndEdit, cancellationToken, callOnce: false);
		}

		public static UniTask<string> OnEndEditAsync(this InputField inputField)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onEndEdit, ((Component)(object)inputField).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<string> OnEndEditAsync(this InputField inputField, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onEndEdit, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<string> OnEndEditAsAsyncEnumerable(this InputField inputField)
		{
			return new UnityEventHandlerAsyncEnumerable<string>((UnityEvent<string>)(object)inputField.onEndEdit, ((Component)(object)inputField).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<string> OnEndEditAsAsyncEnumerable(this InputField inputField, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<string>((UnityEvent<string>)(object)inputField.onEndEdit, cancellationToken);
		}

		public static IAsyncValueChangedEventHandler<string> GetAsyncValueChangedEventHandler(this InputField inputField)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onValueChanged, ((Component)(object)inputField).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncValueChangedEventHandler<string> GetAsyncValueChangedEventHandler(this InputField inputField, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onValueChanged, cancellationToken, callOnce: false);
		}

		public static UniTask<string> OnValueChangedAsync(this InputField inputField)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onValueChanged, ((Component)(object)inputField).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<string> OnValueChangedAsync(this InputField inputField, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<string>((UnityEvent<string>)(object)inputField.onValueChanged, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<string> OnValueChangedAsAsyncEnumerable(this InputField inputField)
		{
			return new UnityEventHandlerAsyncEnumerable<string>((UnityEvent<string>)(object)inputField.onValueChanged, ((Component)(object)inputField).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<string> OnValueChangedAsAsyncEnumerable(this InputField inputField, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<string>((UnityEvent<string>)(object)inputField.onValueChanged, cancellationToken);
		}

		public static IAsyncValueChangedEventHandler<int> GetAsyncValueChangedEventHandler(this Dropdown dropdown)
		{
			return new AsyncUnityEventHandler<int>((UnityEvent<int>)(object)dropdown.onValueChanged, ((Component)(object)dropdown).GetCancellationTokenOnDestroy(), callOnce: false);
		}

		public static IAsyncValueChangedEventHandler<int> GetAsyncValueChangedEventHandler(this Dropdown dropdown, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<int>((UnityEvent<int>)(object)dropdown.onValueChanged, cancellationToken, callOnce: false);
		}

		public static UniTask<int> OnValueChangedAsync(this Dropdown dropdown)
		{
			return new AsyncUnityEventHandler<int>((UnityEvent<int>)(object)dropdown.onValueChanged, ((Component)(object)dropdown).GetCancellationTokenOnDestroy(), callOnce: true).OnInvokeAsync();
		}

		public static UniTask<int> OnValueChangedAsync(this Dropdown dropdown, CancellationToken cancellationToken)
		{
			return new AsyncUnityEventHandler<int>((UnityEvent<int>)(object)dropdown.onValueChanged, cancellationToken, callOnce: true).OnInvokeAsync();
		}

		public static IUniTaskAsyncEnumerable<int> OnValueChangedAsAsyncEnumerable(this Dropdown dropdown)
		{
			return new UnityEventHandlerAsyncEnumerable<int>((UnityEvent<int>)(object)dropdown.onValueChanged, ((Component)(object)dropdown).GetCancellationTokenOnDestroy());
		}

		public static IUniTaskAsyncEnumerable<int> OnValueChangedAsAsyncEnumerable(this Dropdown dropdown, CancellationToken cancellationToken)
		{
			return new UnityEventHandlerAsyncEnumerable<int>((UnityEvent<int>)(object)dropdown.onValueChanged, cancellationToken);
		}
	}
	public interface IAsyncClickEventHandler : IDisposable
	{
		UniTask OnClickAsync();
	}
	public interface IAsyncValueChangedEventHandler<T> : IDisposable
	{
		UniTask<T> OnValueChangedAsync();
	}
	public interface IAsyncEndEditEventHandler<T> : IDisposable
	{
		UniTask<T> OnEndEditAsync();
	}
	public interface IAsyncEndTextSelectionEventHandler<T> : IDisposable
	{
		UniTask<T> OnEndTextSelectionAsync();
	}
	public interface IAsyncTextSelectionEventHandler<T> : IDisposable
	{
		UniTask<T> OnTextSelectionAsync();
	}
	public interface IAsyncDeselectEventHandler<T> : IDisposable
	{
		UniTask<T> OnDeselectAsync();
	}
	public interface IAsyncSelectEventHandler<T> : IDisposable
	{
		UniTask<T> OnSelectAsync();
	}
	public interface IAsyncSubmitEventHandler<T> : IDisposable
	{
		UniTask<T> OnSubmitAsync();
	}
	internal class TextSelectionEventConverter : UnityEvent<(string, int, int)>, IDisposable
	{
		private readonly UnityEvent<string, int, int> innerEvent;

		private readonly UnityAction<string, int, int> invokeDelegate;

		public TextSelectionEventConverter(UnityEvent<string, int, int> unityEvent)
		{
			innerEvent = unityEvent;
			invokeDelegate = InvokeCore;
			innerEvent.AddListener(invokeDelegate);
		}

		private void InvokeCore(string item1, int item2, int item3)
		{
			innerEvent.Invoke(item1, item2, item3);
		}

		public void Dispose()
		{
			innerEvent.RemoveListener(invokeDelegate);
		}
	}
	public class AsyncUnityEventHandler : IUniTaskSource, IDisposable, IAsyncClickEventHandler
	{
		private static Action<object> cancellationCallback = CancellationCallback;

		private readonly UnityAction action;

		private readonly UnityEvent unityEvent;

		private CancellationToken cancellationToken;

		private CancellationTokenRegistration registration;

		private bool isDisposed;

		private bool callOnce;

		private UniTaskCompletionSourceCore<AsyncUnit> core;

		public AsyncUnityEventHandler(UnityEvent unityEvent, CancellationToken cancellationToken, bool callOnce)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			this.cancellationToken = cancellationToken;
			if (cancellationToken.IsCancellationRequested)
			{
				isDisposed = true;
				return;
			}
			action = new UnityAction(Invoke);
			this.unityEvent = unityEvent;
			this.callOnce = callOnce;
			unityEvent.AddListener(action);
			if (cancellationToken.CanBeCanceled)
			{
				registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
			}
			TaskTracker.TrackActiveTask(this, 3);
		}

		public UniTask OnInvokeAsync()
		{
			core.Reset();
			if (isDisposed)
			{
				core.TrySetCanceled(cancellationToken);
			}
			return new UniTask(this, core.Version);
		}

		private void Invoke()
		{
			core.TrySetResult(AsyncUnit.Default);
		}

		private static void CancellationCallback(object state)
		{
			((AsyncUnityEventHandler)state).Dispose();
		}

		public void Dispose()
		{
			if (!isDisposed)
			{
				isDisposed = true;
				TaskTracker.RemoveTracking(this);
				registration.Dispose();
				if (unityEvent != null)
				{
					unityEvent.RemoveListener(action);
				}
				core.TrySetCanceled(cancellationToken);
			}
		}

		UniTask IAsyncClickEventHandler.OnClickAsync()
		{
			return OnInvokeAsync();
		}

		void IUniTaskSource.GetResult(short token)
		{
			try
			{
				core.GetResult(token);
			}
			finally
			{
				if (callOnce)
				{
					Dispose();
				}
			}
		}

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

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

		void IUniTaskSource.OnCompleted(Action<object> continuation, object state, short token)
		{
			core.OnCompleted(continuation, state, token);
		}
	}
	public class AsyncUnityEventHandler<T> : IUniTaskSource<T>, IUniTaskSource, IDisposable, IAsyncValueChangedEventHandler<T>, IAsyncEndEditEventHandler<T>, IAsyncEndTextSelectionEventHandler<T>, IAsyncTextSelectionEventHandler<T>, IAsyncDeselectEventHandler<T>, IAsyncSelectEventHandler<T>, IAsyncSubmitEventHandler<T>
	{
		private static Action<object> cancellationCallback = CancellationCallback;

		private readonly UnityAction<T> action;

		private readonly UnityEvent<T> unityEvent;

		private CancellationToken cancellationToken;

		private CancellationTokenRegistration registration;

		private bool isDisposed;

		private bool callOnce;

		private UniTaskCompletionSourceCore<T> core;

		public AsyncUnityEventHandler(UnityEvent<T> unityEvent, CancellationToken cancellationToken, bool callOnce)
		{
			this.cancellationToken = cancellationToken;
			if (cancellationToken.IsCancellationRequested)
			{
				isDisposed = true;
				return;
			}
			action = Invoke;
			this.unityEvent = unityEvent;
			this.callOnce = callOnce;
			unityEvent.AddListener(action);
			if (cancellationToken.CanBeCanceled)
			{
				registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
			}
			TaskTracker.TrackActiveTask(this, 3);
		}

		public UniTask<T> OnInvokeAsync()
		{
			core.Reset();
			if (isDisposed)
			{
				core.TrySetCanceled(cancellationToken);
			}
			return new UniTask<T>(this, core.Version);
		}

		private void Invoke(T result)
		{
			core.TrySetResult(result);
		}

		private static void CancellationCallback(object state)
		{
			((AsyncUnityEventHandler<T>)state).Dispose();
		}

		public void Dispose()
		{
			if (isDisposed)
			{
				return;
			}
			isDisposed = true;
			TaskTracker.RemoveTracking(this);
			registration.Dispose();
			if (unityEvent != null)
			{
				if (unityEvent is IDisposable disposable)
				{
					disposable.Dispose();
				}
				unityEvent.RemoveListener(action);
			}
			core.TrySetCanceled();
		}

		UniTask<T> IAsyncValueChangedEventHandler<T>.OnValueChangedAsync()
		{
			return OnInvokeAsync();
		}

		UniTask<T> IAsyncEndEditEventHandler<T>.OnEndEditAsync()
		{
			return OnInvokeAsync();
		}

		UniTask<T> IAsyncEndTextSelectionEventHandler<T>.OnEndTextSelectionAsync()
		{
			return OnInvokeAsync();
		}

		UniTask<T> IAsyncTextSelectionEventHandler<T>.OnTextSelectionAsync()
		{
			return OnInvokeAsync();
		}

		UniTask<T> IAsyncDeselectEventHandler<T>.OnDeselectAsync()
		{
			return OnInvokeAsync();
		}

		UniTask<T> IAsyncSelectEventHandler<T>.OnSelectAsync()
		{
			return OnInvokeAsync();
		}

		UniTask<T> IAsyncSubmitEventHandler<T>.OnSubmitAsync()
		{
			return OnInvokeAsync();
		}

		T IUniTaskSource<T>.GetResult(short token)
		{
			try
			{
				return core.GetResult(token);
			}
			finally
			{
				if (callOnce)
				{
					Dispose();
				}
			}
		}

		void IUniTaskSource.GetResult(short token)
		{
			((IUniTaskSource<T>)this).GetResult(token);
		}

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

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

		void IUniTaskSource.OnCompleted(Action<object> continuation, object state, short token)
		{
			core.OnCompleted(continuation, state, token);
		}
	}
	public class UnityEventHandlerAsyncEnumerable : IUniTaskAsyncEnumerable<AsyncUnit>
	{
		private class UnityEventHandlerAsyncEnumerator : MoveNextSource, IUniTaskAsyncEnumerator<AsyncUnit>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> cancel1 = OnCanceled1;

			private static readonly Action<object> cancel2 = OnCanceled2;

			private readonly UnityEvent unityEvent;

			private CancellationToken cancellationToken1;

			private CancellationToken cancellationToken2;

			private UnityAction unityAction;

			private CancellationTokenRegistration registration1;

			private CancellationTokenRegistration registration2;

			private bool isDisposed;

			public AsyncUnit Current => default(AsyncUnit);

			public UnityEventHandlerAsyncEnumerator(UnityEvent unityEvent, CancellationToken cancellationToken1, CancellationToken cancellationToken2)
			{
				this.unityEvent = unityEvent;
				this.cancellationToken1 = cancellationToken1;
				this.cancellationToken2 = cancellationToken2;
			}

			public UniTask<bool> MoveNextAsync()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				cancellationToken1.ThrowIfCancellationRequested();
				cancellationToken2.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (unityAction == null)
				{
					unityAction = new UnityAction(Invoke);
					TaskTracker.TrackActiveTask(this, 3);
					unityEvent.AddListener(unityAction);
					if (cancellationToken1.CanBeCanceled)
					{
						registration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(cancel1, this);
					}
					if (cancellationToken2.CanBeCanceled)
					{
						registration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(cancel2, this);
					}
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void Invoke()
			{
				completionSource.TrySetResult(result: true);
			}

			private static void OnCanceled1(object state)
			{
				UnityEventHandlerAsyncEnumerator unityEventHandlerAsyncEnumerator = (UnityEventHandlerAsyncEnumerator)state;
				try
				{
					unityEventHandlerAsyncEnumerator.completionSource.TrySetCanceled(unityEventHandlerAsyncEnumerator.cancellationToken1);
				}
				finally
				{
					unityEventHandlerAsyncEnumerator.DisposeAsync().Forget();
				}
			}

			private static void OnCanceled2(object state)
			{
				UnityEventHandlerAsyncEnumerator unityEventHandlerAsyncEnumerator = (UnityEventHandlerAsyncEnumerator)state;
				try
				{
					unityEventHandlerAsyncEnumerator.completionSource.TrySetCanceled(unityEventHandlerAsyncEnumerator.cancellationToken2);
				}
				finally
				{
					unityEventHandlerAsyncEnumerator.DisposeAsync().Forget();
				}
			}

			public UniTask DisposeAsync()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					TaskTracker.RemoveTracking(this);
					registration1.Dispose();
					registration2.Dispose();
					unityEvent.RemoveListener(unityAction);
					completionSource.TrySetCanceled();
				}
				return default(UniTask);
			}
		}

		private readonly UnityEvent unityEvent;

		private readonly CancellationToken cancellationToken1;

		public UnityEventHandlerAsyncEnumerable(UnityEvent unityEvent, CancellationToken cancellationToken)
		{
			this.unityEvent = unityEvent;
			cancellationToken1 = cancellationToken;
		}

		public IUniTaskAsyncEnumerator<AsyncUnit> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken1 == cancellationToken)
			{
				return new UnityEventHandlerAsyncEnumerator(unityEvent, cancellationToken1, CancellationToken.None);
			}
			return new UnityEventHandlerAsyncEnumerator(unityEvent, cancellationToken1, cancellationToken);
		}
	}
	public class UnityEventHandlerAsyncEnumerable<T> : IUniTaskAsyncEnumerable<T>
	{
		private class UnityEventHandlerAsyncEnumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> cancel1 = OnCanceled1;

			private static readonly Action<object> cancel2 = OnCanceled2;

			private readonly UnityEvent<T> unityEvent;

			private CancellationToken cancellationToken1;

			private CancellationToken cancellationToken2;

			private UnityAction<T> unityAction;

			private CancellationTokenRegistration registration1;

			private CancellationTokenRegistration registration2;

			private bool isDisposed;

			public T Current { get; private set; }

			public UnityEventHandlerAsyncEnumerator(UnityEvent<T> unityEvent, CancellationToken cancellationToken1, CancellationToken cancellationToken2)
			{
				this.unityEvent = unityEvent;
				this.cancellationToken1 = cancellationToken1;
				this.cancellationToken2 = cancellationToken2;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken1.ThrowIfCancellationRequested();
				cancellationToken2.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (unityAction == null)
				{
					unityAction = Invoke;
					TaskTracker.TrackActiveTask(this, 3);
					unityEvent.AddListener(unityAction);
					if (cancellationToken1.CanBeCanceled)
					{
						registration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(cancel1, this);
					}
					if (cancellationToken2.CanBeCanceled)
					{
						registration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(cancel2, this);
					}
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void Invoke(T value)
			{
				Current = value;
				completionSource.TrySetResult(result: true);
			}

			private static void OnCanceled1(object state)
			{
				UnityEventHandlerAsyncEnumerator unityEventHandlerAsyncEnumerator = (UnityEventHandlerAsyncEnumerator)state;
				try
				{
					unityEventHandlerAsyncEnumerator.completionSource.TrySetCanceled(unityEventHandlerAsyncEnumerator.cancellationToken1);
				}
				finally
				{
					unityEventHandlerAsyncEnumerator.DisposeAsync().Forget();
				}
			}

			private static void OnCanceled2(object state)
			{
				UnityEventHandlerAsyncEnumerator unityEventHandlerAsyncEnumerator = (UnityEventHandlerAsyncEnumerator)state;
				try
				{
					unityEventHandlerAsyncEnumerator.completionSource.TrySetCanceled(unityEventHandlerAsyncEnumerator.cancellationToken2);
				}
				finally
				{
					unityEventHandlerAsyncEnumerator.DisposeAsync().Forget();
				}
			}

			public UniTask DisposeAsync()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					TaskTracker.RemoveTracking(this);
					registration1.Dispose();
					registration2.Dispose();
					if (unityEvent is IDisposable disposable)
					{
						disposable.Dispose();
					}
					unityEvent.RemoveListener(unityAction);
					completionSource.TrySetCanceled();
				}
				return default(UniTask);
			}
		}

		private readonly UnityEvent<T> unityEvent;

		private readonly CancellationToken cancellationToken1;

		public UnityEventHandlerAsyncEnumerable(UnityEvent<T> unityEvent, CancellationToken cancellationToken)
		{
			this.unityEvent = unityEvent;
			cancellationToken1 = cancellationToken;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken1 == cancellationToken)
			{
				return new UnityEventHandlerAsyncEnumerator(unityEvent, cancellationToken1, CancellationToken.None);
			}
			return new UnityEventHandlerAsyncEnumerator(unityEvent, cancellationToken1, cancellationToken);
		}
	}
	public static class UnityBindingExtensions
	{
		public static void BindTo(this IUniTaskAsyncEnumerable<string> source, Text text, bool rebindOnError = true)
		{
			BindToCore(source, text, ((Component)(object)text).GetCancellationTokenOnDestroy(), rebindOnError).Forget();
		}

		public static void BindTo(this IUniTaskAsyncEnumerable<string> source, Text text, CancellationToken cancellationToken, bool rebindOnError = true)
		{
			BindToCore(source, text, cancellationToken, rebindOnError).Forget();
		}

		private static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable<string> source, Text text, CancellationToken cancellationToken, bool rebindOnError)
		{
			bool repeat = false;
			while (true)
			{
				IUniTaskAsyncEnumerator<string> e = source.GetAsyncEnumerator(cancellationToken);
				try
				{
					while (true)
					{
						bool flag;
						try
						{
							flag = await e.MoveNextAsync();
							repeat = false;
						}
						catch (Exception ex)
						{
							if (ex is OperationCanceledException)
							{
								break;
							}
							if (!rebindOnError || repeat)
							{
								throw;
							}
							repeat = true;
							goto end_IL_0000;
						}
						if (flag)
						{
							text.text = e.Current;
							continue;
						}
						break;
					}
					break;
					end_IL_0000:;
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
			}
			int num;
			if (num != 2)
			{
			}
		}

		public static void BindTo<T>(this IUniTaskAsyncEnumerable<T> source, Text text, bool rebindOnError = true)
		{
			BindToCore(source, text, ((Component)(object)text).GetCancellationTokenOnDestroy(), rebindOnError).Forget();
		}

		public static void BindTo<T>(this IUniTaskAsyncEnumerable<T> source, Text text, CancellationToken cancellationToken, bool rebindOnError = true)
		{
			BindToCore(source, text, cancellationToken, rebindOnError).Forget();
		}

		public static void BindTo<T>(this AsyncReactiveProperty<T> source, Text text, bool rebindOnError = true)
		{
			BindToCore(source, text, ((Component)(object)text).GetCancellationTokenOnDestroy(), rebindOnError).Forget();
		}

		private static async UniTaskVoid BindToCore<T>(IUniTaskAsyncEnumerable<T> source, Text text, CancellationToken cancellationToken, bool rebindOnError)
		{
			bool repeat = false;
			while (true)
			{
				IUniTaskAsyncEnumerator<T> e = source.GetAsyncEnumerator(cancellationToken);
				try
				{
					while (true)
					{
						bool flag;
						try
						{
							flag = await e.MoveNextAsync();
							repeat = false;
						}
						catch (Exception ex)
						{
							if (ex is OperationCanceledException)
							{
								break;
							}
							if (!rebindOnError || repeat)
							{
								throw;
							}
							repeat = true;
							goto end_IL_0000;
						}
						if (flag)
						{
							text.text = e.Current.ToString();
							continue;
						}
						break;
					}
					break;
					end_IL_0000:;
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
			}
			int num;
			if (num != 2)
			{
			}
		}

		public static void BindTo(this IUniTaskAsyncEnumerable<bool> source, Selectable selectable, bool rebindOnError = true)
		{
			BindToCore(source, selectable, ((Component)(object)selectable).GetCancellationTokenOnDestroy(), rebindOnError).Forget();
		}

		public static void BindTo(this IUniTaskAsyncEnumerable<bool> source, Selectable selectable, CancellationToken cancellationToken, bool rebindOnError = true)
		{
			BindToCore(source, selectable, cancellationToken, rebindOnError).Forget();
		}

		private static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable<bool> source, Selectable selectable, CancellationToken cancellationToken, bool rebindOnError)
		{
			bool repeat = false;
			while (true)
			{
				IUniTaskAsyncEnumerator<bool> e = source.GetAsyncEnumerator(cancellationToken);
				try
				{
					while (true)
					{
						bool flag;
						try
						{
							flag = await e.MoveNextAsync();
							repeat = false;
						}
						catch (Exception ex)
						{
							if (ex is OperationCanceledException)
							{
								break;
							}
							if (!rebindOnError || repeat)
							{
								throw;
							}
							repeat = true;
							goto end_IL_0000;
						}
						if (flag)
						{
							selectable.interactable = e.Current;
							continue;
						}
						break;
					}
					break;
					end_IL_0000:;
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
			}
			int num;
			if (num != 2)
			{
			}
		}

		public static void BindTo<TSource, TObject>(this IUniTaskAsyncEnumerable<TSource> source, TObject monoBehaviour, Action<TObject, TSource> bindAction, bool rebindOnError = true) where TObject : MonoBehaviour
		{
			BindToCore(source, monoBehaviour, bindAction, ((Component)(object)monoBehaviour).GetCancellationTokenOnDestroy(), rebindOnError).Forget();
		}

		public static void BindTo<TSource, TObject>(this IUniTaskAsyncEnumerable<TSource> source, TObject bindTarget, Action<TObject, TSource> bindAction, CancellationToken cancellationToken, bool rebindOnError = true)
		{
			BindToCore(source, bindTarget, bindAction, cancellationToken, rebindOnError).Forget();
		}

		private static async UniTaskVoid BindToCore<TSource, TObject>(IUniTaskAsyncEnumerable<TSource> source, TObject bindTarget, Action<TObject, TSource> bindAction, CancellationToken cancellationToken, bool rebindOnError)
		{
			bool repeat = false;
			while (true)
			{
				IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
				try
				{
					while (true)
					{
						bool flag;
						try
						{
							flag = await e.MoveNextAsync();
							repeat = false;
						}
						catch (Exception ex)
						{
							if (ex is OperationCanceledException)
							{
								break;
							}
							if (!rebindOnError || repeat)
							{
								throw;
							}
							repeat = true;
							goto end_IL_0000;
						}
						if (flag)
						{
							bindAction(bindTarget, e.Current);
							continue;
						}
						break;
					}
					break;
					end_IL_0000:;
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
			}
			int num;
			if (num != 2)
			{
			}
		}
	}
	public class UnityWebRequestException : Exception
	{
		private string msg;

		public UnityWebRequest UnityWebRequest { get; }

		public Result Result { get; }

		public string Error { get; }

		public string Text { get; }

		public long ResponseCode { get; }

		public Dictionary<string, string> ResponseHeaders { get; }

		public override string Message
		{
			get
			{
				if (msg == null)
				{
					if (!string.IsNullOrWhiteSpace(Text))
					{
						msg = Error + Environment.NewLine + Text;
					}
					else
					{
						msg = Error;
					}
				}
				return msg;
			}
		}

		public UnityWebRequestException(UnityWebRequest unityWebRequest)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			UnityWebRequest = unityWebRequest;
			Result = unityWebRequest.result;
			Error = unityWebRequest.error;
			ResponseCode = unityWebRequest.responseCode;
			if (UnityWebRequest.downloadHandler != null)
			{
				DownloadHandler downloadHandler = unityWebRequest.downloadHandler;
				DownloadHandlerBuffer val = (DownloadHandlerBuffer)(object)((downloadHandler is DownloadHandlerBuffer) ? downloadHandler : null);
				if (val != null)
				{
					Text = ((DownloadHandler)val).text;
				}
			}
			ResponseHeaders = unityWebRequest.GetResponseHeaders();
		}
	}
}
namespace Cysharp.Threading.Tasks.Triggers
{
	public static class AsyncTriggerExtensions
	{
		public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncAwakeTrigger>(gameObject);
		}

		public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this Component component)
		{
			return component.gameObject.GetAsyncAwakeTrigger();
		}

		public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDestroyTrigger>(gameObject);
		}

		public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDestroyTrigger();
		}

		public static AsyncStartTrigger GetAsyncStartTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncStartTrigger>(gameObject);
		}

		public static AsyncStartTrigger GetAsyncStartTrigger(this Component component)
		{
			return component.gameObject.GetAsyncStartTrigger();
		}

		private static T GetOrAddComponent<T>(GameObject gameObject) where T : Component
		{
			T result = default(T);
			if (!gameObject.TryGetComponent<T>(ref result))
			{
				return gameObject.AddComponent<T>();
			}
			return result;
		}

		public static UniTask OnDestroyAsync(this GameObject gameObject)
		{
			return gameObject.GetAsyncDestroyTrigger().OnDestroyAsync();
		}

		public static UniTask OnDestroyAsync(this Component component)
		{
			return component.GetAsyncDestroyTrigger().OnDestroyAsync();
		}

		public static UniTask StartAsync(this GameObject gameObject)
		{
			return gameObject.GetAsyncStartTrigger().StartAsync();
		}

		public static UniTask StartAsync(this Component component)
		{
			return component.GetAsyncStartTrigger().StartAsync();
		}

		public static UniTask AwakeAsync(this GameObject gameObject)
		{
			return gameObject.GetAsyncAwakeTrigger().AwakeAsync();
		}

		public static UniTask AwakeAsync(this Component component)
		{
			return component.GetAsyncAwakeTrigger().AwakeAsync();
		}

		public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncFixedUpdateTrigger>(gameObject);
		}

		public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this Component component)
		{
			return component.gameObject.GetAsyncFixedUpdateTrigger();
		}

		public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncLateUpdateTrigger>(gameObject);
		}

		public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this Component component)
		{
			return component.gameObject.GetAsyncLateUpdateTrigger();
		}

		public static AsyncAnimatorIKTrigger GetAsyncAnimatorIKTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncAnimatorIKTrigger>(gameObject);
		}

		public static AsyncAnimatorIKTrigger GetAsyncAnimatorIKTrigger(this Component component)
		{
			return component.gameObject.GetAsyncAnimatorIKTrigger();
		}

		public static AsyncAnimatorMoveTrigger GetAsyncAnimatorMoveTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncAnimatorMoveTrigger>(gameObject);
		}

		public static AsyncAnimatorMoveTrigger GetAsyncAnimatorMoveTrigger(this Component component)
		{
			return component.gameObject.GetAsyncAnimatorMoveTrigger();
		}

		public static AsyncApplicationFocusTrigger GetAsyncApplicationFocusTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncApplicationFocusTrigger>(gameObject);
		}

		public static AsyncApplicationFocusTrigger GetAsyncApplicationFocusTrigger(this Component component)
		{
			return component.gameObject.GetAsyncApplicationFocusTrigger();
		}

		public static AsyncApplicationPauseTrigger GetAsyncApplicationPauseTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncApplicationPauseTrigger>(gameObject);
		}

		public static AsyncApplicationPauseTrigger GetAsyncApplicationPauseTrigger(this Component component)
		{
			return component.gameObject.GetAsyncApplicationPauseTrigger();
		}

		public static AsyncApplicationQuitTrigger GetAsyncApplicationQuitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncApplicationQuitTrigger>(gameObject);
		}

		public static AsyncApplicationQuitTrigger GetAsyncApplicationQuitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncApplicationQuitTrigger();
		}

		public static AsyncAudioFilterReadTrigger GetAsyncAudioFilterReadTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncAudioFilterReadTrigger>(gameObject);
		}

		public static AsyncAudioFilterReadTrigger GetAsyncAudioFilterReadTrigger(this Component component)
		{
			return component.gameObject.GetAsyncAudioFilterReadTrigger();
		}

		public static AsyncBecameInvisibleTrigger GetAsyncBecameInvisibleTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncBecameInvisibleTrigger>(gameObject);
		}

		public static AsyncBecameInvisibleTrigger GetAsyncBecameInvisibleTrigger(this Component component)
		{
			return component.gameObject.GetAsyncBecameInvisibleTrigger();
		}

		public static AsyncBecameVisibleTrigger GetAsyncBecameVisibleTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncBecameVisibleTrigger>(gameObject);
		}

		public static AsyncBecameVisibleTrigger GetAsyncBecameVisibleTrigger(this Component component)
		{
			return component.gameObject.GetAsyncBecameVisibleTrigger();
		}

		public static AsyncBeforeTransformParentChangedTrigger GetAsyncBeforeTransformParentChangedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncBeforeTransformParentChangedTrigger>(gameObject);
		}

		public static AsyncBeforeTransformParentChangedTrigger GetAsyncBeforeTransformParentChangedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncBeforeTransformParentChangedTrigger();
		}

		public static AsyncOnCanvasGroupChangedTrigger GetAsyncOnCanvasGroupChangedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncOnCanvasGroupChangedTrigger>(gameObject);
		}

		public static AsyncOnCanvasGroupChangedTrigger GetAsyncOnCanvasGroupChangedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncOnCanvasGroupChangedTrigger();
		}

		public static AsyncCollisionEnterTrigger GetAsyncCollisionEnterTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCollisionEnterTrigger>(gameObject);
		}

		public static AsyncCollisionEnterTrigger GetAsyncCollisionEnterTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCollisionEnterTrigger();
		}

		public static AsyncCollisionEnter2DTrigger GetAsyncCollisionEnter2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCollisionEnter2DTrigger>(gameObject);
		}

		public static AsyncCollisionEnter2DTrigger GetAsyncCollisionEnter2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCollisionEnter2DTrigger();
		}

		public static AsyncCollisionExitTrigger GetAsyncCollisionExitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCollisionExitTrigger>(gameObject);
		}

		public static AsyncCollisionExitTrigger GetAsyncCollisionExitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCollisionExitTrigger();
		}

		public static AsyncCollisionExit2DTrigger GetAsyncCollisionExit2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCollisionExit2DTrigger>(gameObject);
		}

		public static AsyncCollisionExit2DTrigger GetAsyncCollisionExit2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCollisionExit2DTrigger();
		}

		public static AsyncCollisionStayTrigger GetAsyncCollisionStayTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCollisionStayTrigger>(gameObject);
		}

		public static AsyncCollisionStayTrigger GetAsyncCollisionStayTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCollisionStayTrigger();
		}

		public static AsyncCollisionStay2DTrigger GetAsyncCollisionStay2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCollisionStay2DTrigger>(gameObject);
		}

		public static AsyncCollisionStay2DTrigger GetAsyncCollisionStay2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCollisionStay2DTrigger();
		}

		public static AsyncControllerColliderHitTrigger GetAsyncControllerColliderHitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncControllerColliderHitTrigger>(gameObject);
		}

		public static AsyncControllerColliderHitTrigger GetAsyncControllerColliderHitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncControllerColliderHitTrigger();
		}

		public static AsyncDisableTrigger GetAsyncDisableTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDisableTrigger>(gameObject);
		}

		public static AsyncDisableTrigger GetAsyncDisableTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDisableTrigger();
		}

		public static AsyncDrawGizmosTrigger GetAsyncDrawGizmosTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDrawGizmosTrigger>(gameObject);
		}

		public static AsyncDrawGizmosTrigger GetAsyncDrawGizmosTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDrawGizmosTrigger();
		}

		public static AsyncDrawGizmosSelectedTrigger GetAsyncDrawGizmosSelectedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDrawGizmosSelectedTrigger>(gameObject);
		}

		public static AsyncDrawGizmosSelectedTrigger GetAsyncDrawGizmosSelectedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDrawGizmosSelectedTrigger();
		}

		public static AsyncEnableTrigger GetAsyncEnableTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncEnableTrigger>(gameObject);
		}

		public static AsyncEnableTrigger GetAsyncEnableTrigger(this Component component)
		{
			return component.gameObject.GetAsyncEnableTrigger();
		}

		public static AsyncGUITrigger GetAsyncGUITrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncGUITrigger>(gameObject);
		}

		public static AsyncGUITrigger GetAsyncGUITrigger(this Component component)
		{
			return component.gameObject.GetAsyncGUITrigger();
		}

		public static AsyncJointBreakTrigger GetAsyncJointBreakTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncJointBreakTrigger>(gameObject);
		}

		public static AsyncJointBreakTrigger GetAsyncJointBreakTrigger(this Component component)
		{
			return component.gameObject.GetAsyncJointBreakTrigger();
		}

		public static AsyncJointBreak2DTrigger GetAsyncJointBreak2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncJointBreak2DTrigger>(gameObject);
		}

		public static AsyncJointBreak2DTrigger GetAsyncJointBreak2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncJointBreak2DTrigger();
		}

		public static AsyncMouseDownTrigger GetAsyncMouseDownTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseDownTrigger>(gameObject);
		}

		public static AsyncMouseDownTrigger GetAsyncMouseDownTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseDownTrigger();
		}

		public static AsyncMouseDragTrigger GetAsyncMouseDragTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseDragTrigger>(gameObject);
		}

		public static AsyncMouseDragTrigger GetAsyncMouseDragTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseDragTrigger();
		}

		public static AsyncMouseEnterTrigger GetAsyncMouseEnterTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseEnterTrigger>(gameObject);
		}

		public static AsyncMouseEnterTrigger GetAsyncMouseEnterTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseEnterTrigger();
		}

		public static AsyncMouseExitTrigger GetAsyncMouseExitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseExitTrigger>(gameObject);
		}

		public static AsyncMouseExitTrigger GetAsyncMouseExitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseExitTrigger();
		}

		public static AsyncMouseOverTrigger GetAsyncMouseOverTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseOverTrigger>(gameObject);
		}

		public static AsyncMouseOverTrigger GetAsyncMouseOverTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseOverTrigger();
		}

		public static AsyncMouseUpTrigger GetAsyncMouseUpTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseUpTrigger>(gameObject);
		}

		public static AsyncMouseUpTrigger GetAsyncMouseUpTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseUpTrigger();
		}

		public static AsyncMouseUpAsButtonTrigger GetAsyncMouseUpAsButtonTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMouseUpAsButtonTrigger>(gameObject);
		}

		public static AsyncMouseUpAsButtonTrigger GetAsyncMouseUpAsButtonTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMouseUpAsButtonTrigger();
		}

		public static AsyncParticleCollisionTrigger GetAsyncParticleCollisionTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncParticleCollisionTrigger>(gameObject);
		}

		public static AsyncParticleCollisionTrigger GetAsyncParticleCollisionTrigger(this Component component)
		{
			return component.gameObject.GetAsyncParticleCollisionTrigger();
		}

		public static AsyncParticleSystemStoppedTrigger GetAsyncParticleSystemStoppedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncParticleSystemStoppedTrigger>(gameObject);
		}

		public static AsyncParticleSystemStoppedTrigger GetAsyncParticleSystemStoppedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncParticleSystemStoppedTrigger();
		}

		public static AsyncParticleTriggerTrigger GetAsyncParticleTriggerTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncParticleTriggerTrigger>(gameObject);
		}

		public static AsyncParticleTriggerTrigger GetAsyncParticleTriggerTrigger(this Component component)
		{
			return component.gameObject.GetAsyncParticleTriggerTrigger();
		}

		public static AsyncParticleUpdateJobScheduledTrigger GetAsyncParticleUpdateJobScheduledTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncParticleUpdateJobScheduledTrigger>(gameObject);
		}

		public static AsyncParticleUpdateJobScheduledTrigger GetAsyncParticleUpdateJobScheduledTrigger(this Component component)
		{
			return component.gameObject.GetAsyncParticleUpdateJobScheduledTrigger();
		}

		public static AsyncPostRenderTrigger GetAsyncPostRenderTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPostRenderTrigger>(gameObject);
		}

		public static AsyncPostRenderTrigger GetAsyncPostRenderTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPostRenderTrigger();
		}

		public static AsyncPreCullTrigger GetAsyncPreCullTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPreCullTrigger>(gameObject);
		}

		public static AsyncPreCullTrigger GetAsyncPreCullTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPreCullTrigger();
		}

		public static AsyncPreRenderTrigger GetAsyncPreRenderTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPreRenderTrigger>(gameObject);
		}

		public static AsyncPreRenderTrigger GetAsyncPreRenderTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPreRenderTrigger();
		}

		public static AsyncRectTransformDimensionsChangeTrigger GetAsyncRectTransformDimensionsChangeTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncRectTransformDimensionsChangeTrigger>(gameObject);
		}

		public static AsyncRectTransformDimensionsChangeTrigger GetAsyncRectTransformDimensionsChangeTrigger(this Component component)
		{
			return component.gameObject.GetAsyncRectTransformDimensionsChangeTrigger();
		}

		public static AsyncRectTransformRemovedTrigger GetAsyncRectTransformRemovedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncRectTransformRemovedTrigger>(gameObject);
		}

		public static AsyncRectTransformRemovedTrigger GetAsyncRectTransformRemovedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncRectTransformRemovedTrigger();
		}

		public static AsyncRenderImageTrigger GetAsyncRenderImageTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncRenderImageTrigger>(gameObject);
		}

		public static AsyncRenderImageTrigger GetAsyncRenderImageTrigger(this Component component)
		{
			return component.gameObject.GetAsyncRenderImageTrigger();
		}

		public static AsyncRenderObjectTrigger GetAsyncRenderObjectTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncRenderObjectTrigger>(gameObject);
		}

		public static AsyncRenderObjectTrigger GetAsyncRenderObjectTrigger(this Component component)
		{
			return component.gameObject.GetAsyncRenderObjectTrigger();
		}

		public static AsyncServerInitializedTrigger GetAsyncServerInitializedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncServerInitializedTrigger>(gameObject);
		}

		public static AsyncServerInitializedTrigger GetAsyncServerInitializedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncServerInitializedTrigger();
		}

		public static AsyncTransformChildrenChangedTrigger GetAsyncTransformChildrenChangedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTransformChildrenChangedTrigger>(gameObject);
		}

		public static AsyncTransformChildrenChangedTrigger GetAsyncTransformChildrenChangedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTransformChildrenChangedTrigger();
		}

		public static AsyncTransformParentChangedTrigger GetAsyncTransformParentChangedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTransformParentChangedTrigger>(gameObject);
		}

		public static AsyncTransformParentChangedTrigger GetAsyncTransformParentChangedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTransformParentChangedTrigger();
		}

		public static AsyncTriggerEnterTrigger GetAsyncTriggerEnterTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTriggerEnterTrigger>(gameObject);
		}

		public static AsyncTriggerEnterTrigger GetAsyncTriggerEnterTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTriggerEnterTrigger();
		}

		public static AsyncTriggerEnter2DTrigger GetAsyncTriggerEnter2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTriggerEnter2DTrigger>(gameObject);
		}

		public static AsyncTriggerEnter2DTrigger GetAsyncTriggerEnter2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTriggerEnter2DTrigger();
		}

		public static AsyncTriggerExitTrigger GetAsyncTriggerExitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTriggerExitTrigger>(gameObject);
		}

		public static AsyncTriggerExitTrigger GetAsyncTriggerExitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTriggerExitTrigger();
		}

		public static AsyncTriggerExit2DTrigger GetAsyncTriggerExit2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTriggerExit2DTrigger>(gameObject);
		}

		public static AsyncTriggerExit2DTrigger GetAsyncTriggerExit2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTriggerExit2DTrigger();
		}

		public static AsyncTriggerStayTrigger GetAsyncTriggerStayTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTriggerStayTrigger>(gameObject);
		}

		public static AsyncTriggerStayTrigger GetAsyncTriggerStayTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTriggerStayTrigger();
		}

		public static AsyncTriggerStay2DTrigger GetAsyncTriggerStay2DTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncTriggerStay2DTrigger>(gameObject);
		}

		public static AsyncTriggerStay2DTrigger GetAsyncTriggerStay2DTrigger(this Component component)
		{
			return component.gameObject.GetAsyncTriggerStay2DTrigger();
		}

		public static AsyncValidateTrigger GetAsyncValidateTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncValidateTrigger>(gameObject);
		}

		public static AsyncValidateTrigger GetAsyncValidateTrigger(this Component component)
		{
			return component.gameObject.GetAsyncValidateTrigger();
		}

		public static AsyncWillRenderObjectTrigger GetAsyncWillRenderObjectTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncWillRenderObjectTrigger>(gameObject);
		}

		public static AsyncWillRenderObjectTrigger GetAsyncWillRenderObjectTrigger(this Component component)
		{
			return component.gameObject.GetAsyncWillRenderObjectTrigger();
		}

		public static AsyncResetTrigger GetAsyncResetTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncResetTrigger>(gameObject);
		}

		public static AsyncResetTrigger GetAsyncResetTrigger(this Component component)
		{
			return component.gameObject.GetAsyncResetTrigger();
		}

		public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncUpdateTrigger>(gameObject);
		}

		public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this Component component)
		{
			return component.gameObject.GetAsyncUpdateTrigger();
		}

		public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncBeginDragTrigger>(gameObject);
		}

		public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this Component component)
		{
			return component.gameObject.GetAsyncBeginDragTrigger();
		}

		public static AsyncCancelTrigger GetAsyncCancelTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncCancelTrigger>(gameObject);
		}

		public static AsyncCancelTrigger GetAsyncCancelTrigger(this Component component)
		{
			return component.gameObject.GetAsyncCancelTrigger();
		}

		public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDeselectTrigger>(gameObject);
		}

		public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDeselectTrigger();
		}

		public static AsyncDragTrigger GetAsyncDragTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDragTrigger>(gameObject);
		}

		public static AsyncDragTrigger GetAsyncDragTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDragTrigger();
		}

		public static AsyncDropTrigger GetAsyncDropTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncDropTrigger>(gameObject);
		}

		public static AsyncDropTrigger GetAsyncDropTrigger(this Component component)
		{
			return component.gameObject.GetAsyncDropTrigger();
		}

		public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncEndDragTrigger>(gameObject);
		}

		public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this Component component)
		{
			return component.gameObject.GetAsyncEndDragTrigger();
		}

		public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncInitializePotentialDragTrigger>(gameObject);
		}

		public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this Component component)
		{
			return component.gameObject.GetAsyncInitializePotentialDragTrigger();
		}

		public static AsyncMoveTrigger GetAsyncMoveTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncMoveTrigger>(gameObject);
		}

		public static AsyncMoveTrigger GetAsyncMoveTrigger(this Component component)
		{
			return component.gameObject.GetAsyncMoveTrigger();
		}

		public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPointerClickTrigger>(gameObject);
		}

		public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPointerClickTrigger();
		}

		public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPointerDownTrigger>(gameObject);
		}

		public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPointerDownTrigger();
		}

		public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPointerEnterTrigger>(gameObject);
		}

		public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPointerEnterTrigger();
		}

		public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPointerExitTrigger>(gameObject);
		}

		public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPointerExitTrigger();
		}

		public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncPointerUpTrigger>(gameObject);
		}

		public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this Component component)
		{
			return component.gameObject.GetAsyncPointerUpTrigger();
		}

		public static AsyncScrollTrigger GetAsyncScrollTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncScrollTrigger>(gameObject);
		}

		public static AsyncScrollTrigger GetAsyncScrollTrigger(this Component component)
		{
			return component.gameObject.GetAsyncScrollTrigger();
		}

		public static AsyncSelectTrigger GetAsyncSelectTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncSelectTrigger>(gameObject);
		}

		public static AsyncSelectTrigger GetAsyncSelectTrigger(this Component component)
		{
			return component.gameObject.GetAsyncSelectTrigger();
		}

		public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncSubmitTrigger>(gameObject);
		}

		public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this Component component)
		{
			return component.gameObject.GetAsyncSubmitTrigger();
		}

		public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this GameObject gameObject)
		{
			return GetOrAddComponent<AsyncUpdateSelectedTrigger>(gameObject);
		}

		public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this Component component)
		{
			return component.gameObject.GetAsyncUpdateSelectedTrigger();
		}
	}
	[DisallowMultipleComponent]
	public sealed class AsyncAwakeTrigger : AsyncTriggerBase<AsyncUnit>
	{
		public UniTask AwakeAsync()
		{
			if (calledAwake)
			{
				return UniTask.CompletedTask;
			}
			return ((IAsyncOneShotTrigger)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OneShotAsync();
		}
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDestroyTrigger : MonoBehaviour
	{
		private class AwakeMonitor : IPlayerLoopItem
		{
			private readonly AsyncDestroyTrigger trigger;

			public AwakeMonitor(AsyncDestroyTrigger trigger)
			{
				this.trigger = trigger;
			}

			public bool MoveNext()
			{
				if (trigger.called)
				{
					return false;
				}
				if ((Object)(object)trigger == (Object)null)
				{
					trigger.OnDestroy();
					return false;
				}
				return true;
			}
		}

		private bool awakeCalled;

		private bool called;

		private CancellationTokenSource cancellationTokenSource;

		public CancellationToken CancellationToken
		{
			get
			{
				if (cancellationTokenSource == null)
				{
					cancellationTokenSource = new CancellationTokenSource();
				}
				if (!awakeCalled)
				{
					PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
				}
				return cancellationTokenSource.Token;
			}
		}

		private void Awake()
		{
			awakeCalled = true;
		}

		private void OnDestroy()
		{
			called = true;
			cancellationTokenSource?.Cancel();
			cancellationTokenSource?.Dispose();
		}

		public UniTask OnDestroyAsync()
		{
			if (called)
			{
				return UniTask.CompletedTask;
			}
			UniTaskCompletionSource uniTaskCompletionSource = new UniTaskCompletionSource();
			CancellationToken.RegisterWithoutCaptureExecutionContext(delegate(object state)
			{
				((UniTaskCompletionSource)state).TrySetResult();
			}, uniTaskCompletionSource);
			return uniTaskCompletionSource.Task;
		}
	}
	[DisallowMultipleComponent]
	public sealed class AsyncStartTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private bool called;

		private void Start()
		{
			called = true;
			RaiseEvent(AsyncUnit.Default);
		}

		public UniTask StartAsync()
		{
			if (called)
			{
				return UniTask.CompletedTask;
			}
			return ((IAsyncOneShotTrigger)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OneShotAsync();
		}
	}
	public abstract class AsyncTriggerBase<T> : MonoBehaviour, IUniTaskAsyncEnumerable<T>
	{
		private sealed class AsyncTriggerEnumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable, ITriggerHandler<T>
		{
			private static Action<object> cancellationCallback = CancellationCallback;

			private readonly AsyncTriggerBase<T> parent;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration registration;

			private bool called;

			private bool isDisposed;

			public T Current { get; private set; }

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

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

			public AsyncTriggerEnumerator(AsyncTriggerBase<T> parent, CancellationToken cancellationToken)
			{
				this.parent = parent;
				this.cancellationToken = cancellationToken;
			}

			public void OnCanceled(CancellationToken cancellationToken = default(CancellationToken))
			{
				completionSource.TrySetCanceled(cancellationToken);
			}

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

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

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

			private static void CancellationCallback(object state)
			{
				AsyncTriggerEnumerator asyncTriggerEnumerator = (AsyncTriggerEnumerator)state;
				asyncTriggerEnumerator.DisposeAsync().Forget();
				asyncTriggerEnumerator.completionSource.TrySetCanceled(asyncTriggerEnumerator.cancellationToken);
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (!called)
				{
					called = true;
					TaskTracker.TrackActiveTask(this, 3);
					parent.AddHandler(this);
					if (cancellationToken.CanBeCanceled)
					{
						registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
					}
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			public UniTask DisposeAsync()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					TaskTracker.RemoveTracking(this);
					registration.Dispose();
					parent.RemoveHandler(this);
				}
				return default(UniTask);
			}
		}

		private class AwakeMonitor : IPlayerLoopItem
		{
			private readonly AsyncTriggerBase<T> trigger;

			public AwakeMonitor(AsyncTriggerBase<T> trigger)
			{
				this.trigger = trigger;
			}

			public bool MoveNext()
			{
				if (trigger.calledAwake)
				{
					return false;
				}
				if ((Object)(object)trigger == (Object)null)
				{
					trigger.OnDestroy();
					return false;
				}
				return true;
			}
		}

		private TriggerEvent<T> triggerEvent;

		protected internal bool calledAwake;

		protected internal bool calledDestroy;

		private void Awake()
		{
			calledAwake = true;
		}

		private void OnDestroy()
		{
			if (!calledDestroy)
			{
				calledDestroy = true;
				triggerEvent.SetCompleted();
			}
		}

		internal void AddHandler(ITriggerHandler<T> handler)
		{
			if (!calledAwake)
			{
				PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
			}
			triggerEvent.Add(handler);
		}

		internal void RemoveHandler(ITriggerHandler<T> handler)
		{
			if (!calledAwake)
			{
				PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
			}
			triggerEvent.Remove(handler);
		}

		protected void RaiseEvent(T value)
		{
			triggerEvent.SetResult(value);
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new AsyncTriggerEnumerator(this, cancellationToken);
		}
	}
	public interface IAsyncOneShotTrigger
	{
		UniTask OneShotAsync();
	}
	public sealed class AsyncTriggerHandler<T> : IAsyncOneShotTrigger, IUniTaskSource<T>, IUniTaskSource, ITriggerHandler<T>, IDisposable, IAsyncFixedUpdateHandler, IAsyncLateUpdateHandler, IAsyncOnAnimatorIKHandler, IAsyncOnAnimatorMoveHandler, IAsyncOnApplicationFocusHandler, IAsyncOnApplicationPauseHandler, IAsyncOnApplicationQuitHandler, IAsyncOnAudioFilterReadHandler, IAsyncOnBecameInvisibleHandler, IAsyncOnBecameVisibleHandler, IAsyncOnBeforeTransformParentChangedHandler, IAsyncOnCanvasGroupChangedHandler, IAsyncOnCollisionEnterHandler, IAsyncOnCollisionEnter2DHandler, IAsyncOnCollisionExitHandler, IAsyncOnCollisionExit2DHandler, IAsyncOnCollisionStayHandler, IAsyncOnCollisionStay2DHandler, IAsyncOnControllerColliderHitHandler, IAsyncOnDisableHandler, IAsyncOnDrawGizmosHandler, IAsyncOnDrawGizmosSelectedHandler, IAsyncOnEnableHandler, IAsyncOnGUIHandler, IAsyncOnJointBreakHandler, IAsyncOnJointBreak2DHandler, IAsyncOnMouseDownHandler, IAsyncOnMouseDragHandler, IAsyncOnMouseEnterHandler, IAsyncOnMouseExitHandler, IAsyncOnMouseOverHandler, IAsyncOnMouseUpHandler, IAsyncOnMouseUpAsButtonHandler, IAsyncOnParticleCollisionHandler, IAsyncOnParticleSystemStoppedHandler, IAsyncOnParticleTriggerHandler, IAsyncOnParticleUpdateJobScheduledHandler, IAsyncOnPostRenderHandler, IAsyncOnPreCullHandler, IAsyncOnPreRenderHandler, IAsyncOnRectTransformDimensionsChangeHandler, IAsyncOnRectTransformRemovedHandler, IAsyncOnRenderImageHandler, IAsyncOnRenderObjectHandler, IAsyncOnServerInitializedHandler, IAsyncOnTransformChildrenChangedHandler, IAsyncOnTransformParentChangedHandler, IAsyncOnTriggerEnterHandler, IAsyncOnTriggerEnter2DHandler, IAsyncOnTriggerExitHandler, IAsyncOnTriggerExit2DHandler, IAsyncOnTriggerStayHandler, IAsyncOnTriggerStay2DHandler, IAsyncOnValidateHandler, IAsyncOnWillRenderObjectHandler, IAsyncResetHandler, IAsyncUpdateHandler, IAsyncOnBeginDragHandler, IAsyncOnCancelHandler, IAsyncOnDeselectHandler, IAsyncOnDragHandler, IAsyncOnDropHandler, IAsyncOnEndDragHandler, IAsyncOnInitializePotentialDragHandler, IAsyncOnMoveHandler, IAsyncOnPointerClickHandler, IAsyncOnPointerDownHandler, IAsyncOnPointerEnterHandler, IAsyncOnPointerExitHandler, IAsyncOnPointerUpHandler, IAsyncOnScrollHandler, IAsyncOnSelectHandler, IAsyncOnSubmitHandler, IAsyncOnUpdateSelectedHandler
	{
		private static Action<object> cancellationCallback = CancellationCallback;

		private readonly AsyncTriggerBase<T> trigger;

		private CancellationToken cancellationToken;

		private CancellationTokenRegistration registration;

		private bool isDisposed;

		private bool callOnce;

		private UniTaskCompletionSourceCore<T> core;

		internal CancellationToken CancellationToken => cancellationToken;

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

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

		UniTask IAsyncOneShotTrigger.OneShotAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		internal AsyncTriggerHandler(AsyncTriggerBase<T> trigger, bool callOnce)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				isDisposed = true;
				return;
			}
			this.trigger = trigger;
			cancellationToken = default(CancellationToken);
			registration = default(CancellationTokenRegistration);
			this.callOnce = callOnce;
			trigger.AddHandler(this);
			TaskTracker.TrackActiveTask(this, 3);
		}

		internal AsyncTriggerHandler(AsyncTriggerBase<T> trigger, CancellationToken cancellationToken, bool callOnce)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				isDisposed = true;
				return;
			}
			this.trigger = trigger;
			this.cancellationToken = cancellationToken;
			this.callOnce = callOnce;
			trigger.AddHandler(this);
			if (cancellationToken.CanBeCanceled)
			{
				registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
			}
			TaskTracker.TrackActiveTask(this, 3);
		}

		private static void CancellationCallback(object state)
		{
			AsyncTriggerHandler<T> asyncTriggerHandler = (AsyncTriggerHandler<T>)state;
			asyncTriggerHandler.Dispose();
			asyncTriggerHandler.core.TrySetCanceled(asyncTriggerHandler.cancellationToken);
		}

		public void Dispose()
		{
			if (!isDisposed)
			{
				isDisposed = true;
				TaskTracker.RemoveTracking(this);
				registration.Dispose();
				trigger.RemoveHandler(this);
			}
		}

		T IUniTaskSource<T>.GetResult(short token)
		{
			try
			{
				return core.GetResult(token);
			}
			finally
			{
				if (callOnce)
				{
					Dispose();
				}
			}
		}

		void ITriggerHandler<T>.OnNext(T value)
		{
			core.TrySetResult(value);
		}

		void ITriggerHandler<T>.OnCanceled(CancellationToken cancellationToken)
		{
			core.TrySetCanceled(cancellationToken);
		}

		void ITriggerHandler<T>.OnCompleted()
		{
			core.TrySetCanceled(CancellationToken.None);
		}

		void ITriggerHandler<T>.OnError(Exception ex)
		{
			core.TrySetException(ex);
		}

		void IUniTaskSource.GetResult(short token)
		{
			((IUniTaskSource<T>)this).GetResult(token);
		}

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

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

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

		UniTask IAsyncFixedUpdateHandler.FixedUpdateAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncLateUpdateHandler.LateUpdateAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<int> IAsyncOnAnimatorIKHandler.OnAnimatorIKAsync()
		{
			core.Reset();
			return new UniTask<int>((IUniTaskSource<int>)(object)this, core.Version);
		}

		UniTask IAsyncOnAnimatorMoveHandler.OnAnimatorMoveAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<bool> IAsyncOnApplicationFocusHandler.OnApplicationFocusAsync()
		{
			core.Reset();
			return new UniTask<bool>((IUniTaskSource<bool>)(object)this, core.Version);
		}

		UniTask<bool> IAsyncOnApplicationPauseHandler.OnApplicationPauseAsync()
		{
			core.Reset();
			return new UniTask<bool>((IUniTaskSource<bool>)(object)this, core.Version);
		}

		UniTask IAsyncOnApplicationQuitHandler.OnApplicationQuitAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<(float[] data, int channels)> IAsyncOnAudioFilterReadHandler.OnAudioFilterReadAsync()
		{
			core.Reset();
			return new UniTask<(float[], int)>((IUniTaskSource<(float[], int)>)(object)this, core.Version);
		}

		UniTask IAsyncOnBecameInvisibleHandler.OnBecameInvisibleAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnBecameVisibleHandler.OnBecameVisibleAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnBeforeTransformParentChangedHandler.OnBeforeTransformParentChangedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnCanvasGroupChangedHandler.OnCanvasGroupChangedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<Collision> IAsyncOnCollisionEnterHandler.OnCollisionEnterAsync()
		{
			core.Reset();
			return new UniTask<Collision>((IUniTaskSource<Collision>)(object)this, core.Version);
		}

		UniTask<Collision2D> IAsyncOnCollisionEnter2DHandler.OnCollisionEnter2DAsync()
		{
			core.Reset();
			return new UniTask<Collision2D>((IUniTaskSource<Collision2D>)(object)this, core.Version);
		}

		UniTask<Collision> IAsyncOnCollisionExitHandler.OnCollisionExitAsync()
		{
			core.Reset();
			return new UniTask<Collision>((IUniTaskSource<Collision>)(object)this, core.Version);
		}

		UniTask<Collision2D> IAsyncOnCollisionExit2DHandler.OnCollisionExit2DAsync()
		{
			core.Reset();
			return new UniTask<Collision2D>((IUniTaskSource<Collision2D>)(object)this, core.Version);
		}

		UniTask<Collision> IAsyncOnCollisionStayHandler.OnCollisionStayAsync()
		{
			core.Reset();
			return new UniTask<Collision>((IUniTaskSource<Collision>)(object)this, core.Version);
		}

		UniTask<Collision2D> IAsyncOnCollisionStay2DHandler.OnCollisionStay2DAsync()
		{
			core.Reset();
			return new UniTask<Collision2D>((IUniTaskSource<Collision2D>)(object)this, core.Version);
		}

		UniTask<ControllerColliderHit> IAsyncOnControllerColliderHitHandler.OnControllerColliderHitAsync()
		{
			core.Reset();
			return new UniTask<ControllerColliderHit>((IUniTaskSource<ControllerColliderHit>)(object)this, core.Version);
		}

		UniTask IAsyncOnDisableHandler.OnDisableAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnDrawGizmosHandler.OnDrawGizmosAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnDrawGizmosSelectedHandler.OnDrawGizmosSelectedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnEnableHandler.OnEnableAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnGUIHandler.OnGUIAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<float> IAsyncOnJointBreakHandler.OnJointBreakAsync()
		{
			core.Reset();
			return new UniTask<float>((IUniTaskSource<float>)(object)this, core.Version);
		}

		UniTask<Joint2D> IAsyncOnJointBreak2DHandler.OnJointBreak2DAsync()
		{
			core.Reset();
			return new UniTask<Joint2D>((IUniTaskSource<Joint2D>)(object)this, core.Version);
		}

		UniTask IAsyncOnMouseDownHandler.OnMouseDownAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnMouseDragHandler.OnMouseDragAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnMouseEnterHandler.OnMouseEnterAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnMouseExitHandler.OnMouseExitAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnMouseOverHandler.OnMouseOverAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnMouseUpHandler.OnMouseUpAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnMouseUpAsButtonHandler.OnMouseUpAsButtonAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<GameObject> IAsyncOnParticleCollisionHandler.OnParticleCollisionAsync()
		{
			core.Reset();
			return new UniTask<GameObject>((IUniTaskSource<GameObject>)(object)this, core.Version);
		}

		UniTask IAsyncOnParticleSystemStoppedHandler.OnParticleSystemStoppedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnParticleTriggerHandler.OnParticleTriggerAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<ParticleSystemJobData> IAsyncOnParticleUpdateJobScheduledHandler.OnParticleUpdateJobScheduledAsync()
		{
			core.Reset();
			return new UniTask<ParticleSystemJobData>((IUniTaskSource<ParticleSystemJobData>)(object)this, core.Version);
		}

		UniTask IAsyncOnPostRenderHandler.OnPostRenderAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnPreCullHandler.OnPreCullAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnPreRenderHandler.OnPreRenderAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnRectTransformDimensionsChangeHandler.OnRectTransformDimensionsChangeAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnRectTransformRemovedHandler.OnRectTransformRemovedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<(RenderTexture source, RenderTexture destination)> IAsyncOnRenderImageHandler.OnRenderImageAsync()
		{
			core.Reset();
			return new UniTask<(RenderTexture, RenderTexture)>((IUniTaskSource<(RenderTexture, RenderTexture)>)(object)this, core.Version);
		}

		UniTask IAsyncOnRenderObjectHandler.OnRenderObjectAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnServerInitializedHandler.OnServerInitializedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnTransformChildrenChangedHandler.OnTransformChildrenChangedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnTransformParentChangedHandler.OnTransformParentChangedAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<Collider> IAsyncOnTriggerEnterHandler.OnTriggerEnterAsync()
		{
			core.Reset();
			return new UniTask<Collider>((IUniTaskSource<Collider>)(object)this, core.Version);
		}

		UniTask<Collider2D> IAsyncOnTriggerEnter2DHandler.OnTriggerEnter2DAsync()
		{
			core.Reset();
			return new UniTask<Collider2D>((IUniTaskSource<Collider2D>)(object)this, core.Version);
		}

		UniTask<Collider> IAsyncOnTriggerExitHandler.OnTriggerExitAsync()
		{
			core.Reset();
			return new UniTask<Collider>((IUniTaskSource<Collider>)(object)this, core.Version);
		}

		UniTask<Collider2D> IAsyncOnTriggerExit2DHandler.OnTriggerExit2DAsync()
		{
			core.Reset();
			return new UniTask<Collider2D>((IUniTaskSource<Collider2D>)(object)this, core.Version);
		}

		UniTask<Collider> IAsyncOnTriggerStayHandler.OnTriggerStayAsync()
		{
			core.Reset();
			return new UniTask<Collider>((IUniTaskSource<Collider>)(object)this, core.Version);
		}

		UniTask<Collider2D> IAsyncOnTriggerStay2DHandler.OnTriggerStay2DAsync()
		{
			core.Reset();
			return new UniTask<Collider2D>((IUniTaskSource<Collider2D>)(object)this, core.Version);
		}

		UniTask IAsyncOnValidateHandler.OnValidateAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncOnWillRenderObjectHandler.OnWillRenderObjectAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncResetHandler.ResetAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask IAsyncUpdateHandler.UpdateAsync()
		{
			core.Reset();
			return new UniTask(this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnBeginDragHandler.OnBeginDragAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<BaseEventData> IAsyncOnCancelHandler.OnCancelAsync()
		{
			core.Reset();
			return new UniTask<BaseEventData>((IUniTaskSource<BaseEventData>)(object)this, core.Version);
		}

		UniTask<BaseEventData> IAsyncOnDeselectHandler.OnDeselectAsync()
		{
			core.Reset();
			return new UniTask<BaseEventData>((IUniTaskSource<BaseEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnDragHandler.OnDragAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnDropHandler.OnDropAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnEndDragHandler.OnEndDragAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnInitializePotentialDragHandler.OnInitializePotentialDragAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<AxisEventData> IAsyncOnMoveHandler.OnMoveAsync()
		{
			core.Reset();
			return new UniTask<AxisEventData>((IUniTaskSource<AxisEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnPointerClickHandler.OnPointerClickAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnPointerDownHandler.OnPointerDownAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnPointerEnterHandler.OnPointerEnterAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnPointerExitHandler.OnPointerExitAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnPointerUpHandler.OnPointerUpAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<PointerEventData> IAsyncOnScrollHandler.OnScrollAsync()
		{
			core.Reset();
			return new UniTask<PointerEventData>((IUniTaskSource<PointerEventData>)(object)this, core.Version);
		}

		UniTask<BaseEventData> IAsyncOnSelectHandler.OnSelectAsync()
		{
			core.Reset();
			return new UniTask<BaseEventData>((IUniTaskSource<BaseEventData>)(object)this, core.Version);
		}

		UniTask<BaseEventData> IAsyncOnSubmitHandler.OnSubmitAsync()
		{
			core.Reset();
			return new UniTask<BaseEventData>((IUniTaskSource<BaseEventData>)(object)this, core.Version);
		}

		UniTask<BaseEventData> IAsyncOnUpdateSelectedHandler.OnUpdateSelectedAsync()
		{
			core.Reset();
			return new UniTask<BaseEventData>((IUniTaskSource<BaseEventData>)(object)this, core.Version);
		}
	}
	public interface IAsyncFixedUpdateHandler
	{
		UniTask FixedUpdateAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncFixedUpdateTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void FixedUpdate()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncFixedUpdateHandler GetFixedUpdateAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncFixedUpdateHandler GetFixedUpdateAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask FixedUpdateAsync()
		{
			return ((IAsyncFixedUpdateHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).FixedUpdateAsync();
		}

		public UniTask FixedUpdateAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncFixedUpdateHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).FixedUpdateAsync();
		}
	}
	public interface IAsyncLateUpdateHandler
	{
		UniTask LateUpdateAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncLateUpdateTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void LateUpdate()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncLateUpdateHandler GetLateUpdateAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncLateUpdateHandler GetLateUpdateAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask LateUpdateAsync()
		{
			return ((IAsyncLateUpdateHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).LateUpdateAsync();
		}

		public UniTask LateUpdateAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncLateUpdateHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).LateUpdateAsync();
		}
	}
	public interface IAsyncOnAnimatorIKHandler
	{
		UniTask<int> OnAnimatorIKAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncAnimatorIKTrigger : AsyncTriggerBase<int>
	{
		private void OnAnimatorIK(int layerIndex)
		{
			RaiseEvent(layerIndex);
		}

		public IAsyncOnAnimatorIKHandler GetOnAnimatorIKAsyncHandler()
		{
			return new AsyncTriggerHandler<int>(this, callOnce: false);
		}

		public IAsyncOnAnimatorIKHandler GetOnAnimatorIKAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<int>(this, cancellationToken, callOnce: false);
		}

		public UniTask<int> OnAnimatorIKAsync()
		{
			return ((IAsyncOnAnimatorIKHandler)new AsyncTriggerHandler<int>(this, callOnce: true)).OnAnimatorIKAsync();
		}

		public UniTask<int> OnAnimatorIKAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnAnimatorIKHandler)new AsyncTriggerHandler<int>(this, cancellationToken, callOnce: true)).OnAnimatorIKAsync();
		}
	}
	public interface IAsyncOnAnimatorMoveHandler
	{
		UniTask OnAnimatorMoveAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncAnimatorMoveTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnAnimatorMove()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnAnimatorMoveHandler GetOnAnimatorMoveAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnAnimatorMoveHandler GetOnAnimatorMoveAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnAnimatorMoveAsync()
		{
			return ((IAsyncOnAnimatorMoveHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnAnimatorMoveAsync();
		}

		public UniTask OnAnimatorMoveAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnAnimatorMoveHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnAnimatorMoveAsync();
		}
	}
	public interface IAsyncOnApplicationFocusHandler
	{
		UniTask<bool> OnApplicationFocusAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncApplicationFocusTrigger : AsyncTriggerBase<bool>
	{
		private void OnApplicationFocus(bool hasFocus)
		{
			RaiseEvent(hasFocus);
		}

		public IAsyncOnApplicationFocusHandler GetOnApplicationFocusAsyncHandler()
		{
			return new AsyncTriggerHandler<bool>(this, callOnce: false);
		}

		public IAsyncOnApplicationFocusHandler GetOnApplicationFocusAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<bool>(this, cancellationToken, callOnce: false);
		}

		public UniTask<bool> OnApplicationFocusAsync()
		{
			return ((IAsyncOnApplicationFocusHandler)new AsyncTriggerHandler<bool>(this, callOnce: true)).OnApplicationFocusAsync();
		}

		public UniTask<bool> OnApplicationFocusAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnApplicationFocusHandler)new AsyncTriggerHandler<bool>(this, cancellationToken, callOnce: true)).OnApplicationFocusAsync();
		}
	}
	public interface IAsyncOnApplicationPauseHandler
	{
		UniTask<bool> OnApplicationPauseAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncApplicationPauseTrigger : AsyncTriggerBase<bool>
	{
		private void OnApplicationPause(bool pauseStatus)
		{
			RaiseEvent(pauseStatus);
		}

		public IAsyncOnApplicationPauseHandler GetOnApplicationPauseAsyncHandler()
		{
			return new AsyncTriggerHandler<bool>(this, callOnce: false);
		}

		public IAsyncOnApplicationPauseHandler GetOnApplicationPauseAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<bool>(this, cancellationToken, callOnce: false);
		}

		public UniTask<bool> OnApplicationPauseAsync()
		{
			return ((IAsyncOnApplicationPauseHandler)new AsyncTriggerHandler<bool>(this, callOnce: true)).OnApplicationPauseAsync();
		}

		public UniTask<bool> OnApplicationPauseAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnApplicationPauseHandler)new AsyncTriggerHandler<bool>(this, cancellationToken, callOnce: true)).OnApplicationPauseAsync();
		}
	}
	public interface IAsyncOnApplicationQuitHandler
	{
		UniTask OnApplicationQuitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncApplicationQuitTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnApplicationQuit()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnApplicationQuitHandler GetOnApplicationQuitAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnApplicationQuitHandler GetOnApplicationQuitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnApplicationQuitAsync()
		{
			return ((IAsyncOnApplicationQuitHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnApplicationQuitAsync();
		}

		public UniTask OnApplicationQuitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnApplicationQuitHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnApplicationQuitAsync();
		}
	}
	public interface IAsyncOnAudioFilterReadHandler
	{
		UniTask<(float[] data, int channels)> OnAudioFilterReadAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncAudioFilterReadTrigger : AsyncTriggerBase<(float[] data, int channels)>
	{
		private void OnAudioFilterRead(float[] data, int channels)
		{
			RaiseEvent((data, channels));
		}

		public IAsyncOnAudioFilterReadHandler GetOnAudioFilterReadAsyncHandler()
		{
			return new AsyncTriggerHandler<(float[], int)>(this, callOnce: false);
		}

		public IAsyncOnAudioFilterReadHandler GetOnAudioFilterReadAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<(float[], int)>(this, cancellationToken, callOnce: false);
		}

		public UniTask<(float[] data, int channels)> OnAudioFilterReadAsync()
		{
			return ((IAsyncOnAudioFilterReadHandler)new AsyncTriggerHandler<(float[], int)>(this, callOnce: true)).OnAudioFilterReadAsync();
		}

		public UniTask<(float[] data, int channels)> OnAudioFilterReadAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnAudioFilterReadHandler)new AsyncTriggerHandler<(float[], int)>(this, cancellationToken, callOnce: true)).OnAudioFilterReadAsync();
		}
	}
	public interface IAsyncOnBecameInvisibleHandler
	{
		UniTask OnBecameInvisibleAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncBecameInvisibleTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnBecameInvisible()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnBecameInvisibleHandler GetOnBecameInvisibleAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnBecameInvisibleHandler GetOnBecameInvisibleAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnBecameInvisibleAsync()
		{
			return ((IAsyncOnBecameInvisibleHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnBecameInvisibleAsync();
		}

		public UniTask OnBecameInvisibleAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnBecameInvisibleHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnBecameInvisibleAsync();
		}
	}
	public interface IAsyncOnBecameVisibleHandler
	{
		UniTask OnBecameVisibleAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncBecameVisibleTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnBecameVisible()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnBecameVisibleHandler GetOnBecameVisibleAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnBecameVisibleHandler GetOnBecameVisibleAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnBecameVisibleAsync()
		{
			return ((IAsyncOnBecameVisibleHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnBecameVisibleAsync();
		}

		public UniTask OnBecameVisibleAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnBecameVisibleHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnBecameVisibleAsync();
		}
	}
	public interface IAsyncOnBeforeTransformParentChangedHandler
	{
		UniTask OnBeforeTransformParentChangedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncBeforeTransformParentChangedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnBeforeTransformParentChanged()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnBeforeTransformParentChangedHandler GetOnBeforeTransformParentChangedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnBeforeTransformParentChangedHandler GetOnBeforeTransformParentChangedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnBeforeTransformParentChangedAsync()
		{
			return ((IAsyncOnBeforeTransformParentChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnBeforeTransformParentChangedAsync();
		}

		public UniTask OnBeforeTransformParentChangedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnBeforeTransformParentChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnBeforeTransformParentChangedAsync();
		}
	}
	public interface IAsyncOnCanvasGroupChangedHandler
	{
		UniTask OnCanvasGroupChangedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncOnCanvasGroupChangedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnCanvasGroupChanged()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnCanvasGroupChangedHandler GetOnCanvasGroupChangedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnCanvasGroupChangedHandler GetOnCanvasGroupChangedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnCanvasGroupChangedAsync()
		{
			return ((IAsyncOnCanvasGroupChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnCanvasGroupChangedAsync();
		}

		public UniTask OnCanvasGroupChangedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCanvasGroupChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnCanvasGroupChangedAsync();
		}
	}
	public interface IAsyncOnCollisionEnterHandler
	{
		UniTask<Collision> OnCollisionEnterAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCollisionEnterTrigger : AsyncTriggerBase<Collision>
	{
		private void OnCollisionEnter(Collision coll)
		{
			RaiseEvent(coll);
		}

		public IAsyncOnCollisionEnterHandler GetOnCollisionEnterAsyncHandler()
		{
			return new AsyncTriggerHandler<Collision>(this, callOnce: false);
		}

		public IAsyncOnCollisionEnterHandler GetOnCollisionEnterAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collision>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collision> OnCollisionEnterAsync()
		{
			return ((IAsyncOnCollisionEnterHandler)new AsyncTriggerHandler<Collision>(this, callOnce: true)).OnCollisionEnterAsync();
		}

		public UniTask<Collision> OnCollisionEnterAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCollisionEnterHandler)new AsyncTriggerHandler<Collision>(this, cancellationToken, callOnce: true)).OnCollisionEnterAsync();
		}
	}
	public interface IAsyncOnCollisionEnter2DHandler
	{
		UniTask<Collision2D> OnCollisionEnter2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCollisionEnter2DTrigger : AsyncTriggerBase<Collision2D>
	{
		private void OnCollisionEnter2D(Collision2D coll)
		{
			RaiseEvent(coll);
		}

		public IAsyncOnCollisionEnter2DHandler GetOnCollisionEnter2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Collision2D>(this, callOnce: false);
		}

		public IAsyncOnCollisionEnter2DHandler GetOnCollisionEnter2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collision2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collision2D> OnCollisionEnter2DAsync()
		{
			return ((IAsyncOnCollisionEnter2DHandler)new AsyncTriggerHandler<Collision2D>(this, callOnce: true)).OnCollisionEnter2DAsync();
		}

		public UniTask<Collision2D> OnCollisionEnter2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCollisionEnter2DHandler)new AsyncTriggerHandler<Collision2D>(this, cancellationToken, callOnce: true)).OnCollisionEnter2DAsync();
		}
	}
	public interface IAsyncOnCollisionExitHandler
	{
		UniTask<Collision> OnCollisionExitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCollisionExitTrigger : AsyncTriggerBase<Collision>
	{
		private void OnCollisionExit(Collision coll)
		{
			RaiseEvent(coll);
		}

		public IAsyncOnCollisionExitHandler GetOnCollisionExitAsyncHandler()
		{
			return new AsyncTriggerHandler<Collision>(this, callOnce: false);
		}

		public IAsyncOnCollisionExitHandler GetOnCollisionExitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collision>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collision> OnCollisionExitAsync()
		{
			return ((IAsyncOnCollisionExitHandler)new AsyncTriggerHandler<Collision>(this, callOnce: true)).OnCollisionExitAsync();
		}

		public UniTask<Collision> OnCollisionExitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCollisionExitHandler)new AsyncTriggerHandler<Collision>(this, cancellationToken, callOnce: true)).OnCollisionExitAsync();
		}
	}
	public interface IAsyncOnCollisionExit2DHandler
	{
		UniTask<Collision2D> OnCollisionExit2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCollisionExit2DTrigger : AsyncTriggerBase<Collision2D>
	{
		private void OnCollisionExit2D(Collision2D coll)
		{
			RaiseEvent(coll);
		}

		public IAsyncOnCollisionExit2DHandler GetOnCollisionExit2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Collision2D>(this, callOnce: false);
		}

		public IAsyncOnCollisionExit2DHandler GetOnCollisionExit2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collision2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collision2D> OnCollisionExit2DAsync()
		{
			return ((IAsyncOnCollisionExit2DHandler)new AsyncTriggerHandler<Collision2D>(this, callOnce: true)).OnCollisionExit2DAsync();
		}

		public UniTask<Collision2D> OnCollisionExit2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCollisionExit2DHandler)new AsyncTriggerHandler<Collision2D>(this, cancellationToken, callOnce: true)).OnCollisionExit2DAsync();
		}
	}
	public interface IAsyncOnCollisionStayHandler
	{
		UniTask<Collision> OnCollisionStayAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCollisionStayTrigger : AsyncTriggerBase<Collision>
	{
		private void OnCollisionStay(Collision coll)
		{
			RaiseEvent(coll);
		}

		public IAsyncOnCollisionStayHandler GetOnCollisionStayAsyncHandler()
		{
			return new AsyncTriggerHandler<Collision>(this, callOnce: false);
		}

		public IAsyncOnCollisionStayHandler GetOnCollisionStayAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collision>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collision> OnCollisionStayAsync()
		{
			return ((IAsyncOnCollisionStayHandler)new AsyncTriggerHandler<Collision>(this, callOnce: true)).OnCollisionStayAsync();
		}

		public UniTask<Collision> OnCollisionStayAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCollisionStayHandler)new AsyncTriggerHandler<Collision>(this, cancellationToken, callOnce: true)).OnCollisionStayAsync();
		}
	}
	public interface IAsyncOnCollisionStay2DHandler
	{
		UniTask<Collision2D> OnCollisionStay2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCollisionStay2DTrigger : AsyncTriggerBase<Collision2D>
	{
		private void OnCollisionStay2D(Collision2D coll)
		{
			RaiseEvent(coll);
		}

		public IAsyncOnCollisionStay2DHandler GetOnCollisionStay2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Collision2D>(this, callOnce: false);
		}

		public IAsyncOnCollisionStay2DHandler GetOnCollisionStay2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collision2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collision2D> OnCollisionStay2DAsync()
		{
			return ((IAsyncOnCollisionStay2DHandler)new AsyncTriggerHandler<Collision2D>(this, callOnce: true)).OnCollisionStay2DAsync();
		}

		public UniTask<Collision2D> OnCollisionStay2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCollisionStay2DHandler)new AsyncTriggerHandler<Collision2D>(this, cancellationToken, callOnce: true)).OnCollisionStay2DAsync();
		}
	}
	public interface IAsyncOnControllerColliderHitHandler
	{
		UniTask<ControllerColliderHit> OnControllerColliderHitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncControllerColliderHitTrigger : AsyncTriggerBase<ControllerColliderHit>
	{
		private void OnControllerColliderHit(ControllerColliderHit hit)
		{
			RaiseEvent(hit);
		}

		public IAsyncOnControllerColliderHitHandler GetOnControllerColliderHitAsyncHandler()
		{
			return new AsyncTriggerHandler<ControllerColliderHit>(this, callOnce: false);
		}

		public IAsyncOnControllerColliderHitHandler GetOnControllerColliderHitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<ControllerColliderHit>(this, cancellationToken, callOnce: false);
		}

		public UniTask<ControllerColliderHit> OnControllerColliderHitAsync()
		{
			return ((IAsyncOnControllerColliderHitHandler)new AsyncTriggerHandler<ControllerColliderHit>(this, callOnce: true)).OnControllerColliderHitAsync();
		}

		public UniTask<ControllerColliderHit> OnControllerColliderHitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnControllerColliderHitHandler)new AsyncTriggerHandler<ControllerColliderHit>(this, cancellationToken, callOnce: true)).OnControllerColliderHitAsync();
		}
	}
	public interface IAsyncOnDisableHandler
	{
		UniTask OnDisableAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDisableTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnDisable()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnDisableHandler GetOnDisableAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnDisableHandler GetOnDisableAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnDisableAsync()
		{
			return ((IAsyncOnDisableHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnDisableAsync();
		}

		public UniTask OnDisableAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnDisableHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnDisableAsync();
		}
	}
	public interface IAsyncOnDrawGizmosHandler
	{
		UniTask OnDrawGizmosAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDrawGizmosTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnDrawGizmos()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnDrawGizmosHandler GetOnDrawGizmosAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnDrawGizmosHandler GetOnDrawGizmosAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnDrawGizmosAsync()
		{
			return ((IAsyncOnDrawGizmosHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnDrawGizmosAsync();
		}

		public UniTask OnDrawGizmosAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnDrawGizmosHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnDrawGizmosAsync();
		}
	}
	public interface IAsyncOnDrawGizmosSelectedHandler
	{
		UniTask OnDrawGizmosSelectedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDrawGizmosSelectedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnDrawGizmosSelected()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnDrawGizmosSelectedHandler GetOnDrawGizmosSelectedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnDrawGizmosSelectedHandler GetOnDrawGizmosSelectedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnDrawGizmosSelectedAsync()
		{
			return ((IAsyncOnDrawGizmosSelectedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnDrawGizmosSelectedAsync();
		}

		public UniTask OnDrawGizmosSelectedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnDrawGizmosSelectedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnDrawGizmosSelectedAsync();
		}
	}
	public interface IAsyncOnEnableHandler
	{
		UniTask OnEnableAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncEnableTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnEnable()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnEnableHandler GetOnEnableAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnEnableHandler GetOnEnableAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnEnableAsync()
		{
			return ((IAsyncOnEnableHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnEnableAsync();
		}

		public UniTask OnEnableAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnEnableHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnEnableAsync();
		}
	}
	public interface IAsyncOnGUIHandler
	{
		UniTask OnGUIAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncGUITrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnGUI()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnGUIHandler GetOnGUIAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnGUIHandler GetOnGUIAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnGUIAsync()
		{
			return ((IAsyncOnGUIHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnGUIAsync();
		}

		public UniTask OnGUIAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnGUIHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnGUIAsync();
		}
	}
	public interface IAsyncOnJointBreakHandler
	{
		UniTask<float> OnJointBreakAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncJointBreakTrigger : AsyncTriggerBase<float>
	{
		private void OnJointBreak(float breakForce)
		{
			RaiseEvent(breakForce);
		}

		public IAsyncOnJointBreakHandler GetOnJointBreakAsyncHandler()
		{
			return new AsyncTriggerHandler<float>(this, callOnce: false);
		}

		public IAsyncOnJointBreakHandler GetOnJointBreakAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<float>(this, cancellationToken, callOnce: false);
		}

		public UniTask<float> OnJointBreakAsync()
		{
			return ((IAsyncOnJointBreakHandler)new AsyncTriggerHandler<float>(this, callOnce: true)).OnJointBreakAsync();
		}

		public UniTask<float> OnJointBreakAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnJointBreakHandler)new AsyncTriggerHandler<float>(this, cancellationToken, callOnce: true)).OnJointBreakAsync();
		}
	}
	public interface IAsyncOnJointBreak2DHandler
	{
		UniTask<Joint2D> OnJointBreak2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncJointBreak2DTrigger : AsyncTriggerBase<Joint2D>
	{
		private void OnJointBreak2D(Joint2D brokenJoint)
		{
			RaiseEvent(brokenJoint);
		}

		public IAsyncOnJointBreak2DHandler GetOnJointBreak2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Joint2D>(this, callOnce: false);
		}

		public IAsyncOnJointBreak2DHandler GetOnJointBreak2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Joint2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Joint2D> OnJointBreak2DAsync()
		{
			return ((IAsyncOnJointBreak2DHandler)new AsyncTriggerHandler<Joint2D>(this, callOnce: true)).OnJointBreak2DAsync();
		}

		public UniTask<Joint2D> OnJointBreak2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnJointBreak2DHandler)new AsyncTriggerHandler<Joint2D>(this, cancellationToken, callOnce: true)).OnJointBreak2DAsync();
		}
	}
	public interface IAsyncOnMouseDownHandler
	{
		UniTask OnMouseDownAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseDownTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseDown()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseDownHandler GetOnMouseDownAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseDownHandler GetOnMouseDownAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseDownAsync()
		{
			return ((IAsyncOnMouseDownHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseDownAsync();
		}

		public UniTask OnMouseDownAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseDownHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseDownAsync();
		}
	}
	public interface IAsyncOnMouseDragHandler
	{
		UniTask OnMouseDragAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseDragTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseDrag()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseDragHandler GetOnMouseDragAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseDragHandler GetOnMouseDragAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseDragAsync()
		{
			return ((IAsyncOnMouseDragHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseDragAsync();
		}

		public UniTask OnMouseDragAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseDragHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseDragAsync();
		}
	}
	public interface IAsyncOnMouseEnterHandler
	{
		UniTask OnMouseEnterAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseEnterTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseEnter()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseEnterHandler GetOnMouseEnterAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseEnterHandler GetOnMouseEnterAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseEnterAsync()
		{
			return ((IAsyncOnMouseEnterHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseEnterAsync();
		}

		public UniTask OnMouseEnterAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseEnterHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseEnterAsync();
		}
	}
	public interface IAsyncOnMouseExitHandler
	{
		UniTask OnMouseExitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseExitTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseExit()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseExitHandler GetOnMouseExitAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseExitHandler GetOnMouseExitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseExitAsync()
		{
			return ((IAsyncOnMouseExitHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseExitAsync();
		}

		public UniTask OnMouseExitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseExitHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseExitAsync();
		}
	}
	public interface IAsyncOnMouseOverHandler
	{
		UniTask OnMouseOverAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseOverTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseOver()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseOverHandler GetOnMouseOverAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseOverHandler GetOnMouseOverAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseOverAsync()
		{
			return ((IAsyncOnMouseOverHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseOverAsync();
		}

		public UniTask OnMouseOverAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseOverHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseOverAsync();
		}
	}
	public interface IAsyncOnMouseUpHandler
	{
		UniTask OnMouseUpAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseUpTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseUp()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseUpHandler GetOnMouseUpAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseUpHandler GetOnMouseUpAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseUpAsync()
		{
			return ((IAsyncOnMouseUpHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseUpAsync();
		}

		public UniTask OnMouseUpAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseUpHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseUpAsync();
		}
	}
	public interface IAsyncOnMouseUpAsButtonHandler
	{
		UniTask OnMouseUpAsButtonAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMouseUpAsButtonTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnMouseUpAsButton()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnMouseUpAsButtonHandler GetOnMouseUpAsButtonAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnMouseUpAsButtonHandler GetOnMouseUpAsButtonAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnMouseUpAsButtonAsync()
		{
			return ((IAsyncOnMouseUpAsButtonHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnMouseUpAsButtonAsync();
		}

		public UniTask OnMouseUpAsButtonAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMouseUpAsButtonHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnMouseUpAsButtonAsync();
		}
	}
	public interface IAsyncOnParticleCollisionHandler
	{
		UniTask<GameObject> OnParticleCollisionAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncParticleCollisionTrigger : AsyncTriggerBase<GameObject>
	{
		private void OnParticleCollision(GameObject other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnParticleCollisionHandler GetOnParticleCollisionAsyncHandler()
		{
			return new AsyncTriggerHandler<GameObject>(this, callOnce: false);
		}

		public IAsyncOnParticleCollisionHandler GetOnParticleCollisionAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<GameObject>(this, cancellationToken, callOnce: false);
		}

		public UniTask<GameObject> OnParticleCollisionAsync()
		{
			return ((IAsyncOnParticleCollisionHandler)new AsyncTriggerHandler<GameObject>(this, callOnce: true)).OnParticleCollisionAsync();
		}

		public UniTask<GameObject> OnParticleCollisionAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnParticleCollisionHandler)new AsyncTriggerHandler<GameObject>(this, cancellationToken, callOnce: true)).OnParticleCollisionAsync();
		}
	}
	public interface IAsyncOnParticleSystemStoppedHandler
	{
		UniTask OnParticleSystemStoppedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncParticleSystemStoppedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnParticleSystemStopped()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnParticleSystemStoppedHandler GetOnParticleSystemStoppedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnParticleSystemStoppedHandler GetOnParticleSystemStoppedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnParticleSystemStoppedAsync()
		{
			return ((IAsyncOnParticleSystemStoppedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnParticleSystemStoppedAsync();
		}

		public UniTask OnParticleSystemStoppedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnParticleSystemStoppedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnParticleSystemStoppedAsync();
		}
	}
	public interface IAsyncOnParticleTriggerHandler
	{
		UniTask OnParticleTriggerAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncParticleTriggerTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnParticleTrigger()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnParticleTriggerHandler GetOnParticleTriggerAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnParticleTriggerHandler GetOnParticleTriggerAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnParticleTriggerAsync()
		{
			return ((IAsyncOnParticleTriggerHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnParticleTriggerAsync();
		}

		public UniTask OnParticleTriggerAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnParticleTriggerHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnParticleTriggerAsync();
		}
	}
	public interface IAsyncOnParticleUpdateJobScheduledHandler
	{
		UniTask<ParticleSystemJobData> OnParticleUpdateJobScheduledAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncParticleUpdateJobScheduledTrigger : AsyncTriggerBase<ParticleSystemJobData>
	{
		private void OnParticleUpdateJobScheduled(ParticleSystemJobData particles)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			RaiseEvent(particles);
		}

		public IAsyncOnParticleUpdateJobScheduledHandler GetOnParticleUpdateJobScheduledAsyncHandler()
		{
			return new AsyncTriggerHandler<ParticleSystemJobData>(this, callOnce: false);
		}

		public IAsyncOnParticleUpdateJobScheduledHandler GetOnParticleUpdateJobScheduledAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<ParticleSystemJobData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<ParticleSystemJobData> OnParticleUpdateJobScheduledAsync()
		{
			return ((IAsyncOnParticleUpdateJobScheduledHandler)new AsyncTriggerHandler<ParticleSystemJobData>(this, callOnce: true)).OnParticleUpdateJobScheduledAsync();
		}

		public UniTask<ParticleSystemJobData> OnParticleUpdateJobScheduledAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnParticleUpdateJobScheduledHandler)new AsyncTriggerHandler<ParticleSystemJobData>(this, cancellationToken, callOnce: true)).OnParticleUpdateJobScheduledAsync();
		}
	}
	public interface IAsyncOnPostRenderHandler
	{
		UniTask OnPostRenderAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPostRenderTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnPostRender()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnPostRenderHandler GetOnPostRenderAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnPostRenderHandler GetOnPostRenderAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnPostRenderAsync()
		{
			return ((IAsyncOnPostRenderHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnPostRenderAsync();
		}

		public UniTask OnPostRenderAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPostRenderHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnPostRenderAsync();
		}
	}
	public interface IAsyncOnPreCullHandler
	{
		UniTask OnPreCullAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPreCullTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnPreCull()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnPreCullHandler GetOnPreCullAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnPreCullHandler GetOnPreCullAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnPreCullAsync()
		{
			return ((IAsyncOnPreCullHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnPreCullAsync();
		}

		public UniTask OnPreCullAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPreCullHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnPreCullAsync();
		}
	}
	public interface IAsyncOnPreRenderHandler
	{
		UniTask OnPreRenderAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPreRenderTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnPreRender()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnPreRenderHandler GetOnPreRenderAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnPreRenderHandler GetOnPreRenderAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnPreRenderAsync()
		{
			return ((IAsyncOnPreRenderHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnPreRenderAsync();
		}

		public UniTask OnPreRenderAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPreRenderHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnPreRenderAsync();
		}
	}
	public interface IAsyncOnRectTransformDimensionsChangeHandler
	{
		UniTask OnRectTransformDimensionsChangeAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncRectTransformDimensionsChangeTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnRectTransformDimensionsChange()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnRectTransformDimensionsChangeHandler GetOnRectTransformDimensionsChangeAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnRectTransformDimensionsChangeHandler GetOnRectTransformDimensionsChangeAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnRectTransformDimensionsChangeAsync()
		{
			return ((IAsyncOnRectTransformDimensionsChangeHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnRectTransformDimensionsChangeAsync();
		}

		public UniTask OnRectTransformDimensionsChangeAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnRectTransformDimensionsChangeHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnRectTransformDimensionsChangeAsync();
		}
	}
	public interface IAsyncOnRectTransformRemovedHandler
	{
		UniTask OnRectTransformRemovedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncRectTransformRemovedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnRectTransformRemoved()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnRectTransformRemovedHandler GetOnRectTransformRemovedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnRectTransformRemovedHandler GetOnRectTransformRemovedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnRectTransformRemovedAsync()
		{
			return ((IAsyncOnRectTransformRemovedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnRectTransformRemovedAsync();
		}

		public UniTask OnRectTransformRemovedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnRectTransformRemovedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnRectTransformRemovedAsync();
		}
	}
	public interface IAsyncOnRenderImageHandler
	{
		UniTask<(RenderTexture source, RenderTexture destination)> OnRenderImageAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncRenderImageTrigger : AsyncTriggerBase<(RenderTexture source, RenderTexture destination)>
	{
		private void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			RaiseEvent((source, destination));
		}

		public IAsyncOnRenderImageHandler GetOnRenderImageAsyncHandler()
		{
			return new AsyncTriggerHandler<(RenderTexture, RenderTexture)>(this, callOnce: false);
		}

		public IAsyncOnRenderImageHandler GetOnRenderImageAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<(RenderTexture, RenderTexture)>(this, cancellationToken, callOnce: false);
		}

		public UniTask<(RenderTexture source, RenderTexture destination)> OnRenderImageAsync()
		{
			return ((IAsyncOnRenderImageHandler)new AsyncTriggerHandler<(RenderTexture, RenderTexture)>(this, callOnce: true)).OnRenderImageAsync();
		}

		public UniTask<(RenderTexture source, RenderTexture destination)> OnRenderImageAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnRenderImageHandler)new AsyncTriggerHandler<(RenderTexture, RenderTexture)>(this, cancellationToken, callOnce: true)).OnRenderImageAsync();
		}
	}
	public interface IAsyncOnRenderObjectHandler
	{
		UniTask OnRenderObjectAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncRenderObjectTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnRenderObject()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnRenderObjectHandler GetOnRenderObjectAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnRenderObjectHandler GetOnRenderObjectAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnRenderObjectAsync()
		{
			return ((IAsyncOnRenderObjectHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnRenderObjectAsync();
		}

		public UniTask OnRenderObjectAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnRenderObjectHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnRenderObjectAsync();
		}
	}
	public interface IAsyncOnServerInitializedHandler
	{
		UniTask OnServerInitializedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncServerInitializedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnServerInitialized()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnServerInitializedHandler GetOnServerInitializedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnServerInitializedHandler GetOnServerInitializedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnServerInitializedAsync()
		{
			return ((IAsyncOnServerInitializedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnServerInitializedAsync();
		}

		public UniTask OnServerInitializedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnServerInitializedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnServerInitializedAsync();
		}
	}
	public interface IAsyncOnTransformChildrenChangedHandler
	{
		UniTask OnTransformChildrenChangedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTransformChildrenChangedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnTransformChildrenChanged()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnTransformChildrenChangedHandler GetOnTransformChildrenChangedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnTransformChildrenChangedHandler GetOnTransformChildrenChangedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnTransformChildrenChangedAsync()
		{
			return ((IAsyncOnTransformChildrenChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnTransformChildrenChangedAsync();
		}

		public UniTask OnTransformChildrenChangedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTransformChildrenChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnTransformChildrenChangedAsync();
		}
	}
	public interface IAsyncOnTransformParentChangedHandler
	{
		UniTask OnTransformParentChangedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTransformParentChangedTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnTransformParentChanged()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnTransformParentChangedHandler GetOnTransformParentChangedAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnTransformParentChangedHandler GetOnTransformParentChangedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnTransformParentChangedAsync()
		{
			return ((IAsyncOnTransformParentChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnTransformParentChangedAsync();
		}

		public UniTask OnTransformParentChangedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTransformParentChangedHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnTransformParentChangedAsync();
		}
	}
	public interface IAsyncOnTriggerEnterHandler
	{
		UniTask<Collider> OnTriggerEnterAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTriggerEnterTrigger : AsyncTriggerBase<Collider>
	{
		private void OnTriggerEnter(Collider other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnTriggerEnterHandler GetOnTriggerEnterAsyncHandler()
		{
			return new AsyncTriggerHandler<Collider>(this, callOnce: false);
		}

		public IAsyncOnTriggerEnterHandler GetOnTriggerEnterAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collider>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collider> OnTriggerEnterAsync()
		{
			return ((IAsyncOnTriggerEnterHandler)new AsyncTriggerHandler<Collider>(this, callOnce: true)).OnTriggerEnterAsync();
		}

		public UniTask<Collider> OnTriggerEnterAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTriggerEnterHandler)new AsyncTriggerHandler<Collider>(this, cancellationToken, callOnce: true)).OnTriggerEnterAsync();
		}
	}
	public interface IAsyncOnTriggerEnter2DHandler
	{
		UniTask<Collider2D> OnTriggerEnter2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTriggerEnter2DTrigger : AsyncTriggerBase<Collider2D>
	{
		private void OnTriggerEnter2D(Collider2D other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnTriggerEnter2DHandler GetOnTriggerEnter2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Collider2D>(this, callOnce: false);
		}

		public IAsyncOnTriggerEnter2DHandler GetOnTriggerEnter2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collider2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collider2D> OnTriggerEnter2DAsync()
		{
			return ((IAsyncOnTriggerEnter2DHandler)new AsyncTriggerHandler<Collider2D>(this, callOnce: true)).OnTriggerEnter2DAsync();
		}

		public UniTask<Collider2D> OnTriggerEnter2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTriggerEnter2DHandler)new AsyncTriggerHandler<Collider2D>(this, cancellationToken, callOnce: true)).OnTriggerEnter2DAsync();
		}
	}
	public interface IAsyncOnTriggerExitHandler
	{
		UniTask<Collider> OnTriggerExitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTriggerExitTrigger : AsyncTriggerBase<Collider>
	{
		private void OnTriggerExit(Collider other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnTriggerExitHandler GetOnTriggerExitAsyncHandler()
		{
			return new AsyncTriggerHandler<Collider>(this, callOnce: false);
		}

		public IAsyncOnTriggerExitHandler GetOnTriggerExitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collider>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collider> OnTriggerExitAsync()
		{
			return ((IAsyncOnTriggerExitHandler)new AsyncTriggerHandler<Collider>(this, callOnce: true)).OnTriggerExitAsync();
		}

		public UniTask<Collider> OnTriggerExitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTriggerExitHandler)new AsyncTriggerHandler<Collider>(this, cancellationToken, callOnce: true)).OnTriggerExitAsync();
		}
	}
	public interface IAsyncOnTriggerExit2DHandler
	{
		UniTask<Collider2D> OnTriggerExit2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTriggerExit2DTrigger : AsyncTriggerBase<Collider2D>
	{
		private void OnTriggerExit2D(Collider2D other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnTriggerExit2DHandler GetOnTriggerExit2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Collider2D>(this, callOnce: false);
		}

		public IAsyncOnTriggerExit2DHandler GetOnTriggerExit2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collider2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collider2D> OnTriggerExit2DAsync()
		{
			return ((IAsyncOnTriggerExit2DHandler)new AsyncTriggerHandler<Collider2D>(this, callOnce: true)).OnTriggerExit2DAsync();
		}

		public UniTask<Collider2D> OnTriggerExit2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTriggerExit2DHandler)new AsyncTriggerHandler<Collider2D>(this, cancellationToken, callOnce: true)).OnTriggerExit2DAsync();
		}
	}
	public interface IAsyncOnTriggerStayHandler
	{
		UniTask<Collider> OnTriggerStayAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTriggerStayTrigger : AsyncTriggerBase<Collider>
	{
		private void OnTriggerStay(Collider other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnTriggerStayHandler GetOnTriggerStayAsyncHandler()
		{
			return new AsyncTriggerHandler<Collider>(this, callOnce: false);
		}

		public IAsyncOnTriggerStayHandler GetOnTriggerStayAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collider>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collider> OnTriggerStayAsync()
		{
			return ((IAsyncOnTriggerStayHandler)new AsyncTriggerHandler<Collider>(this, callOnce: true)).OnTriggerStayAsync();
		}

		public UniTask<Collider> OnTriggerStayAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTriggerStayHandler)new AsyncTriggerHandler<Collider>(this, cancellationToken, callOnce: true)).OnTriggerStayAsync();
		}
	}
	public interface IAsyncOnTriggerStay2DHandler
	{
		UniTask<Collider2D> OnTriggerStay2DAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncTriggerStay2DTrigger : AsyncTriggerBase<Collider2D>
	{
		private void OnTriggerStay2D(Collider2D other)
		{
			RaiseEvent(other);
		}

		public IAsyncOnTriggerStay2DHandler GetOnTriggerStay2DAsyncHandler()
		{
			return new AsyncTriggerHandler<Collider2D>(this, callOnce: false);
		}

		public IAsyncOnTriggerStay2DHandler GetOnTriggerStay2DAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<Collider2D>(this, cancellationToken, callOnce: false);
		}

		public UniTask<Collider2D> OnTriggerStay2DAsync()
		{
			return ((IAsyncOnTriggerStay2DHandler)new AsyncTriggerHandler<Collider2D>(this, callOnce: true)).OnTriggerStay2DAsync();
		}

		public UniTask<Collider2D> OnTriggerStay2DAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnTriggerStay2DHandler)new AsyncTriggerHandler<Collider2D>(this, cancellationToken, callOnce: true)).OnTriggerStay2DAsync();
		}
	}
	public interface IAsyncOnValidateHandler
	{
		UniTask OnValidateAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncValidateTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnValidate()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnValidateHandler GetOnValidateAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnValidateHandler GetOnValidateAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnValidateAsync()
		{
			return ((IAsyncOnValidateHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnValidateAsync();
		}

		public UniTask OnValidateAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnValidateHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnValidateAsync();
		}
	}
	public interface IAsyncOnWillRenderObjectHandler
	{
		UniTask OnWillRenderObjectAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncWillRenderObjectTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void OnWillRenderObject()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncOnWillRenderObjectHandler GetOnWillRenderObjectAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncOnWillRenderObjectHandler GetOnWillRenderObjectAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask OnWillRenderObjectAsync()
		{
			return ((IAsyncOnWillRenderObjectHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).OnWillRenderObjectAsync();
		}

		public UniTask OnWillRenderObjectAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnWillRenderObjectHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).OnWillRenderObjectAsync();
		}
	}
	public interface IAsyncResetHandler
	{
		UniTask ResetAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncResetTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void Reset()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncResetHandler GetResetAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncResetHandler GetResetAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask ResetAsync()
		{
			return ((IAsyncResetHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).ResetAsync();
		}

		public UniTask ResetAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncResetHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).ResetAsync();
		}
	}
	public interface IAsyncUpdateHandler
	{
		UniTask UpdateAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncUpdateTrigger : AsyncTriggerBase<AsyncUnit>
	{
		private void Update()
		{
			RaiseEvent(AsyncUnit.Default);
		}

		public IAsyncUpdateHandler GetUpdateAsyncHandler()
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, callOnce: false);
		}

		public IAsyncUpdateHandler GetUpdateAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: false);
		}

		public UniTask UpdateAsync()
		{
			return ((IAsyncUpdateHandler)new AsyncTriggerHandler<AsyncUnit>(this, callOnce: true)).UpdateAsync();
		}

		public UniTask UpdateAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncUpdateHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, callOnce: true)).UpdateAsync();
		}
	}
	public interface IAsyncOnBeginDragHandler
	{
		UniTask<PointerEventData> OnBeginDragAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncBeginDragTrigger : AsyncTriggerBase<PointerEventData>, IBeginDragHandler, IEventSystemHandler
	{
		void IBeginDragHandler.OnBeginDrag(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnBeginDragHandler GetOnBeginDragAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnBeginDragHandler GetOnBeginDragAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnBeginDragAsync()
		{
			return ((IAsyncOnBeginDragHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnBeginDragAsync();
		}

		public UniTask<PointerEventData> OnBeginDragAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnBeginDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnBeginDragAsync();
		}
	}
	public interface IAsyncOnCancelHandler
	{
		UniTask<BaseEventData> OnCancelAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncCancelTrigger : AsyncTriggerBase<BaseEventData>, ICancelHandler, IEventSystemHandler
	{
		void ICancelHandler.OnCancel(BaseEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnCancelHandler GetOnCancelAsyncHandler()
		{
			return new AsyncTriggerHandler<BaseEventData>(this, callOnce: false);
		}

		public IAsyncOnCancelHandler GetOnCancelAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<BaseEventData> OnCancelAsync()
		{
			return ((IAsyncOnCancelHandler)new AsyncTriggerHandler<BaseEventData>(this, callOnce: true)).OnCancelAsync();
		}

		public UniTask<BaseEventData> OnCancelAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnCancelHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: true)).OnCancelAsync();
		}
	}
	public interface IAsyncOnDeselectHandler
	{
		UniTask<BaseEventData> OnDeselectAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDeselectTrigger : AsyncTriggerBase<BaseEventData>, IDeselectHandler, IEventSystemHandler
	{
		void IDeselectHandler.OnDeselect(BaseEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnDeselectHandler GetOnDeselectAsyncHandler()
		{
			return new AsyncTriggerHandler<BaseEventData>(this, callOnce: false);
		}

		public IAsyncOnDeselectHandler GetOnDeselectAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<BaseEventData> OnDeselectAsync()
		{
			return ((IAsyncOnDeselectHandler)new AsyncTriggerHandler<BaseEventData>(this, callOnce: true)).OnDeselectAsync();
		}

		public UniTask<BaseEventData> OnDeselectAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnDeselectHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: true)).OnDeselectAsync();
		}
	}
	public interface IAsyncOnDragHandler
	{
		UniTask<PointerEventData> OnDragAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDragTrigger : AsyncTriggerBase<PointerEventData>, IDragHandler, IEventSystemHandler
	{
		void IDragHandler.OnDrag(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnDragHandler GetOnDragAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnDragHandler GetOnDragAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnDragAsync()
		{
			return ((IAsyncOnDragHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnDragAsync();
		}

		public UniTask<PointerEventData> OnDragAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnDragAsync();
		}
	}
	public interface IAsyncOnDropHandler
	{
		UniTask<PointerEventData> OnDropAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncDropTrigger : AsyncTriggerBase<PointerEventData>, IDropHandler, IEventSystemHandler
	{
		void IDropHandler.OnDrop(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnDropHandler GetOnDropAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnDropHandler GetOnDropAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnDropAsync()
		{
			return ((IAsyncOnDropHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnDropAsync();
		}

		public UniTask<PointerEventData> OnDropAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnDropHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnDropAsync();
		}
	}
	public interface IAsyncOnEndDragHandler
	{
		UniTask<PointerEventData> OnEndDragAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncEndDragTrigger : AsyncTriggerBase<PointerEventData>, IEndDragHandler, IEventSystemHandler
	{
		void IEndDragHandler.OnEndDrag(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnEndDragHandler GetOnEndDragAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnEndDragHandler GetOnEndDragAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnEndDragAsync()
		{
			return ((IAsyncOnEndDragHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnEndDragAsync();
		}

		public UniTask<PointerEventData> OnEndDragAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnEndDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnEndDragAsync();
		}
	}
	public interface IAsyncOnInitializePotentialDragHandler
	{
		UniTask<PointerEventData> OnInitializePotentialDragAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncInitializePotentialDragTrigger : AsyncTriggerBase<PointerEventData>, IInitializePotentialDragHandler, IEventSystemHandler
	{
		void IInitializePotentialDragHandler.OnInitializePotentialDrag(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnInitializePotentialDragHandler GetOnInitializePotentialDragAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnInitializePotentialDragHandler GetOnInitializePotentialDragAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnInitializePotentialDragAsync()
		{
			return ((IAsyncOnInitializePotentialDragHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnInitializePotentialDragAsync();
		}

		public UniTask<PointerEventData> OnInitializePotentialDragAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnInitializePotentialDragHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnInitializePotentialDragAsync();
		}
	}
	public interface IAsyncOnMoveHandler
	{
		UniTask<AxisEventData> OnMoveAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncMoveTrigger : AsyncTriggerBase<AxisEventData>, IMoveHandler, IEventSystemHandler
	{
		void IMoveHandler.OnMove(AxisEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnMoveHandler GetOnMoveAsyncHandler()
		{
			return new AsyncTriggerHandler<AxisEventData>(this, callOnce: false);
		}

		public IAsyncOnMoveHandler GetOnMoveAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<AxisEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<AxisEventData> OnMoveAsync()
		{
			return ((IAsyncOnMoveHandler)new AsyncTriggerHandler<AxisEventData>(this, callOnce: true)).OnMoveAsync();
		}

		public UniTask<AxisEventData> OnMoveAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnMoveHandler)new AsyncTriggerHandler<AxisEventData>(this, cancellationToken, callOnce: true)).OnMoveAsync();
		}
	}
	public interface IAsyncOnPointerClickHandler
	{
		UniTask<PointerEventData> OnPointerClickAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPointerClickTrigger : AsyncTriggerBase<PointerEventData>, IPointerClickHandler, IEventSystemHandler
	{
		void IPointerClickHandler.OnPointerClick(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnPointerClickHandler GetOnPointerClickAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnPointerClickHandler GetOnPointerClickAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnPointerClickAsync()
		{
			return ((IAsyncOnPointerClickHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnPointerClickAsync();
		}

		public UniTask<PointerEventData> OnPointerClickAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPointerClickHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnPointerClickAsync();
		}
	}
	public interface IAsyncOnPointerDownHandler
	{
		UniTask<PointerEventData> OnPointerDownAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPointerDownTrigger : AsyncTriggerBase<PointerEventData>, IPointerDownHandler, IEventSystemHandler
	{
		void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnPointerDownHandler GetOnPointerDownAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnPointerDownHandler GetOnPointerDownAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnPointerDownAsync()
		{
			return ((IAsyncOnPointerDownHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnPointerDownAsync();
		}

		public UniTask<PointerEventData> OnPointerDownAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPointerDownHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnPointerDownAsync();
		}
	}
	public interface IAsyncOnPointerEnterHandler
	{
		UniTask<PointerEventData> OnPointerEnterAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPointerEnterTrigger : AsyncTriggerBase<PointerEventData>, IPointerEnterHandler, IEventSystemHandler
	{
		void IPointerEnterHandler.OnPointerEnter(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnPointerEnterHandler GetOnPointerEnterAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnPointerEnterHandler GetOnPointerEnterAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnPointerEnterAsync()
		{
			return ((IAsyncOnPointerEnterHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnPointerEnterAsync();
		}

		public UniTask<PointerEventData> OnPointerEnterAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPointerEnterHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnPointerEnterAsync();
		}
	}
	public interface IAsyncOnPointerExitHandler
	{
		UniTask<PointerEventData> OnPointerExitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPointerExitTrigger : AsyncTriggerBase<PointerEventData>, IPointerExitHandler, IEventSystemHandler
	{
		void IPointerExitHandler.OnPointerExit(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnPointerExitHandler GetOnPointerExitAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnPointerExitHandler GetOnPointerExitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnPointerExitAsync()
		{
			return ((IAsyncOnPointerExitHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnPointerExitAsync();
		}

		public UniTask<PointerEventData> OnPointerExitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPointerExitHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnPointerExitAsync();
		}
	}
	public interface IAsyncOnPointerUpHandler
	{
		UniTask<PointerEventData> OnPointerUpAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncPointerUpTrigger : AsyncTriggerBase<PointerEventData>, IPointerUpHandler, IEventSystemHandler
	{
		void IPointerUpHandler.OnPointerUp(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnPointerUpHandler GetOnPointerUpAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnPointerUpHandler GetOnPointerUpAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnPointerUpAsync()
		{
			return ((IAsyncOnPointerUpHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnPointerUpAsync();
		}

		public UniTask<PointerEventData> OnPointerUpAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnPointerUpHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnPointerUpAsync();
		}
	}
	public interface IAsyncOnScrollHandler
	{
		UniTask<PointerEventData> OnScrollAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncScrollTrigger : AsyncTriggerBase<PointerEventData>, IScrollHandler, IEventSystemHandler
	{
		void IScrollHandler.OnScroll(PointerEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnScrollHandler GetOnScrollAsyncHandler()
		{
			return new AsyncTriggerHandler<PointerEventData>(this, callOnce: false);
		}

		public IAsyncOnScrollHandler GetOnScrollAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<PointerEventData> OnScrollAsync()
		{
			return ((IAsyncOnScrollHandler)new AsyncTriggerHandler<PointerEventData>(this, callOnce: true)).OnScrollAsync();
		}

		public UniTask<PointerEventData> OnScrollAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnScrollHandler)new AsyncTriggerHandler<PointerEventData>(this, cancellationToken, callOnce: true)).OnScrollAsync();
		}
	}
	public interface IAsyncOnSelectHandler
	{
		UniTask<BaseEventData> OnSelectAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncSelectTrigger : AsyncTriggerBase<BaseEventData>, ISelectHandler, IEventSystemHandler
	{
		void ISelectHandler.OnSelect(BaseEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnSelectHandler GetOnSelectAsyncHandler()
		{
			return new AsyncTriggerHandler<BaseEventData>(this, callOnce: false);
		}

		public IAsyncOnSelectHandler GetOnSelectAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<BaseEventData> OnSelectAsync()
		{
			return ((IAsyncOnSelectHandler)new AsyncTriggerHandler<BaseEventData>(this, callOnce: true)).OnSelectAsync();
		}

		public UniTask<BaseEventData> OnSelectAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnSelectHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: true)).OnSelectAsync();
		}
	}
	public interface IAsyncOnSubmitHandler
	{
		UniTask<BaseEventData> OnSubmitAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncSubmitTrigger : AsyncTriggerBase<BaseEventData>, ISubmitHandler, IEventSystemHandler
	{
		void ISubmitHandler.OnSubmit(BaseEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnSubmitHandler GetOnSubmitAsyncHandler()
		{
			return new AsyncTriggerHandler<BaseEventData>(this, callOnce: false);
		}

		public IAsyncOnSubmitHandler GetOnSubmitAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<BaseEventData> OnSubmitAsync()
		{
			return ((IAsyncOnSubmitHandler)new AsyncTriggerHandler<BaseEventData>(this, callOnce: true)).OnSubmitAsync();
		}

		public UniTask<BaseEventData> OnSubmitAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnSubmitHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: true)).OnSubmitAsync();
		}
	}
	public interface IAsyncOnUpdateSelectedHandler
	{
		UniTask<BaseEventData> OnUpdateSelectedAsync();
	}
	[DisallowMultipleComponent]
	public sealed class AsyncUpdateSelectedTrigger : AsyncTriggerBase<BaseEventData>, IUpdateSelectedHandler, IEventSystemHandler
	{
		void IUpdateSelectedHandler.OnUpdateSelected(BaseEventData eventData)
		{
			RaiseEvent(eventData);
		}

		public IAsyncOnUpdateSelectedHandler GetOnUpdateSelectedAsyncHandler()
		{
			return new AsyncTriggerHandler<BaseEventData>(this, callOnce: false);
		}

		public IAsyncOnUpdateSelectedHandler GetOnUpdateSelectedAsyncHandler(CancellationToken cancellationToken)
		{
			return new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: false);
		}

		public UniTask<BaseEventData> OnUpdateSelectedAsync()
		{
			return ((IAsyncOnUpdateSelectedHandler)new AsyncTriggerHandler<BaseEventData>(this, callOnce: true)).OnUpdateSelectedAsync();
		}

		public UniTask<BaseEventData> OnUpdateSelectedAsync(CancellationToken cancellationToken)
		{
			return ((IAsyncOnUpdateSelectedHandler)new AsyncTriggerHandler<BaseEventData>(this, cancellationToken, callOnce: true)).OnUpdateSelectedAsync();
		}
	}
}
namespace Cysharp.Threading.Tasks.Internal
{
	internal sealed class ArrayPool<T>
	{
		private const int DefaultMaxNumberOfArraysPerBucket = 50;

		private static readonly T[] EmptyArray = new T[0];

		public static readonly ArrayPool<T> Shared = new ArrayPool<T>();

		private readonly MinimumQueue<T[]>[] buckets;

		private readonly SpinLock[] locks;

		private ArrayPool()
		{
			buckets = new MinimumQueue<T[]>[18];
			locks = new SpinLock[18];
			for (int i = 0; i < buckets.Length; i++)
			{
				buckets[i] = new MinimumQueue<T[]>(4);
				locks[i] = new SpinLock(enableThreadOwnerTracking: false);
			}
		}

		public T[] Rent(int minimumLength)
		{
			if (minimumLength < 0)
			{
				throw new ArgumentOutOfRangeException("minimumLength");
			}
			if (minimumLength == 0)
			{
				return EmptyArray;
			}
			int num = CalculateSize(minimumLength);
			int queueIndex = GetQueueIndex(num);
			if (queueIndex != -1)
			{
				MinimumQueue<T[]> minimumQueue = buckets[queueIndex];
				bool lockTaken = false;
				try
				{
					locks[queueIndex].Enter(ref lockTaken);
					if (minimumQueue.Count != 0)
					{
						return minimumQueue.Dequeue();
					}
				}
				finally
				{
					if (lockTaken)
					{
						locks[queueIndex].Exit(useMemoryBarrier: false);
					}
				}
			}
			return new T[num];
		}

		public void Return(T[] array, bool clearArray = false)
		{
			if (array == null || array.Length == 0)
			{
				return;
			}
			int queueIndex = GetQueueIndex(array.Length);
			if (queueIndex == -1)
			{
				return;
			}
			if (clearArray)
			{
				Array.Clear(array, 0, array.Length);
			}
			MinimumQueue<T[]> minimumQueue = buckets[queueIndex];
			bool lockTaken = false;
			try
			{
				locks[queueIndex].Enter(ref lockTaken);
				if (minimumQueue.Count <= 50)
				{
					minimumQueue.Enqueue(array);
				}
			}
			finally
			{
				if (lockTaken)
				{
					locks[queueIndex].Exit(useMemoryBarrier: false);
				}
			}
		}

		private static int CalculateSize(int size)
		{
			size--;
			size |= size >> 1;
			size |= size >> 2;
			size |= size >> 4;
			size |= size >> 8;
			size |= size >> 16;
			size++;
			if (size < 8)
			{
				size = 8;
			}
			return size;
		}

		private static int GetQueueIndex(int size)
		{
			return size switch
			{
				8 => 0, 
				16 => 1, 
				32 => 2, 
				64 => 3, 
				128 => 4, 
				256 => 5, 
				512 => 6, 
				1024 => 7, 
				2048 => 8, 
				4096 => 9, 
				8192 => 10, 
				16384 => 11, 
				32768 => 12, 
				65536 => 13, 
				131072 => 14, 
				262144 => 15, 
				524288 => 16, 
				1048576 => 17, 
				_ => -1, 
			};
		}
	}
	internal static class ArrayPoolUtil
	{
		public struct RentArray<T> : IDisposable
		{
			public readonly T[] Array;

			public readonly int Length;

			private ArrayPool<T> pool;

			public RentArray(T[] array, int length, ArrayPool<T> pool)
			{
				Array = array;
				Length = length;
				this.pool = pool;
			}

			public void Dispose()
			{
				DisposeManually(!RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<T>());
			}

			public void DisposeManually(bool clearArray)
			{
				if (pool != null)
				{
					if (clearArray)
					{
						System.Array.Clear(Array, 0, Length);
					}
					pool.Return(Array);
					pool = null;
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EnsureCapacity<T>(ref T[] array, int index, ArrayPool<T> pool)
		{
			if (array.Length <= index)
			{
				EnsureCapacityCore(ref array, index, pool);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void EnsureCapacityCore<T>(ref T[] array, int index, ArrayPool<T> pool)
		{
			if (array.Length <= index)
			{
				int num = array.Length * 2;
				T[] array2 = pool.Rent((index < num) ? num : (index * 2));
				Array.Copy(array, 0, array2, 0, array.Length);
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<T>());
				array = array2;
			}
		}

		public static RentArray<T> Materialize<T>(IEnumerable<T> source)
		{
			if (source is T[] array)
			{
				return new RentArray<T>(array, array.Length, null);
			}
			int num = 32;
			if (source is ICollection<T> collection)
			{
				if (collection.Count == 0)
				{
					return new RentArray<T>(Array.Empty<T>(), 0, null);
				}
				num = collection.Count;
				ArrayPool<T> shared = ArrayPool<T>.Shared;
				T[] array2 = shared.Rent(num);
				collection.CopyTo(array2, 0);
				return new RentArray<T>(array2, collection.Count, shared);
			}
			if (source is IReadOnlyCollection<T> readOnlyCollection)
			{
				num = readOnlyCollection.Count;
			}
			if (num == 0)
			{
				return new RentArray<T>(Array.Empty<T>(), 0, null);
			}
			ArrayPool<T> shared2 = ArrayPool<T>.Shared;
			int num2 = 0;
			T[] array3 = shared2.Rent(num);
			foreach (T item in source)
			{
				EnsureCapacity(ref array3, num2, shared2);
				array3[num2++] = item;
			}
			return new RentArray<T>(array3, num2, shared2);
		}
	}
	internal static class ArrayUtil
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void EnsureCapacity<T>(ref T[] array, int index)
		{
			if (array.Length <= index)
			{
				EnsureCore(ref array, index);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void EnsureCore<T>(ref T[] array, int index)
		{
			int num = array.Length * 2;
			T[] array2 = new T[(index < num) ? num : (index * 2)];
			Array.Copy(array, 0, array2, 0, array.Length);
			array = array2;
		}

		public static (T[] array, int length) Materialize<T>(IEnumerable<T> source)
		{
			if (source is T[] array)
			{
				return (array, array.Length);
			}
			int num = 4;
			if (source is ICollection<T> collection)
			{
				num = collection.Count;
				T[] array2 = new T[num];
				collection.CopyTo(array2, 0);
				return (array2, num);
			}
			if (source is IReadOnlyCollection<T> readOnlyCollection)
			{
				num = readOnlyCollection.Count;
			}
			if (num == 0)
			{
				return (Array.Empty<T>(), 0);
			}
			int num2 = 0;
			T[] array3 = new T[num];
			foreach (T item in source)
			{
				EnsureCapacity(ref array3, num2);
				array3[num2++] = item;
			}
			return (array3, num2);
		}
	}
	internal sealed class ContinuationQueue
	{
		private const int MaxArrayLength = 2146435071;

		private const int InitialSize = 16;

		private readonly PlayerLoopTiming timing;

		private SpinLock gate = new SpinLock(enableThreadOwnerTracking: false);

		private bool dequing;

		private int actionListCount;

		private Action[] actionList = new Action[16];

		private int waitingListCount;

		private Action[] waitingList = new Action[16];

		public ContinuationQueue(PlayerLoopTiming timing)
		{
			this.timing = timing;
		}

		public void Enqueue(Action continuation)
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				if (dequing)
				{
					if (waitingList.Length == waitingListCount)
					{
						int num = waitingListCount * 2;
						if ((uint)num > 2146435071u)
						{
							num = 2146435071;
						}
						Action[] destinationArray = new Action[num];
						Array.Copy(waitingList, destinationArray, waitingListCount);
						waitingList = destinationArray;
					}
					waitingList[waitingListCount] = continuation;
					waitingListCount++;
					return;
				}
				if (actionList.Length == actionListCount)
				{
					int num2 = actionListCount * 2;
					if ((uint)num2 > 2146435071u)
					{
						num2 = 2146435071;
					}
					Action[] destinationArray2 = new Action[num2];
					Array.Copy(actionList, destinationArray2, actionListCount);
					actionList = destinationArray2;
				}
				actionList[actionListCount] = continuation;
				actionListCount++;
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}

		public int Clear()
		{
			int result = actionListCount + waitingListCount;
			actionListCount = 0;
			actionList = new Action[16];
			waitingListCount = 0;
			waitingList = new Action[16];
			return result;
		}

		public void Run()
		{
			switch (timing)
			{
			case PlayerLoopTiming.Initialization:
				Initialization();
				break;
			case PlayerLoopTiming.LastInitialization:
				LastInitialization();
				break;
			case PlayerLoopTiming.EarlyUpdate:
				EarlyUpdate();
				break;
			case PlayerLoopTiming.LastEarlyUpdate:
				LastEarlyUpdate();
				break;
			case PlayerLoopTiming.FixedUpdate:
				FixedUpdate();
				break;
			case PlayerLoopTiming.LastFixedUpdate:
				LastFixedUpdate();
				break;
			case PlayerLoopTiming.PreUpdate:
				PreUpdate();
				break;
			case PlayerLoopTiming.LastPreUpdate:
				LastPreUpdate();
				break;
			case PlayerLoopTiming.Update:
				Update();
				break;
			case PlayerLoopTiming.LastUpdate:
				LastUpdate();
				break;
			case PlayerLoopTiming.PreLateUpdate:
				PreLateUpdate();
				break;
			case PlayerLoopTiming.LastPreLateUpdate:
				LastPreLateUpdate();
				break;
			case PlayerLoopTiming.PostLateUpdate:
				PostLateUpdate();
				break;
			case PlayerLoopTiming.LastPostLateUpdate:
				LastPostLateUpdate();
				break;
			case PlayerLoopTiming.TimeUpdate:
				TimeUpdate();
				break;
			case PlayerLoopTiming.LastTimeUpdate:
				LastTimeUpdate();
				break;
			}
		}

		private void Initialization()
		{
			RunCore();
		}

		private void LastInitialization()
		{
			RunCore();
		}

		private void EarlyUpdate()
		{
			RunCore();
		}

		private void LastEarlyUpdate()
		{
			RunCore();
		}

		private void FixedUpdate()
		{
			RunCore();
		}

		private void LastFixedUpdate()
		{
			RunCore();
		}

		private void PreUpdate()
		{
			RunCore();
		}

		private void LastPreUpdate()
		{
			RunCore();
		}

		private void Update()
		{
			RunCore();
		}

		private void LastUpdate()
		{
			RunCore();
		}

		private void PreLateUpdate()
		{
			RunCore();
		}

		private void LastPreLateUpdate()
		{
			RunCore();
		}

		private void PostLateUpdate()
		{
			RunCore();
		}

		private void LastPostLateUpdate()
		{
			RunCore();
		}

		private void TimeUpdate()
		{
			RunCore();
		}

		private void LastTimeUpdate()
		{
			RunCore();
		}

		[DebuggerHidden]
		private void RunCore()
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				if (actionListCount == 0)
				{
					return;
				}
				dequing = true;
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
			for (int i = 0; i < actionListCount; i++)
			{
				Action action = actionList[i];
				actionList[i] = null;
				try
				{
					action();
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
			}
			bool lockTaken2 = false;
			try
			{
				gate.Enter(ref lockTaken2);
				dequing = false;
				Action[] array = actionList;
				actionListCount = waitingListCount;
				actionList = waitingList;
				waitingListCount = 0;
				waitingList = array;
			}
			finally
			{
				if (lockTaken2)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}
	}
	internal static class DiagnosticsExtensions
	{
		private static bool displayFilenames = true;

		private static readonly Regex typeBeautifyRegex = new Regex("`.+$", RegexOptions.Compiled);

		private static readonly Dictionary<Type, string> builtInTypeNames = new Dictionary<Type, string>
		{
			{
				typeof(void),
				"void"
			},
			{
				typeof(bool),
				"bool"
			},
			{
				typeof(byte),
				"byte"
			},
			{
				typeof(char),
				"char"
			},
			{
				typeof(decimal),
				"decimal"
			},
			{
				typeof(double),
				"double"
			},
			{
				typeof(float),
				"float"
			},
			{
				typeof(int),
				"int"
			},
			{
				typeof(long),
				"long"
			},
			{
				typeof(object),
				"object"
			},
			{
				typeof(sbyte),
				"sbyte"
			},
			{
				typeof(short),
				"short"
			},
			{
				typeof(string),
				"string"
			},
			{
				typeof(uint),
				"uint"
			},
			{
				typeof(ulong),
				"ulong"
			},
			{
				typeof(ushort),
				"ushort"
			},
			{
				typeof(Task),
				"Task"
			},
			{
				typeof(UniTask),
				"UniTask"
			},
			{
				typeof(UniTaskVoid),
				"UniTaskVoid"
			}
		};

		public static string CleanupAsyncStackTrace(this StackTrace stackTrace)
		{
			if (stackTrace == null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < stackTrace.FrameCount; i++)
			{
				StackFrame frame = stackTrace.GetFrame(i);
				MethodBase method = frame.GetMethod();
				if (IgnoreLine(method))
				{
					continue;
				}
				if (IsAsync(method))
				{
					stringBuilder.Append("async ");
					TryResolveStateMachineMethod(ref method, out var _);
				}
				if (method is MethodInfo methodInfo)
				{
					stringBuilder.Append(BeautifyType(methodInfo.ReturnType, shortName: false));
					stringBuilder.Append(" ");
				}
				stringBuilder.Append(BeautifyType(method.DeclaringType, shortName: false));
				if (!method.IsConstructor)
				{
					stringBuilder.Append(".");
				}
				stringBuilder.Append(method.Name);
				if (method.IsGenericMethod)
				{
					stringBuilder.Append("<");
					Type[] genericArguments = method.GetGenericArguments();
					foreach (Type t in genericArguments)
					{
						stringBuilder.Append(BeautifyType(t, shortName: true));
					}
					stringBuilder.Append(">");
				}
				stringBuilder.Append("(");
				stringBuilder.Append(string.Join(", ", from p in method.GetParameters()
					select BeautifyType(p.ParameterType, shortName: true) + " " + p.Name));
				stringBuilder.Append(")");
				if (displayFilenames && frame.GetILOffset() != -1)
				{
					string text = null;
					try
					{
						text = frame.GetFileName();
					}
					catch (NotSupportedException)
					{
						displayFilenames = false;
					}
					catch (SecurityException)
					{
						displayFilenames = false;
					}
					if (text != null)
					{
						stringBuilder.Append(' ');
						stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "(at {0})", AppendHyperLink(text, frame.GetFileLineNumber().ToString()));
					}
				}
				stringBuilder.AppendLine();
			}
			return stringBuilder.ToString();
		}

		private static bool IsAsync(MethodBase methodInfo)
		{
			Type declaringType = methodInfo.DeclaringType;
			return typeof(IAsyncStateMachine).IsAssignableFrom(declaringType);
		}

		private static bool TryResolveStateMachineMethod(ref MethodBase method, out Type declaringType)
		{
			declaringType = method.DeclaringType;
			Type declaringType2 = declaringType.DeclaringType;
			if (declaringType2 == null)
			{
				return false;
			}
			MethodInfo[] methods = declaringType2.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (methods == null)
			{
				return false;
			}
			MethodInfo[] array = methods;
			foreach (MethodInfo methodInfo in array)
			{
				IEnumerable<StateMachineAttribute> customAttributes = methodInfo.GetCustomAttributes<StateMachineAttribute>(inherit: false);
				if (customAttributes == null)
				{
					continue;
				}
				foreach (StateMachineAttribute item in customAttributes)
				{
					if (item.StateMachineType == declaringType)
					{
						method = methodInfo;
						declaringType = methodInfo.DeclaringType;
						return item is IteratorStateMachineAttribute;
					}
				}
			}
			return false;
		}

		private static string BeautifyType(Type t, bool shortName)
		{
			if (builtInTypeNames.TryGetValue(t, out var value))
			{
				return value;
			}
			if (t.IsGenericParameter)
			{
				return t.Name;
			}
			if (t.IsArray)
			{
				return BeautifyType(t.GetElementType(), shortName) + "[]";
			}
			string? fullName = t.FullName;
			if (fullName != null && fullName.StartsWith("System.ValueTuple"))
			{
				return "(" + string.Join(", ", from x in t.GetGenericArguments()
					select BeautifyType(x, shortName: true)) + ")";
			}
			if (!t.IsGenericType)
			{
				string text;
				if (!shortName)
				{
					text = t.FullName.Replace("Cysharp.Threading.Tasks.Triggers.", "").Replace("Cysharp.Threading.Tasks.Internal.", "").Replace("Cysharp.Threading.Tasks.", "");
					if (text == null)
					{
						return t.Name;
					}
				}
				else
				{
					text = t.Name;
				}
				return text;
			}
			string text2 = string.Join(", ", from x in t.GetGenericArguments()
				select BeautifyType(x, shortName: true));
			string text3 = t.GetGenericTypeDefinition().FullName;
			if (text3 == "System.Threading.Tasks.Task`1")
			{
				text3 = "Task";
			}
			return typeBeautifyRegex.Replace(text3, "").Replace("Cysharp.Threading.Tasks.Triggers.", "").Replace("Cysharp.Threading.Tasks.Internal.", "")
				.Replace("Cysharp.Threading.Tasks.", "") + "<" + text2 + ">";
		}

		private static bool IgnoreLine(MethodBase methodInfo)
		{
			string fullName = methodInfo.DeclaringType.FullName;
			if (fullName == "System.Threading.ExecutionContext")
			{
				return true;
			}
			if (fullName.StartsWith("System.Runtime.CompilerServices"))
			{
				return true;
			}
			if (fullName.StartsWith("Cysharp.Threading.Tasks.CompilerServices"))
			{
				return true;
			}
			if (fullName == "System.Threading.Tasks.AwaitTaskContinuation")
			{
				return true;
			}
			if (fullName.StartsWith("System.Threading.Tasks.Task"))
			{
				return true;
			}
			if (fullName.StartsWith("Cysharp.Threading.Tasks.UniTaskCompletionSourceCore"))
			{
				return true;
			}
			if (fullName.StartsWith("Cysharp.Threading.Tasks.AwaiterActions"))
			{
				return true;
			}
			return false;
		}

		private static string AppendHyperLink(string path, string line)
		{
			FileInfo fileInfo = new FileInfo(path);
			if (fileInfo.Directory == null)
			{
				return fileInfo.Name;
			}
			string text = fileInfo.FullName.Replace(Path.DirectorySeparatorChar, '/').Replace(PlayerLoopHelper.ApplicationDataPath, "");
			string text2 = "Assets/" + text;
			return "<a href=\"" + text2 + "\" line=\"" + line + "\">" + text2 + ":" + line + "</a>";
		}
	}
	internal static class Error
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ThrowArgumentNullException<T>(T value, string paramName) where T : class
		{
			if (value == null)
			{
				ThrowArgumentNullExceptionCore(paramName);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowArgumentNullExceptionCore(string paramName)
		{
			throw new ArgumentNullException(paramName);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Exception ArgumentOutOfRange(string paramName)
		{
			return new ArgumentOutOfRangeException(paramName);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Exception NoElements()
		{
			return new InvalidOperationException("Source sequence doesn't contain any elements.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Exception MoreThanOneElement()
		{
			return new InvalidOperationException("Source sequence contains more than one element.");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentException<T>(string message)
		{
			throw new ArgumentException(message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowNotYetCompleted()
		{
			throw new InvalidOperationException("Not yet completed.");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static T ThrowNotYetCompleted<T>()
		{
			throw new InvalidOperationException("Not yet completed.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ThrowWhenContinuationIsAlreadyRegistered<T>(T continuationField) where T : class
		{
			if (continuationField != null)
			{
				ThrowInvalidOperationExceptionCore("continuation is already registered.");
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowInvalidOperationExceptionCore(string message)
		{
			throw new InvalidOperationException(message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowOperationCanceledException()
		{
			throw new OperationCanceledException();
		}
	}
	internal class MinimumQueue<T>
	{
		private const int MinimumGrow = 4;

		private const int GrowFactor = 200;

		private T[] array;

		private int head;

		private int tail;

		private int size;

		public int Count
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return size;
			}
		}

		public MinimumQueue(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			array = new T[capacity];
			head = (tail = (size = 0));
		}

		public T Peek()
		{
			if (size == 0)
			{
				ThrowForEmptyQueue();
			}
			return array[head];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Enqueue(T item)
		{
			if (size == array.Length)
			{
				Grow();
			}
			array[tail] = item;
			MoveNext(ref tail);
			size++;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public T Dequeue()
		{
			if (size == 0)
			{
				ThrowForEmptyQueue();
			}
			int num = head;
			T[] obj = array;
			T result = obj[num];
			obj[num] = default(T);
			MoveNext(ref head);
			size--;
			return result;
		}

		private void Grow()
		{
			int num = (int)((long)array.Length * 200L / 100);
			if (num < array.Length + 4)
			{
				num = array.Length + 4;
			}
			SetCapacity(num);
		}

		private void SetCapacity(int capacity)
		{
			T[] destinationArray = new T[capacity];
			if (size > 0)
			{
				if (head < tail)
				{
					Array.Copy(array, head, destinationArray, 0, size);
				}
				else
				{
					Array.Copy(array, head, destinationArray, 0, array.Length - head);
					Array.Copy(array, 0, destinationArray, array.Length - head, tail);
				}
			}
			array = destinationArray;
			head = 0;
			tail = ((size != capacity) ? size : 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void MoveNext(ref int index)
		{
			int num = index + 1;
			if (num == array.Length)
			{
				num = 0;
			}
			index = num;
		}

		private void ThrowForEmptyQueue()
		{
			throw new InvalidOperationException("EmptyQueue");
		}
	}
	internal sealed class PlayerLoopRunner
	{
		private const int InitialSize = 16;

		private readonly PlayerLoopTiming timing;

		private readonly object runningAndQueueLock = new object();

		private readonly object arrayLock = new object();

		private readonly Action<Exception> unhandledExceptionCallback;

		private int tail;

		private bool running;

		private IPlayerLoopItem[] loopItems = new IPlayerLoopItem[16];

		private MinimumQueue<IPlayerLoopItem> waitQueue = new MinimumQueue<IPlayerLoopItem>(16);

		public PlayerLoopRunner(PlayerLoopTiming timing)
		{
			unhandledExceptionCallback = delegate(Exception ex)
			{
				Debug.LogException(ex);
			};
			this.timing = timing;
		}

		public void AddAction(IPlayerLoopItem item)
		{
			lock (runningAndQueueLock)
			{
				if (running)
				{
					waitQueue.Enqueue(item);
					return;
				}
			}
			lock (arrayLock)
			{
				if (loopItems.Length == tail)
				{
					Array.Resize(ref loopItems, checked(tail * 2));
				}
				loopItems[tail++] = item;
			}
		}

		public int Clear()
		{
			lock (arrayLock)
			{
				int num = 0;
				for (int i = 0; i < loopItems.Length; i++)
				{
					if (loopItems[i] != null)
					{
						num++;
					}
					loopItems[i] = null;
				}
				tail = 0;
				return num;
			}
		}

		public void Run()
		{
			switch (timing)
			{
			case PlayerLoopTiming.Initialization:
				Initialization();
				break;
			case PlayerLoopTiming.LastInitialization:
				LastInitialization();
				break;
			case PlayerLoopTiming.EarlyUpdate:
				EarlyUpdate();
				break;
			case PlayerLoopTiming.LastEarlyUpdate:
				LastEarlyUpdate();
				break;
			case PlayerLoopTiming.FixedUpdate:
				FixedUpdate();
				break;
			case PlayerLoopTiming.LastFixedUpdate:
				LastFixedUpdate();
				break;
			case PlayerLoopTiming.PreUpdate:
				PreUpdate();
				break;
			case PlayerLoopTiming.LastPreUpdate:
				LastPreUpdate();
				break;
			case PlayerLoopTiming.Update:
				Update();
				break;
			case PlayerLoopTiming.LastUpdate:
				LastUpdate();
				break;
			case PlayerLoopTiming.PreLateUpdate:
				PreLateUpdate();
				break;
			case PlayerLoopTiming.LastPreLateUpdate:
				LastPreLateUpdate();
				break;
			case PlayerLoopTiming.PostLateUpdate:
				PostLateUpdate();
				break;
			case PlayerLoopTiming.LastPostLateUpdate:
				LastPostLateUpdate();
				break;
			case PlayerLoopTiming.TimeUpdate:
				TimeUpdate();
				break;
			case PlayerLoopTiming.LastTimeUpdate:
				LastTimeUpdate();
				break;
			}
		}

		private void Initialization()
		{
			RunCore();
		}

		private void LastInitialization()
		{
			RunCore();
		}

		private void EarlyUpdate()
		{
			RunCore();
		}

		private void LastEarlyUpdate()
		{
			RunCore();
		}

		private void FixedUpdate()
		{
			RunCore();
		}

		private void LastFixedUpdate()
		{
			RunCore();
		}

		private void PreUpdate()
		{
			RunCore();
		}

		private void LastPreUpdate()
		{
			RunCore();
		}

		private void Update()
		{
			RunCore();
		}

		private void LastUpdate()
		{
			RunCore();
		}

		private void PreLateUpdate()
		{
			RunCore();
		}

		private void LastPreLateUpdate()
		{
			RunCore();
		}

		private void PostLateUpdate()
		{
			RunCore();
		}

		private void LastPostLateUpdate()
		{
			RunCore();
		}

		private void TimeUpdate()
		{
			RunCore();
		}

		private void LastTimeUpdate()
		{
			RunCore();
		}

		[DebuggerHidden]
		private void RunCore()
		{
			lock (runningAndQueueLock)
			{
				running = true;
			}
			lock (arrayLock)
			{
				int num = tail - 1;
				for (int i = 0; i < loopItems.Length; i++)
				{
					IPlayerLoopItem playerLoopItem = loopItems[i];
					if (playerLoopItem != null)
					{
						try
						{
							if (!playerLoopItem.MoveNext())
							{
								loopItems[i] = null;
								goto IL_00f9;
							}
						}
						catch (Exception obj)
						{
							loopItems[i] = null;
							try
							{
								unhandledExceptionCallback(obj);
							}
							catch
							{
							}
							goto IL_00f9;
						}
						continue;
					}
					goto IL_00f9;
					IL_00f9:
					while (i < num)
					{
						IPlayerLoopItem playerLoopItem2 = loopItems[num];
						if (playerLoopItem2 != null)
						{
							try
							{
								if (!playerLoopItem2.MoveNext())
								{
									loopItems[num] = null;
									num--;
									continue;
								}
								loopItems[i] = playerLoopItem2;
								loopItems[num] = null;
								num--;
								goto IL_0106;
							}
							catch (Exception obj3)
							{
								loopItems[num] = null;
								num--;
								try
								{
									unhandledExceptionCallback(obj3);
								}
								catch
								{
								}
							}
						}
						else
						{
							num--;
						}
					}
					tail = i;
					break;
					IL_0106:;
				}
				lock (runningAndQueueLock)
				{
					running = false;
					while (waitQueue.Count != 0)
					{
						if (loopItems.Length == tail)
						{
							Array.Resize(ref loopItems, checked(tail * 2));
						}
						loopItems[tail++] = waitQueue.Dequeue();
					}
				}
			}
		}
	}
	internal sealed class PooledDelegate<T> : ITaskPoolNode<PooledDelegate<T>>
	{
		private static TaskPool<PooledDelegate<T>> pool;

		private PooledDelegate<T> nextNode;

		private readonly Action<T> runDelegate;

		private Action continuation;

		public ref PooledDelegate<T> NextNode => ref nextNode;

		static PooledDelegate()
		{
			TaskPool.RegisterSizeGetter(typeof(PooledDelegate<T>), () => pool.Size);
		}

		private PooledDelegate()
		{
			runDelegate = Run;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Action<T> Create(Action continuation)
		{
			if (!pool.TryPop(out var result))
			{
				result = new PooledDelegate<T>();
			}
			result.continuation = continuation;
			return result.runDelegate;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Run(T _)
		{
			Action action = continuation;
			continuation = null;
			if (action != null)
			{
				pool.TryPush(this);
				action();
			}
		}
	}
	internal static class RuntimeHelpersAbstraction
	{
		private static class WellKnownNoReferenceContainsType<T>
		{
			public static readonly bool IsWellKnownType;

			static WellKnownNoReferenceContainsType()
			{
				IsWellKnownType = WellKnownNoReferenceContainsTypeInitialize(typeof(T));
			}
		}

		public static bool IsWellKnownNoReferenceContainsType<T>()
		{
			return WellKnownNoReferenceContainsType<T>.IsWellKnownType;
		}

		private static bool WellKnownNoReferenceContainsTypeInitialize(Type t)
		{
			if (t.IsPrimitive)
			{
				return true;
			}
			if (t.IsEnum)
			{
				return true;
			}
			if (t == typeof(DateTime))
			{
				return true;
			}
			if (t == typeof(DateTimeOffset))
			{
				return true;
			}
			if (t == typeof(Guid))
			{
				return true;
			}
			if (t == typeof(decimal))
			{
				return true;
			}
			if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				return WellKnownNoReferenceContainsTypeInitialize(t.GetGenericArguments()[0]);
			}
			if (t == typeof(Vector2))
			{
				return true;
			}
			if (t == typeof(Vector3))
			{
				return true;
			}
			if (t == typeof(Vector4))
			{
				return true;
			}
			if (t == typeof(Color))
			{
				return true;
			}
			if (t == typeof(Rect))
			{
				return true;
			}
			if (t == typeof(Bounds))
			{
				return true;
			}
			if (t == typeof(Quaternion))
			{
				return true;
			}
			if (t == typeof(Vector2Int))
			{
				return true;
			}
			if (t == typeof(Vector3Int))
			{
				return true;
			}
			return false;
		}
	}
	internal static class StateTuple
	{
		public static StateTuple<T1> Create<T1>(T1 item1)
		{
			return StatePool<T1>.Create(item1);
		}

		public static StateTuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
		{
			return StatePool<T1, T2>.Create(item1, item2);
		}

		public static StateTuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
		{
			return StatePool<T1, T2, T3>.Create(item1, item2, item3);
		}
	}
	internal class StateTuple<T1> : IDisposable
	{
		public T1 Item1;

		public void Deconstruct(out T1 item1)
		{
			item1 = Item1;
		}

		public void Dispose()
		{
			StatePool<T1>.Return(this);
		}
	}
	internal static class StatePool<T1>
	{
		private static readonly ConcurrentQueue<StateTuple<T1>> queue = new ConcurrentQueue<StateTuple<T1>>();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static StateTuple<T1> Create(T1 item1)
		{
			if (queue.TryDequeue(out var result))
			{
				result.Item1 = item1;
				return result;
			}
			return new StateTuple<T1>
			{
				Item1 = item1
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Return(StateTuple<T1> tuple)
		{
			tuple.Item1 = default(T1);
			queue.Enqueue(tuple);
		}
	}
	internal class StateTuple<T1, T2> : IDisposable
	{
		public T1 Item1;

		public T2 Item2;

		public void Deconstruct(out T1 item1, out T2 item2)
		{
			item1 = Item1;
			item2 = Item2;
		}

		public void Dispose()
		{
			StatePool<T1, T2>.Return(this);
		}
	}
	internal static class StatePool<T1, T2>
	{
		private static readonly ConcurrentQueue<StateTuple<T1, T2>> queue = new ConcurrentQueue<StateTuple<T1, T2>>();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static StateTuple<T1, T2> Create(T1 item1, T2 item2)
		{
			if (queue.TryDequeue(out var result))
			{
				result.Item1 = item1;
				result.Item2 = item2;
				return result;
			}
			return new StateTuple<T1, T2>
			{
				Item1 = item1,
				Item2 = item2
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Return(StateTuple<T1, T2> tuple)
		{
			tuple.Item1 = default(T1);
			tuple.Item2 = default(T2);
			queue.Enqueue(tuple);
		}
	}
	internal class StateTuple<T1, T2, T3> : IDisposable
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		public void Deconstruct(out T1 item1, out T2 item2, out T3 item3)
		{
			item1 = Item1;
			item2 = Item2;
			item3 = Item3;
		}

		public void Dispose()
		{
			StatePool<T1, T2, T3>.Return(this);
		}
	}
	internal static class StatePool<T1, T2, T3>
	{
		private static readonly ConcurrentQueue<StateTuple<T1, T2, T3>> queue = new ConcurrentQueue<StateTuple<T1, T2, T3>>();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static StateTuple<T1, T2, T3> Create(T1 item1, T2 item2, T3 item3)
		{
			if (queue.TryDequeue(out var result))
			{
				result.Item1 = item1;
				result.Item2 = item2;
				result.Item3 = item3;
				return result;
			}
			return new StateTuple<T1, T2, T3>
			{
				Item1 = item1,
				Item2 = item2,
				Item3 = item3
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Return(StateTuple<T1, T2, T3> tuple)
		{
			tuple.Item1 = default(T1);
			tuple.Item2 = default(T2);
			tuple.Item3 = default(T3);
			queue.Enqueue(tuple);
		}
	}
	internal static class UnityEqualityComparer
	{
		private static class Cache<T>
		{
			public static readonly IEqualityComparer<T> Comparer;

			static Cache()
			{
				object defaultHelper = GetDefaultHelper(typeof(T));
				if (defaultHelper == null)
				{
					Comparer = EqualityComparer<T>.Default;
				}
				else
				{
					Comparer = (IEqualityComparer<T>)defaultHelper;
				}
			}
		}

		private sealed class Vector2EqualityComparer : IEqualityComparer<Vector2>
		{
			public bool Equals(Vector2 self, Vector2 vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if (self.x.Equals(vector.x))
				{
					return self.y.Equals(vector.y);
				}
				return false;
			}

			public int GetHashCode(Vector2 obj)
			{
				return obj.x.GetHashCode() ^ (obj.y.GetHashCode() << 2);
			}
		}

		private sealed class Vector3EqualityComparer : IEqualityComparer<Vector3>
		{
			public bool Equals(Vector3 self, Vector3 vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if (self.x.Equals(vector.x) && self.y.Equals(vector.y))
				{
					return self.z.Equals(vector.z);
				}
				return false;
			}

			public int GetHashCode(Vector3 obj)
			{
				return obj.x.GetHashCode() ^ (obj.y.GetHashCode() << 2) ^ (obj.z.GetHashCode() >> 2);
			}
		}

		private sealed class Vector4EqualityComparer : IEqualityComparer<Vector4>
		{
			public bool Equals(Vector4 self, Vector4 vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if (self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z))
				{
					return self.w.Equals(vector.w);
				}
				return false;
			}

			public int GetHashCode(Vector4 obj)
			{
				return obj.x.GetHashCode() ^ (obj.y.GetHashCode() << 2) ^ (obj.z.GetHashCode() >> 2) ^ (obj.w.GetHashCode() >> 1);
			}
		}

		private sealed class ColorEqualityComparer : IEqualityComparer<Color>
		{
			public bool Equals(Color self, Color other)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if (self.r.Equals(other.r) && self.g.Equals(other.g) && self.b.Equals(other.b))
				{
					return self.a.Equals(other.a);
				}
				return false;
			}

			public int GetHashCode(Color obj)
			{
				return obj.r.GetHashCode() ^ (obj.g.GetHashCode() << 2) ^ (obj.b.GetHashCode() >> 2) ^ (obj.a.GetHashCode() >> 1);
			}
		}

		private sealed class RectEqualityComparer : IEqualityComparer<Rect>
		{
			public bool Equals(Rect self, Rect other)
			{
				if (((Rect)(ref self)).x.Equals(((Rect)(ref other)).x) && ((Rect)(ref self)).width.Equals(((Rect)(ref other)).width) && ((Rect)(ref self)).y.Equals(((Rect)(ref other)).y))
				{
					return ((Rect)(ref self)).height.Equals(((Rect)(ref other)).height);
				}
				return false;
			}

			public int GetHashCode(Rect obj)
			{
				return ((Rect)(ref obj)).x.GetHashCode() ^ (((Rect)(ref obj)).width.GetHashCode() << 2) ^ (((Rect)(ref obj)).y.GetHashCode() >> 2) ^ (((Rect)(ref obj)).height.GetHashCode() >> 1);
			}
		}

		private sealed class BoundsEqualityComparer : IEqualityComparer<Bounds>
		{
			public bool Equals(Bounds self, Bounds vector)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: 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_0024: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Bounds)(ref self)).center;
				if (((Vector3)(ref val)).Equals(((Bounds)(ref vector)).center))
				{
					val = ((Bounds)(ref self)).extents;
					return ((Vector3)(ref val)).Equals(((Bounds)(ref vector)).extents);
				}
				return false;
			}

			public int GetHashCode(Bounds obj)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Bounds)(ref obj)).center;
				int hashCode = ((object)(Vector3)(ref val)).GetHashCode();
				val = ((Bounds)(ref obj)).extents;
				return hashCode ^ (((object)(Vector3)(ref val)).GetHashCode() << 2);
			}
		}

		private sealed class QuaternionEqualityComparer : IEqualityComparer<Quaternion>
		{
			public bool Equals(Quaternion self, Quaternion vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if (self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z))
				{
					return self.w.Equals(vector.w);
				}
				return false;
			}

			public int GetHashCode(Quaternion obj)
			{
				return obj.x.GetHashCode() ^ (obj.y.GetHashCode() << 2) ^ (obj.z.GetHashCode() >> 2) ^ (obj.w.GetHashCode() >> 1);
			}
		}

		private sealed class Color32EqualityComparer : IEqualityComparer<Color32>
		{
			public bool Equals(Color32 self, Color32 vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if (self.a.Equals(vector.a) && self.r.Equals(vector.r) && self.g.Equals(vector.g))
				{
					return self.b.Equals(vector.b);
				}
				return false;
			}

			public int GetHashCode(Color32 obj)
			{
				return obj.a.GetHashCode() ^ (obj.r.GetHashCode() << 2) ^ (obj.g.GetHashCode() >> 2) ^ (obj.b.GetHashCode() >> 1);
			}
		}

		private sealed class Vector2IntEqualityComparer : IEqualityComparer<Vector2Int>
		{
			public bool Equals(Vector2Int self, Vector2Int vector)
			{
				if (((Vector2Int)(ref self)).x.Equals(((Vector2Int)(ref vector)).x))
				{
					return ((Vector2Int)(ref self)).y.Equals(((Vector2Int)(ref vector)).y);
				}
				return false;
			}

			public int GetHashCode(Vector2Int obj)
			{
				return ((Vector2Int)(ref obj)).x.GetHashCode() ^ (((Vector2Int)(ref obj)).y.GetHashCode() << 2);
			}
		}

		private sealed class Vector3IntEqualityComparer : IEqualityComparer<Vector3Int>
		{
			public static readonly Vector3IntEqualityComparer Default = new Vector3IntEqualityComparer();

			public bool Equals(Vector3Int self, Vector3Int vector)
			{
				if (((Vector3Int)(ref self)).x.Equals(((Vector3Int)(ref vector)).x) && ((Vector3Int)(ref self)).y.Equals(((Vector3Int)(ref vector)).y))
				{
					return ((Vector3Int)(ref self)).z.Equals(((Vector3Int)(ref vector)).z);
				}
				return false;
			}

			public int GetHashCode(Vector3Int obj)
			{
				return ((Vector3Int)(ref obj)).x.GetHashCode() ^ (((Vector3Int)(ref obj)).y.GetHashCode() << 2) ^ (((Vector3Int)(ref obj)).z.GetHashCode() >> 2);
			}
		}

		private sealed class RangeIntEqualityComparer : IEqualityComparer<RangeInt>
		{
			public bool Equals(RangeInt self, RangeInt vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if (self.start.Equals(vector.start))
				{
					return self.length.Equals(vector.length);
				}
				return false;
			}

			public int GetHashCode(RangeInt obj)
			{
				return obj.start.GetHashCode() ^ (obj.length.GetHashCode() << 2);
			}
		}

		private sealed class RectIntEqualityComparer : IEqualityComparer<RectInt>
		{
			public bool Equals(RectInt self, RectInt other)
			{
				if (((RectInt)(ref self)).x.Equals(((RectInt)(ref other)).x) && ((RectInt)(ref self)).width.Equals(((RectInt)(ref other)).width) && ((RectInt)(ref self)).y.Equals(((RectInt)(ref other)).y))
				{
					return ((RectInt)(ref self)).height.Equals(((RectInt)(ref other)).height);
				}
				return false;
			}

			public int GetHashCode(RectInt obj)
			{
				return ((RectInt)(ref obj)).x.GetHashCode() ^ (((RectInt)(ref obj)).width.GetHashCode() << 2) ^ (((RectInt)(ref obj)).y.GetHashCode() >> 2) ^ (((RectInt)(ref obj)).height.GetHashCode() >> 1);
			}
		}

		private sealed class BoundsIntEqualityComparer : IEqualityComparer<BoundsInt>
		{
			public bool Equals(BoundsInt self, BoundsInt vector)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				if (Vector3IntEqualityComparer.Default.Equals(((BoundsInt)(ref self)).position, ((BoundsInt)(ref vector)).position))
				{
					return Vector3IntEqualityComparer.Default.Equals(((BoundsInt)(ref self)).size, ((BoundsInt)(ref vector)).size);
				}
				return false;
			}

			public int GetHashCode(BoundsInt obj)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				return Vector3IntEqualityComparer.Default.GetHashCode(((BoundsInt)(ref obj)).position) ^ (Vector3IntEqualityComparer.Default.GetHashCode(((BoundsInt)(ref obj)).size) << 2);
			}
		}

		public static readonly IEqualityComparer<Vector2> Vector2 = new Vector2EqualityComparer();

		public static readonly IEqualityComparer<Vector3> Vector3 = new Vector3EqualityComparer();

		public static readonly IEqualityComparer<Vector4> Vector4 = new Vector4EqualityComparer();

		public static readonly IEqualityComparer<Color> Color = new ColorEqualityComparer();

		public static readonly IEqualityComparer<Color32> Color32 = new Color32EqualityComparer();

		public static readonly IEqualityComparer<Rect> Rect = new RectEqualityComparer();

		public static readonly IEqualityComparer<Bounds> Bounds = new BoundsEqualityComparer();

		public static readonly IEqualityComparer<Quaternion> Quaternion = new QuaternionEqualityComparer();

		private static readonly RuntimeTypeHandle vector2Type = typeof(Vector2).TypeHandle;

		private static readonly RuntimeTypeHandle vector3Type = typeof(Vector3).TypeHandle;

		private static readonly RuntimeTypeHandle vector4Type = typeof(Vector4).TypeHandle;

		private static readonly RuntimeTypeHandle colorType = typeof(Color).TypeHandle;

		private static readonly RuntimeTypeHandle color32Type = typeof(Color32).TypeHandle;

		private static readonly RuntimeTypeHandle rectType = typeof(Rect).TypeHandle;

		private static readonly RuntimeTypeHandle boundsType = typeof(Bounds).TypeHandle;

		private static readonly RuntimeTypeHandle quaternionType = typeof(Quaternion).TypeHandle;

		public static readonly IEqualityComparer<Vector2Int> Vector2Int = new Vector2IntEqualityComparer();

		public static readonly IEqualityComparer<Vector3Int> Vector3Int = new Vector3IntEqualityComparer();

		public static readonly IEqualityComparer<RangeInt> RangeInt = new RangeIntEqualityComparer();

		public static readonly IEqualityComparer<RectInt> RectInt = new RectIntEqualityComparer();

		public static readonly IEqualityComparer<BoundsInt> BoundsInt = new BoundsIntEqualityComparer();

		private static readonly RuntimeTypeHandle vector2IntType = typeof(Vector2Int).TypeHandle;

		private static readonly RuntimeTypeHandle vector3IntType = typeof(Vector3Int).TypeHandle;

		private static readonly RuntimeTypeHandle rangeIntType = typeof(RangeInt).TypeHandle;

		private static readonly RuntimeTypeHandle rectIntType = typeof(RectInt).TypeHandle;

		private static readonly RuntimeTypeHandle boundsIntType = typeof(BoundsInt).TypeHandle;

		public static IEqualityComparer<T> GetDefault<T>()
		{
			return Cache<T>.Comparer;
		}

		private static object GetDefaultHelper(Type type)
		{
			RuntimeTypeHandle typeHandle = type.TypeHandle;
			if (typeHandle.Equals(vector2Type))
			{
				return Vector2;
			}
			if (typeHandle.Equals(vector3Type))
			{
				return Vector3;
			}
			if (typeHandle.Equals(vector4Type))
			{
				return Vector4;
			}
			if (typeHandle.Equals(colorType))
			{
				return Color;
			}
			if (typeHandle.Equals(color32Type))
			{
				return Color32;
			}
			if (typeHandle.Equals(rectType))
			{
				return Rect;
			}
			if (typeHandle.Equals(boundsType))
			{
				return Bounds;
			}
			if (typeHandle.Equals(quaternionType))
			{
				return Quaternion;
			}
			if (typeHandle.Equals(vector2IntType))
			{
				return Vector2Int;
			}
			if (typeHandle.Equals(vector3IntType))
			{
				return Vector3Int;
			}
			if (typeHandle.Equals(rangeIntType))
			{
				return RangeInt;
			}
			if (typeHandle.Equals(rectIntType))
			{
				return RectInt;
			}
			if (typeHandle.Equals(boundsIntType))
			{
				return BoundsInt;
			}
			return null;
		}
	}
	internal static class UnityWebRequestResultExtensions
	{
		public static bool IsError(this UnityWebRequest unityWebRequest)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			Result result = unityWebRequest.result;
			if ((int)result != 2 && (int)result != 4)
			{
				return (int)result == 3;
			}
			return true;
		}
	}
	internal readonly struct ValueStopwatch
	{
		private static readonly double TimestampToTicks = 10000000.0 / (double)Stopwatch.Frequency;

		private readonly long startTimestamp;

		public TimeSpan Elapsed => TimeSpan.FromTicks(ElapsedTicks);

		public bool IsInvalid => startTimestamp == 0;

		public long ElapsedTicks
		{
			get
			{
				if (startTimestamp == 0L)
				{
					throw new InvalidOperationException("Detected invalid initialization(use 'default'), only to create from StartNew().");
				}
				return (long)((double)(Stopwatch.GetTimestamp() - startTimestamp) * TimestampToTicks);
			}
		}

		public static ValueStopwatch StartNew()
		{
			return new ValueStopwatch(Stopwatch.GetTimestamp());
		}

		private ValueStopwatch(long startTimestamp)
		{
			this.startTimestamp = startTimestamp;
		}
	}
	internal class WeakDictionary<TKey, TValue> where TKey : class
	{
		private class Entry
		{
			public WeakReference<TKey> Key;

			public TValue Value;

			public int Hash;

			public Entry Prev;

			public Entry Next;

			public override string ToString()
			{
				if (Key.TryGetTarget(out var target))
				{
					return target?.ToString() + "(" + Count() + ")";
				}
				return "(Dead)";
			}

			private int Count()
			{
				int num = 1;
				Entry entry = this;
				while (entry.Next != null)
				{
					num++;
					entry = entry.Next;
				}
				return num;
			}
		}

		private Entry[] buckets;

		private int size;

		private SpinLock gate;

		private readonly float loadFactor;

		private readonly IEqualityComparer<TKey> keyEqualityComparer;

		public WeakDictionary(int capacity = 4, float loadFactor = 0.75f, IEqualityComparer<TKey> keyComparer = null)
		{
			int num = CalculateCapacity(capacity, loadFactor);
			buckets = new Entry[num];
			this.loadFactor = loadFactor;
			gate = new SpinLock(enableThreadOwnerTracking: false);
			keyEqualityComparer = keyComparer ?? EqualityComparer<TKey>.Default;
		}

		public bool TryAdd(TKey key, TValue value)
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				return TryAddInternal(key, value);
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				if (TryGetEntry(key, out var _, out var entry))
				{
					value = entry.Value;
					return true;
				}
				value = default(TValue);
				return false;
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}

		public bool TryRemove(TKey key)
		{
			bool lockTaken = false;
			try
			{
				gate.Enter(ref lockTaken);
				if (TryGetEntry(key, out var hashIndex, out var entry))
				{
					Remove(hashIndex, entry);
					return true;
				}
				return false;
			}
			finally
			{
				if (lockTaken)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}

		private bool TryAddInternal(TKey key, TValue value)
		{
			int num = CalculateCapacity(size + 1, loadFactor);
			while (buckets.Length < num)
			{
				Entry[] targetBuckets = new Entry[num];
				for (int i = 0; i < buckets.Length; i++)
				{
					for (Entry entry = buckets[i]; entry != null; entry = entry.Next)
					{
						AddToBuckets(targetBuckets, key, entry.Value, entry.Hash);
					}
				}
				buckets = targetBuckets;
			}
			bool num2 = AddToBuckets(buckets, key, value, keyEqualityComparer.GetHashCode(key));
			if (num2)
			{
				size++;
			}
			return num2;
		}

		private bool AddToBuckets(Entry[] targetBuckets, TKey newKey, TValue value, int keyHash)
		{
			int num = keyHash & (targetBuckets.Length - 1);
			while (targetBuckets[num] != null)
			{
				Entry entry = targetBuckets[num];
				while (true)
				{
					if (entry != null)
					{
						if (entry.Key.TryGetTarget(out var target))
						{
							if (keyEqualityComparer.Equals(newKey, target))
							{
								return false;
							}
						}
						else
						{
							Remove(num, entry);
							if (targetBuckets[num] == null)
							{
								break;
							}
						}
						if (entry.Next != null)
						{
							entry = entry.Next;
							continue;
						}
						entry.Next = new Entry
						{
							Key = new WeakReference<TKey>(newKey, trackResurrection: false),
							Value = value,
							Hash = keyHash
						};
						entry.Next.Prev = entry;
						continue;
					}
					return false;
				}
			}
			targetBuckets[num] = new Entry
			{
				Key = new WeakReference<TKey>(newKey, trackResurrection: false),
				Value = value,
				Hash = keyHash
			};
			return true;
		}

		private bool TryGetEntry(TKey key, out int hashIndex, out Entry entry)
		{
			Entry[] array = buckets;
			int hashCode = keyEqualityComparer.GetHashCode(key);
			hashIndex = hashCode & (array.Length - 1);
			for (entry = array[hashIndex]; entry != null; entry = entry.Next)
			{
				if (entry.Key.TryGetTarget(out var target))
				{
					if (keyEqualityComparer.Equals(key, target))
					{
						return true;
					}
				}
				else
				{
					Remove(hashIndex, entry);
				}
			}
			return false;
		}

		private void Remove(int hashIndex, Entry entry)
		{
			if (entry.Prev == null && entry.Next == null)
			{
				buckets[hashIndex] = null;
			}
			else
			{
				if (entry.Prev == null)
				{
					buckets[hashIndex] = entry.Next;
				}
				if (entry.Prev != null)
				{
					entry.Prev.Next = entry.Next;
				}
				if (entry.Next != null)
				{
					entry.Next.Prev = entry.Prev;
				}
			}
			size--;
		}

		public List<KeyValuePair<TKey, TValue>> ToList()
		{
			List<KeyValuePair<TKey, TValue>> list = new List<KeyValuePair<TKey, TValue>>(size);
			ToList(ref list, clear: false);
			return list;
		}

		public int ToList(ref List<KeyValuePair<TKey, TValue>> list, bool clear = true)
		{
			if (clear)
			{
				list.Clear();
			}
			int num = 0;
			bool flag = false;
			try
			{
				for (int i = 0; i < buckets.Length; i++)
				{
					for (Entry entry = buckets[i]; entry != null; entry = entry.Next)
					{
						if (entry.Key.TryGetTarget(out var target))
						{
							KeyValuePair<TKey, TValue> keyValuePair = new KeyValuePair<TKey, TValue>(target, entry.Value);
							if (num < list.Count)
							{
								list[num++] = keyValuePair;
							}
							else
							{
								list.Add(keyValuePair);
								num++;
							}
						}
						else
						{
							Remove(i, entry);
						}
					}
				}
				return num;
			}
			finally
			{
				if (flag)
				{
					gate.Exit(useMemoryBarrier: false);
				}
			}
		}

		private static int CalculateCapacity(int collectionSize, float loadFactor)
		{
			int num = (int)((float)collectionSize / loadFactor);
			num--;
			num |= num >> 1;
			num |= num >> 2;
			num |= num >> 4;
			num |= num >> 8;
			num |= num >> 16;
			num++;
			if (num < 8)
			{
				num = 8;
			}
			return num;
		}
	}
	internal class EmptyDisposable : IDisposable
	{
		public static EmptyDisposable Instance = new EmptyDisposable();

		private EmptyDisposable()
		{
		}

		public void Dispose()
		{
		}
	}
	internal sealed class SingleAssignmentDisposable : IDisposable
	{
		private readonly object gate = new object();

		private IDisposable current;

		private bool disposed;

		public bool IsDisposed
		{
			get
			{
				lock (gate)
				{
					return disposed;
				}
			}
		}

		public IDisposable Disposable
		{
			get
			{
				return current;
			}
			set
			{
				IDisposable disposable = null;
				bool flag;
				lock (gate)
				{
					flag = disposed;
					disposable = current;
					if (!flag)
					{
						if (value == null)
						{
							return;
						}
						current = value;
					}
				}
				if (flag && value != null)
				{
					value.Dispose();
				}
				else if (disposable != null)
				{
					throw new InvalidOperationException("Disposable is already set");
				}
			}
		}

		public void Dispose()
		{
			IDisposable disposable = null;
			lock (gate)
			{
				if (!disposed)
				{
					disposed = true;
					disposable = current;
					current = null;
				}
			}
			disposable?.Dispose();
		}
	}
	internal sealed class AsyncSubject<T> : IObservable<T>, IObserver<T>
	{
		private class Subscription : IDisposable
		{
			private readonly object gate = new object();

			private AsyncSubject<T> parent;

			private IObserver<T> unsubscribeTarget;

			public Subscription(AsyncSubject<T> parent, IObserver<T> unsubscribeTarget)
			{
				this.parent = parent;
				this.unsubscribeTarget = unsubscribeTarget;
			}

			public void Dispose()
			{
				lock (gate)
				{
					if (parent == null)
					{
						return;
					}
					lock (parent.observerLock)
					{
						if (parent.outObserver is ListObserver<T> listObserver)
						{
							parent.outObserver = listObserver.Remove(unsubscribeTarget);
						}
						else
						{
							parent.outObserver = EmptyObserver<T>.Instance;
						}
						unsubscribeTarget = null;
						parent = null;
					}
				}
			}
		}

		private object observerLock = new object();

		private T lastValue;

		private bool hasValue;

		private bool isStopped;

		private bool isDisposed;

		private Exception lastError;

		private IObserver<T> outObserver = EmptyObserver<T>.Instance;

		public T Value
		{
			get
			{
				ThrowIfDisposed();
				if (!isStopped)
				{
					throw new InvalidOperationException("AsyncSubject is not completed yet");
				}
				if (lastError != null)
				{
					ExceptionDispatchInfo.Capture(lastError).Throw();
				}
				return lastValue;
			}
		}

		public bool HasObservers
		{
			get
			{
				if (!(outObserver is EmptyObserver<T>) && !isStopped)
				{
					return !isDisposed;
				}
				return false;
			}
		}

		public bool IsCompleted => isStopped;

		public void OnCompleted()
		{
			IObserver<T> observer;
			T value;
			bool flag;
			lock (observerLock)
			{
				ThrowIfDisposed();
				if (isStopped)
				{
					return;
				}
				observer = outObserver;
				outObserver = EmptyObserver<T>.Instance;
				isStopped = true;
				value = lastValue;
				flag = hasValue;
			}
			if (flag)
			{
				observer.OnNext(value);
				observer.OnCompleted();
			}
			else
			{
				observer.OnCompleted();
			}
		}

		public void OnError(Exception error)
		{
			if (error == null)
			{
				throw new ArgumentNullException("error");
			}
			IObserver<T> observer;
			lock (observerLock)
			{
				ThrowIfDisposed();
				if (isStopped)
				{
					return;
				}
				observer = outObserver;
				outObserver = EmptyObserver<T>.Instance;
				isStopped = true;
				lastError = error;
			}
			observer.OnError(error);
		}

		public void OnNext(T value)
		{
			lock (observerLock)
			{
				ThrowIfDisposed();
				if (!isStopped)
				{
					hasValue = true;
					lastValue = value;
				}
			}
		}

		public IDisposable Subscribe(IObserver<T> observer)
		{
			if (observer == null)
			{
				throw new ArgumentNullException("observer");
			}
			Exception ex = null;
			T value = default(T);
			bool flag = false;
			lock (observerLock)
			{
				ThrowIfDisposed();
				if (!isStopped)
				{
					if (outObserver is ListObserver<T> listObserver)
					{
						outObserver = listObserver.Add(observer);
					}
					else
					{
						IObserver<T> observer2 = outObserver;
						if (observer2 is EmptyObserver<T>)
						{
							outObserver = observer;
						}
						else
						{
							outObserver = new ListObserver<T>(new ImmutableList<IObserver<T>>(new IObserver<T>[2] { observer2, observer }));
						}
					}
					return new Subscription(this, observer);
				}
				ex = lastError;
				value = lastValue;
				flag = hasValue;
			}
			if (ex != null)
			{
				observer.OnError(ex);
			}
			else if (flag)
			{
				observer.OnNext(value);
				observer.OnCompleted();
			}
			else
			{
				observer.OnCompleted();
			}
			return EmptyDisposable.Instance;
		}

		public void Dispose()
		{
			lock (observerLock)
			{
				isDisposed = true;
				outObserver = DisposedObserver<T>.Instance;
				lastError = null;
				lastValue = default(T);
			}
		}

		private void ThrowIfDisposed()
		{
			if (isDisposed)
			{
				throw new ObjectDisposedException("");
			}
		}
	}
	internal class ListObserver<T> : IObserver<T>
	{
		private readonly ImmutableList<IObserver<T>> _observers;

		public ListObserver(ImmutableList<IObserver<T>> observers)
		{
			_observers = observers;
		}

		public void OnCompleted()
		{
			IObserver<T>[] data = _observers.Data;
			for (int i = 0; i < data.Length; i++)
			{
				data[i].OnCompleted();
			}
		}

		public void OnError(Exception error)
		{
			IObserver<T>[] data = _observers.Data;
			for (int i = 0; i < data.Length; i++)
			{
				data[i].OnError(error);
			}
		}

		public void OnNext(T value)
		{
			IObserver<T>[] data = _observers.Data;
			for (int i = 0; i < data.Length; i++)
			{
				data[i].OnNext(value);
			}
		}

		internal IObserver<T> Add(IObserver<T> observer)
		{
			return new ListObserver<T>(_observers.Add(observer));
		}

		internal IObserver<T> Remove(IObserver<T> observer)
		{
			int num = Array.IndexOf(_observers.Data, observer);
			if (num < 0)
			{
				return this;
			}
			if (_observers.Data.Length == 2)
			{
				return _observers.Data[1 - num];
			}
			return new ListObserver<T>(_observers.Remove(observer));
		}
	}
	internal class EmptyObserver<T> : IObserver<T>
	{
		public static readonly EmptyObserver<T> Instance = new EmptyObserver<T>();

		private EmptyObserver()
		{
		}

		public void OnCompleted()
		{
		}

		public void OnError(Exception error)
		{
		}

		public void OnNext(T value)
		{
		}
	}
	internal class ThrowObserver<T> : IObserver<T>
	{
		public static readonly ThrowObserver<T> Instance = new ThrowObserver<T>();

		private ThrowObserver()
		{
		}

		public void OnCompleted()
		{
		}

		public void OnError(Exception error)
		{
			ExceptionDispatchInfo.Capture(error).Throw();
		}

		public void OnNext(T value)
		{
		}
	}
	internal class DisposedObserver<T> : IObserver<T>
	{
		public static readonly DisposedObserver<T> Instance = new DisposedObserver<T>();

		private DisposedObserver()
		{
		}

		public void OnCompleted()
		{
			throw new ObjectDisposedException("");
		}

		public void OnError(Exception error)
		{
			throw new ObjectDisposedException("");
		}

		public void OnNext(T value)
		{
			throw new ObjectDisposedException("");
		}
	}
	internal class ImmutableList<T>
	{
		public static readonly ImmutableList<T> Empty = new ImmutableList<T>();

		private T[] data;

		public T[] Data => data;

		private ImmutableList()
		{
			data = new T[0];
		}

		public ImmutableList(T[] data)
		{
			this.data = data;
		}

		public ImmutableList<T> Add(T value)
		{
			T[] array = new T[data.Length + 1];
			Array.Copy(data, array, data.Length);
			array[data.Length] = value;
			return new ImmutableList<T>(array);
		}

		public ImmutableList<T> Remove(T value)
		{
			int num = IndexOf(value);
			if (num < 0)
			{
				return this;
			}
			int num2 = data.Length;
			if (num2 == 1)
			{
				return Empty;
			}
			T[] destinationArray = new T[num2 - 1];
			Array.Copy(data, 0, destinationArray, 0, num);
			Array.Copy(data, num + 1, destinationArray, num, num2 - num - 1);
			return new ImmutableList<T>(destinationArray);
		}

		public int IndexOf(T value)
		{
			for (int i = 0; i < data.Length; i++)
			{
				if (object.Equals(data[i], value))
				{
					return i;
				}
			}
			return -1;
		}
	}
}
namespace Cysharp.Threading.Tasks.CompilerServices
{
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncUniTaskMethodBuilder
	{
		private IStateMachineRunnerPromise runnerPromise;

		private Exception ex;

		private object debuggingId;

		public UniTask Task
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			get
			{
				if (runnerPromise != null)
				{
					return runnerPromise.Task;
				}
				if (ex != null)
				{
					return UniTask.FromException(ex);
				}
				return UniTask.CompletedTask;
			}
		}

		private object ObjectIdForDebugger
		{
			get
			{
				if (debuggingId == null)
				{
					debuggingId = new object();
				}
				return debuggingId;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public static AsyncUniTaskMethodBuilder Create()
		{
			return default(AsyncUniTaskMethodBuilder);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void SetException(Exception exception)
		{
			if (runnerPromise == null)
			{
				ex = exception;
			}
			else
			{
				runnerPromise.SetException(exception);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void SetResult()
		{
			if (runnerPromise != null)
			{
				runnerPromise.SetResult();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			if (runnerPromise == null)
			{
				AsyncUniTask<TStateMachine>.SetStateMachine(ref stateMachine, ref runnerPromise);
			}
			awaiter.OnCompleted(runnerPromise.MoveNext);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		[SecuritySafeCritical]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			if (runnerPromise == null)
			{
				AsyncUniTask<TStateMachine>.SetStateMachine(ref stateMachine, ref runnerPromise);
			}
			awaiter.UnsafeOnCompleted(runnerPromise.MoveNext);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			stateMachine.MoveNext();
		}

		[DebuggerHidden]
		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncUniTaskMethodBuilder<T>
	{
		private IStateMachineRunnerPromise<T> runnerPromise;

		private Exception ex;

		private T result;

		private object debuggingId;

		public UniTask<T> Task
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			get
			{
				if (runnerPromise != null)
				{
					return runnerPromise.Task;
				}
				if (ex != null)
				{
					return UniTask.FromException<T>(ex);
				}
				return UniTask.FromResult(result);
			}
		}

		private object ObjectIdForDebugger
		{
			get
			{
				if (debuggingId == null)
				{
					debuggingId = new object();
				}
				return debuggingId;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public static AsyncUniTaskMethodBuilder<T> Create()
		{
			return default(AsyncUniTaskMethodBuilder<T>);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void SetException(Exception exception)
		{
			if (runnerPromise == null)
			{
				ex = exception;
			}
			else
			{
				runnerPromise.SetException(exception);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void SetResult(T result)
		{
			if (runnerPromise == null)
			{
				this.result = result;
			}
			else
			{
				runnerPromise.SetResult(result);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			if (runnerPromise == null)
			{
				AsyncUniTask<TStateMachine, T>.SetStateMachine(ref stateMachine, ref runnerPromise);
			}
			awaiter.OnCompleted(runnerPromise.MoveNext);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		[SecuritySafeCritical]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			if (runnerPromise == null)
			{
				AsyncUniTask<TStateMachine, T>.SetStateMachine(ref stateMachine, ref runnerPromise);
			}
			awaiter.UnsafeOnCompleted(runnerPromise.MoveNext);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			stateMachine.MoveNext();
		}

		[DebuggerHidden]
		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncUniTaskVoidMethodBuilder
	{
		private IStateMachineRunner runner;

		private object debuggingId;

		public UniTaskVoid Task
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerHidden]
			get
			{
				return default(UniTaskVoid);
			}
		}

		private object ObjectIdForDebugger
		{
			get
			{
				if (debuggingId == null)
				{
					debuggingId = new object();
				}
				return debuggingId;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public static AsyncUniTaskVoidMethodBuilder Create()
		{
			return default(AsyncUniTaskVoidMethodBuilder);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void SetException(Exception exception)
		{
			if (runner != null)
			{
				runner.Return();
				runner = null;
			}
			UniTaskScheduler.PublishUnobservedTaskException(exception);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void SetResult()
		{
			if (runner != null)
			{
				runner.Return();
				runner = null;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			if (runner == null)
			{
				AsyncUniTaskVoid<TStateMachine>.SetStateMachine(ref stateMachine, ref runner);
			}
			awaiter.OnCompleted(runner.MoveNext);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		[SecuritySafeCritical]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			if (runner == null)
			{
				AsyncUniTaskVoid<TStateMachine>.SetStateMachine(ref stateMachine, ref runner);
			}
			awaiter.UnsafeOnCompleted(runner.MoveNext);
		}

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

		[DebuggerHidden]
		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
		}
	}
	internal interface IStateMachineRunner
	{
		Action MoveNext { get; }

		void Return();
	}
	internal interface IStateMachineRunnerPromise : IUniTaskSource
	{
		Action MoveNext { get; }

		UniTask Task { get; }

		void SetResult();

		void SetException(Exception exception);
	}
	internal interface IStateMachineRunnerPromise<T> : IUniTaskSource<T>, IUniTaskSource
	{
		Action MoveNext { get; }

		UniTask<T> Task { get; }

		void SetResult(T result);

		void SetException(Exception exception);
	}
	internal static class StateMachineUtility
	{
		public static int GetState(IAsyncStateMachine stateMachine)
		{
			return (int)stateMachine.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).First((FieldInfo x) => x.Name.EndsWith("__state"))
				.GetValue(stateMachine);
		}
	}
	internal sealed class AsyncUniTaskVoid<TStateMachine> : IStateMachineRunner, ITaskPoolNode<AsyncUniTaskVoid<TStateMachine>>, IUniTaskSource where TStateMachine : IAsyncStateMachine
	{
		private static TaskPool<AsyncUniTaskVoid<TStateMachine>> pool;

		private TStateMachine stateMachine;

		private AsyncUniTaskVoid<TStateMachine> nextNode;

		public Action MoveNext { get; }

		public ref AsyncUniTaskVoid<TStateMachine> NextNode => ref nextNode;

		public AsyncUniTaskVoid()
		{
			MoveNext = Run;
		}

		public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunner runnerFieldRef)
		{
			if (!pool.TryPop(out var result))
			{
				result = new AsyncUniTaskVoid<TStateMachine>();
			}
			TaskTracker.TrackActiveTask(result, 3);
			runnerFieldRef = result;
			result.stateMachine = stateMachine;
		}

		static AsyncUniTaskVoid()
		{
			TaskPool.RegisterSizeGetter(typeof(AsyncUniTaskVoid<TStateMachine>), () => pool.Size);
		}

		public void Return()
		{
			TaskTracker.RemoveTracking(this);
			stateMachine = default(TStateMachine);
			pool.TryPush(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		private void Run()
		{
			stateMachine.MoveNext();
		}

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

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

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

		void IUniTaskSource.GetResult(short token)
		{
		}
	}
	internal sealed class AsyncUniTask<TStateMachine> : IStateMachineRunnerPromise, IUniTaskSource, ITaskPoolNode<AsyncUniTask<TStateMachine>> where TStateMachine : IAsyncStateMachine
	{
		private static TaskPool<AsyncUniTask<TStateMachine>> pool;

		private TStateMachine stateMachine;

		private UniTaskCompletionSourceCore<AsyncUnit> core;

		private AsyncUniTask<TStateMachine> nextNode;

		public Action MoveNext { get; }

		public ref AsyncUniTask<TStateMachine> NextNode => ref nextNode;

		public UniTask Task
		{
			[DebuggerHidden]
			get
			{
				return new UniTask(this, core.Version);
			}
		}

		private AsyncUniTask()
		{
			MoveNext = Run;
		}

		public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunnerPromise runnerPromiseFieldRef)
		{
			if (!pool.TryPop(out var result))
			{
				result = new AsyncUniTask<TStateMachine>();
			}
			TaskTracker.TrackActiveTask(result, 3);
			runnerPromiseFieldRef = result;
			result.stateMachine = stateMachine;
		}

		static AsyncUniTask()
		{
			TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine>), () => pool.Size);
		}

		private void Return()
		{
			TaskTracker.RemoveTracking(this);
			core.Reset();
			stateMachine = default(TStateMachine);
			pool.TryPush(this);
		}

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		private void Run()
		{
			stateMachine.MoveNext();
		}

		[DebuggerHidden]
		public void SetResult()
		{
			core.TrySetResult(AsyncUnit.Default);
		}

		[DebuggerHidden]
		public void SetException(Exception exception)
		{
			core.TrySetException(exception);
		}

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

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

		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			return core.UnsafeGetStatus();
		}

		[DebuggerHidden]
		public void OnCompleted(Action<object> continuation, object state, short token)
		{
			core.OnCompleted(continuation, state, token);
		}
	}
	internal sealed class AsyncUniTask<TStateMachine, T> : IStateMachineRunnerPromise<T>, IUniTaskSource<T>, IUniTaskSource, ITaskPoolNode<AsyncUniTask<TStateMachine, T>> where TStateMachine : IAsyncStateMachine
	{
		private static TaskPool<AsyncUniTask<TStateMachine, T>> pool;

		private TStateMachine stateMachine;

		private UniTaskCompletionSourceCore<T> core;

		private AsyncUniTask<TStateMachine, T> nextNode;

		public Action MoveNext { get; }

		public ref AsyncUniTask<TStateMachine, T> NextNode => ref nextNode;

		public UniTask<T> Task
		{
			[DebuggerHidden]
			get
			{
				return new UniTask<T>(this, core.Version);
			}
		}

		private AsyncUniTask()
		{
			MoveNext = Run;
		}

		public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunnerPromise<T> runnerPromiseFieldRef)
		{
			if (!pool.TryPop(out var result))
			{
				result = new AsyncUniTask<TStateMachine, T>();
			}
			TaskTracker.TrackActiveTask(result, 3);
			runnerPromiseFieldRef = result;
			result.stateMachine = stateMachine;
		}

		static AsyncUniTask()
		{
			TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine, T>), () => pool.Size);
		}

		private void Return()
		{
			TaskTracker.RemoveTracking(this);
			core.Reset();
			stateMachine = default(TStateMachine);
			pool.TryPush(this);
		}

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerHidden]
		private void Run()
		{
			stateMachine.MoveNext();
		}

		[DebuggerHidden]
		public void SetResult(T result)
		{
			core.TrySetResult(result);
		}

		[DebuggerHidden]
		public void SetException(Exception exception)
		{
			core.TrySetException(exception);
		}

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

		[DebuggerHidden]
		void IUniTaskSource.GetResult(short token)
		{
			GetResult(token);
		}

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

		[DebuggerHidden]
		public UniTaskStatus UnsafeGetStatus()
		{
			return core.UnsafeGetStatus();
		}

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