using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Sources;
using Cysharp.Threading.Tasks.CompilerServices;
using Cysharp.Threading.Tasks.Internal;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Cysharp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Cysharp, Inc.")]
[assembly: AssemblyDescription("Provides an efficient async/await integration to Unity and .NET Core.")]
[assembly: AssemblyFileVersion("2.5.10.0")]
[assembly: AssemblyInformationalVersion("2.5.10+7c0f199fe0d3fc528024488ccd671e6c7b27745b")]
[assembly: AssemblyProduct("UniTask")]
[assembly: AssemblyTitle("UniTask")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Cysharp/UniTask")]
[assembly: AssemblyVersion("2.5.10.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
{
	[StructLayout(LayoutKind.Auto)]
	[AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder))]
	public readonly struct UniTask
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public readonly struct YieldAwaitable
		{
			[StructLayout(LayoutKind.Sequential, Size = 1)]
			public readonly struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
			{
				private static readonly SendOrPostCallback SendOrPostCallbackDelegate = Continuation;

				private static readonly WaitCallback WaitCallbackDelegate = Continuation;

				public bool IsCompleted => false;

				public void GetResult()
				{
				}

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

				public void UnsafeOnCompleted(Action continuation)
				{
					SynchronizationContext current = SynchronizationContext.Current;
					if (current != null)
					{
						current.Post(SendOrPostCallbackDelegate, continuation);
					}
					else
					{
						ThreadPool.UnsafeQueueUserWorkItem(WaitCallbackDelegate, continuation);
					}
				}

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

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

		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 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 DeferPromiseWithState<TState> : IUniTaskSource
		{
			private Func<TState, UniTask> factory;

			private TState argument;

			private UniTask task;

			private Awaiter awaiter;

			public DeferPromiseWithState(TState argument, Func<TState, UniTask> factory)
			{
				this.argument = argument;
				this.factory = factory;
			}

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

			public UniTaskStatus GetStatus(short token)
			{
				Func<TState, UniTask> func = Interlocked.Exchange(ref factory, null);
				if (func != null)
				{
					task = func(argument);
					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 DeferPromiseWithState<TState, TResult> : IUniTaskSource<TResult>, IUniTaskSource
		{
			private Func<TState, UniTask<TResult>> factory;

			private TState argument;

			private UniTask<TResult> task;

			private UniTask<TResult>.Awaiter awaiter;

			public DeferPromiseWithState(TState argument, Func<TState, UniTask<TResult>> factory)
			{
				this.argument = argument;
				this.factory = factory;
			}

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

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

			public UniTaskStatus GetStatus(short token)
			{
				Func<TState, UniTask<TResult>> func = Interlocked.Exchange(ref factory, null);
				if (func != null)
				{
					task = func(argument);
					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 WhenAllPromise<T> : IUniTaskSource<T[]>, IUniTaskSource
		{
			private T[] result;

			private int completeCount;

			private UniTaskCompletionSourceCore<T[]> core;

			public WhenAllPromise(UniTask<T>[] tasks, int tasksLength)
			{
				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)
			{
				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)
			{
				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)
			{
				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 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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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 WhenAnyLRPromise<T> : IUniTaskSource<(bool, T)>, IUniTaskSource
		{
			private int completedCount;

			private UniTaskCompletionSourceCore<(bool, T)> core;

			public WhenAnyLRPromise(UniTask<T> leftTask, UniTask rightTask)
			{
				UniTask<T>.Awaiter awaiter;
				try
				{
					awaiter = leftTask.GetAwaiter();
				}
				catch (Exception error)
				{
					core.TrySetException(error);
					goto IL_0061;
				}
				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_0061;
				IL_0061:
				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)
			{
				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.");
				}
				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)
			{
				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.");
				}
				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)
			{
				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> : 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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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)
			{
				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 readonly IUniTaskSource source;

		private readonly short token;

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

		public static readonly UniTask CompletedTask = default(UniTask);

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

		public static async UniTask Run(Action action, bool configureAwait = true)
		{
			if (configureAwait)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				await SwitchToThreadPool();
				try
				{
					action();
				}
				finally
				{
					if (current != null)
					{
						await SwitchToSynchronizationContext(current);
					}
				}
			}
			else
			{
				await SwitchToThreadPool();
				action();
			}
		}

		public static async UniTask Run(Action<object> action, object state, bool configureAwait = true)
		{
			if (configureAwait)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				await SwitchToThreadPool();
				try
				{
					action(state);
				}
				finally
				{
					if (current != null)
					{
						await SwitchToSynchronizationContext(current);
					}
				}
			}
			else
			{
				await SwitchToThreadPool();
				action(state);
			}
		}

		public static async UniTask<T> Run<T>(Func<T> func, bool configureAwait = true)
		{
			if (configureAwait)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				await SwitchToThreadPool();
				T result;
				try
				{
					result = func();
				}
				finally
				{
					if (current != null)
					{
						await SwitchToSynchronizationContext(current);
					}
				}
				return result;
			}
			await SwitchToThreadPool();
			return func();
		}

		public static async UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true)
		{
			if (configureAwait)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				await SwitchToThreadPool();
				T result;
				try
				{
					result = func(state);
				}
				finally
				{
					if (current != null)
					{
						await SwitchToSynchronizationContext(current);
					}
				}
				return result;
			}
			await SwitchToThreadPool();
			return func(state);
		}

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

		[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 static implicit operator ValueTask(in UniTask self)
		{
			if (self.source == null)
			{
				return default(ValueTask);
			}
			return self.AsValueTask();
		}

		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 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 Create(Func<CancellationToken, UniTask> factory, CancellationToken cancellationToken)
		{
			return factory(cancellationToken);
		}

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

		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 Action Action<T>(T state, Func<T, UniTaskVoid> asyncAction)
		{
			return delegate
			{
				asyncAction(state).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 Defer<TState>(TState state, Func<TState, UniTask> factory)
		{
			return new UniTask(new DeferPromiseWithState<TState>(state, factory), 0);
		}

		public static UniTask<TResult> Defer<TState, TResult>(TState state, Func<TState, UniTask<TResult>> factory)
		{
			return new UniTask<TResult>(new DeferPromiseWithState<TState, TResult>(state, 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);
		}

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

		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 IUniTaskAsyncEnumerable<WhenEachResult<T>> WhenEach<T>(IEnumerable<UniTask<T>> tasks)
		{
			return new WhenEachEnumerable<T>(tasks);
		}

		public static IUniTaskAsyncEnumerable<WhenEachResult<T>> WhenEach<T>(params UniTask<T>[] tasks)
		{
			return new WhenEachEnumerable<T>(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);
				token = result.core.Version;
				return result;
			}

			private bool TryReturn()
			{
				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);
				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;
					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 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);
				token = result.core.Version;
				return result;
			}

			private bool TryReturn()
			{
				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);
				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;
					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 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;
			}

			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)
			{
				core.TrySetCanceled(cancellationToken);
			}

			public void SingalCompleted(Exception error)
			{
				if (error != null)
				{
					core.TrySetException(error);
				}
				else
				{
					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 ExceptionExtensions
	{
		public static bool IsOperationCanceledException(this Exception exception)
		{
			return exception is OperationCanceledException;
		}
	}
	public static class TaskTracker
	{
		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)
		{
		}

		[Conditional("UNITY_EDITOR")]
		public static void RemoveTracking(IUniTaskSource 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 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 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 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 ?? EqualityComparer<T>.Default);
		}
	}
	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 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 ITriggerHandler<T> iteratingNode;

		private void LogError(Exception ex)
		{
			Console.WriteLine(ex);
		}

		public void SetResult(T value)
		{
			if (iteratingNode != null)
			{
				throw new InvalidOperationException("Can not trigger itself in iterating.");
			}
			for (ITriggerHandler<T> triggerHandler = head; triggerHandler != null; triggerHandler = ((triggerHandler == iteratingNode) ? triggerHandler.Next : iteratingNode))
			{
				iteratingNode = triggerHandler;
				try
				{
					triggerHandler.OnNext(value);
				}
				catch (Exception ex)
				{
					LogError(ex);
					Remove(triggerHandler);
				}
			}
			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);
				}
				ITriggerHandler<T> obj = ((triggerHandler == iteratingNode) ? triggerHandler.Next : iteratingNode);
				iteratingNode = null;
				Remove(triggerHandler);
				triggerHandler = obj;
			}
			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);
				}
				ITriggerHandler<T> obj = ((triggerHandler == iteratingNode) ? triggerHandler.Next : iteratingNode);
				iteratingNode = null;
				Remove(triggerHandler);
				triggerHandler = obj;
			}
			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);
				}
				ITriggerHandler<T> obj = ((triggerHandler == iteratingNode) ? triggerHandler.Next : iteratingNode);
				iteratingNode = null;
				Remove(triggerHandler);
				triggerHandler = obj;
			}
			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");
			}
			ITriggerHandler<T> prev = handler.Prev;
			ITriggerHandler<T> next = handler.Next;
			if (next != null)
			{
				next.Prev = prev;
			}
			if (handler == head)
			{
				head = next;
			}
			else if (prev != null)
			{
				prev.Next = next;
			}
			if (handler == iteratingNode)
			{
				iteratingNode = next;
			}
			if (handler == iteratingHead)
			{
				iteratingHead = 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 UniTaskValueTaskExtensions
	{
		private class UniTaskValueTaskSource : IValueTaskSource
		{
			private readonly UniTask task;

			private readonly UniTask.Awaiter awaiter;

			public UniTaskValueTaskSource(UniTask task)
			{
				this.task = task;
				awaiter = task.GetAwaiter();
			}

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

			public ValueTaskSourceStatus GetStatus(short token)
			{
				return (ValueTaskSourceStatus)task.Status;
			}

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

		private class UniTaskValueTaskSource<T> : IValueTaskSource<T>
		{
			private readonly UniTask<T> task;

			private readonly UniTask<T>.Awaiter awaiter;

			public UniTaskValueTaskSource(UniTask<T> task)
			{
				this.task = task;
				awaiter = task.GetAwaiter();
			}

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

			public ValueTaskSourceStatus GetStatus(short token)
			{
				return (ValueTaskSourceStatus)task.Status;
			}

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

		public static ValueTask AsValueTask(this in UniTask task)
		{
			return new ValueTask(new UniTaskValueTaskSource(task), 0);
		}

		public static ValueTask<T> AsValueTask<T>(this in UniTask<T> task)
		{
			return new ValueTask<T>(new UniTaskValueTaskSource<T>(task), 0);
		}

		public static async UniTask<T> AsUniTask<T>(this ValueTask<T> task)
		{
			return await task;
		}

		public static async UniTask AsUniTask(this ValueTask task)
		{
			await task;
		}
	}
	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 static implicit operator ValueTask<T>(in UniTask<T> self)
		{
			if (self.source == null)
			{
				return new ValueTask<T>(self.result);
			}
			return UniTaskValueTaskExtensions.AsValueTask(in self);
		}

		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() + ")";
			}
			T val = result;
			if (val == null)
			{
				return null;
			}
			return val.ToString();
		}
	}
	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);
	}
	[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);
		}
	}
	public readonly struct WhenEachResult<T>
	{
		public T Result { get; }

		public Exception Exception { get; }

		public bool IsCompletedSuccessfully => Exception == null;

		public bool IsFaulted => Exception != null;

		public WhenEachResult(T result)
		{
			Result = result;
			Exception = null;
		}

		public WhenEachResult(Exception exception)
		{
			if (exception == null)
			{
				throw new ArgumentNullException("exception");
			}
			Result = default(T);
			Exception = exception;
		}

		public void TryThrow()
		{
			if (IsFaulted)
			{
				ExceptionDispatchInfo.Capture(Exception).Throw();
			}
		}

		public T GetResult()
		{
			if (IsFaulted)
			{
				ExceptionDispatchInfo.Capture(Exception).Throw();
			}
			return Result;
		}

		public override string ToString()
		{
			if (IsCompletedSuccessfully)
			{
				T result = Result;
				return ((result != null) ? result.ToString() : null) ?? "";
			}
			return "Exception{" + Exception.Message + "}";
		}
	}
	internal enum WhenEachState : byte
	{
		NotRunning,
		Running,
		Completed
	}
	internal sealed class WhenEachEnumerable<T> : IUniTaskAsyncEnumerable<WhenEachResult<T>>
	{
		private sealed class Enumerator : IUniTaskAsyncEnumerator<WhenEachResult<T>>, IUniTaskAsyncDisposable
		{
			private readonly IEnumerable<UniTask<T>> source;

			private CancellationToken cancellationToken;

			private Channel<WhenEachResult<T>> channel;

			private IUniTaskAsyncEnumerator<WhenEachResult<T>> channelEnumerator;

			private int completeCount;

			private WhenEachState state;

			public WhenEachResult<T> Current => channelEnumerator.Current;

			public Enumerator(IEnumerable<UniTask<T>> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (state == WhenEachState.NotRunning)
				{
					state = WhenEachState.Running;
					channel = Channel.CreateSingleConsumerUnbounded<WhenEachResult<T>>();
					channelEnumerator = channel.Reader.ReadAllAsync().GetAsyncEnumerator(cancellationToken);
					if (source is UniTask<T>[] array)
					{
						ConsumeAll(this, array, array.Length);
					}
					else
					{
						ArrayPoolUtil.RentArray<UniTask<T>> rentArray = ArrayPoolUtil.Materialize(source);
						try
						{
							ConsumeAll(this, rentArray.Array, rentArray.Length);
						}
						finally
						{
							((IDisposable)rentArray).Dispose();
						}
					}
				}
				return channelEnumerator.MoveNextAsync();
			}

			private static void ConsumeAll(Enumerator self, UniTask<T>[] array, int length)
			{
				for (int i = 0; i < length; i++)
				{
					RunWhenEachTask(self, array[i], length).Forget();
				}
			}

			private static async UniTaskVoid RunWhenEachTask(Enumerator self, UniTask<T> task, int length)
			{
				try
				{
					T result = await task;
					self.channel.Writer.TryWrite(new WhenEachResult<T>(result));
				}
				catch (Exception exception)
				{
					self.channel.Writer.TryWrite(new WhenEachResult<T>(exception));
				}
				if (Interlocked.Increment(ref self.completeCount) == length)
				{
					self.state = WhenEachState.Completed;
					self.channel.Writer.TryComplete();
				}
			}

			public async UniTask DisposeAsync()
			{
				if (channelEnumerator != null)
				{
					await channelEnumerator.DisposeAsync();
				}
				if (state != WhenEachState.Completed)
				{
					state = WhenEachState.Completed;
					channel.Writer.TryComplete(new OperationCanceledException());
				}
			}
		}

		private IEnumerable<UniTask<T>> source;

		public WhenEachEnumerable(IEnumerable<UniTask<T>> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<WhenEachResult<T>> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new Enumerator(source, cancellationToken);
		}
	}
	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;

		private short version;

		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();
			}
			result.version = result.core.Version;
			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()
		{
			if (version == core.Version)
			{
				return core.TrySetResult(AsyncUnit.Default);
			}
			return false;
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (version == core.Version)
			{
				return core.TrySetCanceled(cancellationToken);
			}
			return false;
		}

		[DebuggerHidden]
		public bool TrySetException(Exception exception)
		{
			if (version == core.Version)
			{
				return core.TrySetException(exception);
			}
			return false;
		}

		[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()
		{
			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;

		private short version;

		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>();
			}
			result.version = result.core.Version;
			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)
		{
			if (version == core.Version)
			{
				return core.TrySetResult(result);
			}
			return false;
		}

		[DebuggerHidden]
		public bool TrySetCanceled(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (version == core.Version)
			{
				return core.TrySetCanceled(cancellationToken);
			}
			return false;
		}

		[DebuggerHidden]
		public bool TrySetException(Exception exception)
		{
			if (version == core.Version)
			{
				return core.TrySetException(exception);
			}
			return false;
		}

		[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()
		{
			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);
			}
		}

		[DebuggerHidden]
		internal void MarkHandled()
		{
			if (!handled)
			{
				handled = true;
			}
		}

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

		[DebuggerHidden]
		internal void MarkHandled()
		{
			if (!handled)
			{
				handled = true;
			}
		}

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

		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.InnerException ?? 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.InnerException ?? 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)
			{
				task.Forget();
				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)
			{
				task.Forget();
				return UniTask.FromCanceled<T>(cancellationToken);
			}
			if (task.Status.IsCompleted())
			{
				return task;
			}
			return new UniTask<T>(new AttachExternalCancellationSource<T>(task, cancellationToken), 0);
		}

		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 obj)
			{
				try
				{
					_ = handleExceptionOnMainThread;
					exceptionHandler(obj);
				}
				catch (Exception ex)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex);
				}
			}
		}

		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 obj)
			{
				try
				{
					_ = handleExceptionOnMainThread;
					exceptionHandler(obj);
				}
				catch (Exception ex)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex);
				}
			}
		}

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

		public static event Action<Exception> UnobservedTaskException;

		internal static void PublishUnobservedTaskException(Exception ex)
		{
			if (ex != null && (PropagateOperationCanceledException || !(ex is OperationCanceledException)))
			{
				if (UniTaskScheduler.UnobservedTaskException != null)
				{
					UniTaskScheduler.UnobservedTaskException(ex);
				}
				else
				{
					Console.WriteLine("UnobservedTaskException: " + ex.ToString());
				}
			}
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	[AsyncMethodBuilder(typeof(AsyncUniTaskVoidMethodBuilder))]
	public readonly struct UniTaskVoid
	{
		public void Forget()
		{
		}
	}
}
namespace Cysharp.Threading.Tasks.Linq
{
	public static class UniTaskAsyncEnumerable
	{
		public static UniTask<TSource> AggregateAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			return Aggregate.AggregateAsync(source, accumulator, cancellationToken);
		}

		public static UniTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			return Aggregate.AggregateAsync(source, seed, accumulator, cancellationToken);
		}

		public static UniTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			Error.ThrowArgumentNullException(accumulator, "resultSelector");
			return Aggregate.AggregateAsync(source, seed, accumulator, resultSelector, cancellationToken);
		}

		public static UniTask<TSource> AggregateAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TSource, UniTask<TSource>> accumulator, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			return Aggregate.AggregateAwaitAsync(source, accumulator, cancellationToken);
		}

		public static UniTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, UniTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			return Aggregate.AggregateAwaitAsync(source, seed, accumulator, cancellationToken);
		}

		public static UniTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, UniTask<TAccumulate>> accumulator, Func<TAccumulate, UniTask<TResult>> resultSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			Error.ThrowArgumentNullException(accumulator, "resultSelector");
			return Aggregate.AggregateAwaitAsync(source, seed, accumulator, resultSelector, cancellationToken);
		}

		public static UniTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TSource, CancellationToken, UniTask<TSource>> accumulator, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			return Aggregate.AggregateAwaitWithCancellationAsync(source, accumulator, cancellationToken);
		}

		public static UniTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, UniTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			return Aggregate.AggregateAwaitWithCancellationAsync(source, seed, accumulator, cancellationToken);
		}

		public static UniTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, UniTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, UniTask<TResult>> resultSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(accumulator, "accumulator");
			Error.ThrowArgumentNullException(accumulator, "resultSelector");
			return Aggregate.AggregateAwaitWithCancellationAsync(source, seed, accumulator, resultSelector, cancellationToken);
		}

		public static UniTask<bool> AllAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return All.AllAsync(source, predicate, cancellationToken);
		}

		public static UniTask<bool> AllAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return All.AllAwaitAsync(source, predicate, cancellationToken);
		}

		public static UniTask<bool> AllAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return All.AllAwaitWithCancellationAsync(source, predicate, cancellationToken);
		}

		public static UniTask<bool> AnyAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Any.AnyAsync(source, cancellationToken);
		}

		public static UniTask<bool> AnyAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Any.AnyAsync(source, predicate, cancellationToken);
		}

		public static UniTask<bool> AnyAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Any.AnyAwaitAsync(source, predicate, cancellationToken);
		}

		public static UniTask<bool> AnyAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Any.AnyAwaitWithCancellationAsync(source, predicate, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<TSource> Append<TSource>(this IUniTaskAsyncEnumerable<TSource> source, TSource element)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new AppendPrepend<TSource>(source, element, append: true);
		}

		public static IUniTaskAsyncEnumerable<TSource> Prepend<TSource>(this IUniTaskAsyncEnumerable<TSource> source, TSource element)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new AppendPrepend<TSource>(source, element, append: false);
		}

		public static IUniTaskAsyncEnumerable<TSource> AsUniTaskAsyncEnumerable<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			return source;
		}

		public static UniTask<double> AverageAsync(this IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<double> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAsync(this IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<double> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> AverageAsync(this IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<float> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAsync(this IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<double> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> AverageAsync(this IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<decimal> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAsync(this IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<double?> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAsync(this IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<double?> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> AverageAsync(this IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<float?> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAsync(this IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<double?> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> AverageAsync(this IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Average.AverageAsync(source, cancellationToken);
		}

		public static UniTask<decimal?> AverageAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> AverageAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<IList<TSource>> Buffer<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			Error.ThrowArgumentNullException(source, "source");
			if (count <= 0)
			{
				throw Error.ArgumentOutOfRange("count");
			}
			return new Buffer<TSource>(source, count);
		}

		public static IUniTaskAsyncEnumerable<IList<TSource>> Buffer<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int count, int skip)
		{
			Error.ThrowArgumentNullException(source, "source");
			if (count <= 0)
			{
				throw Error.ArgumentOutOfRange("count");
			}
			if (skip <= 0)
			{
				throw Error.ArgumentOutOfRange("skip");
			}
			return new BufferSkip<TSource>(source, count, skip);
		}

		public static IUniTaskAsyncEnumerable<TResult> Cast<TResult>(this IUniTaskAsyncEnumerable<object> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Cast<TResult>(source);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, Func<T1, T2, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, TResult>(source1, source2, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, Func<T1, T2, T3, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, TResult>(source1, source2, source3, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, Func<T1, T2, T3, T4, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, TResult>(source1, source2, source3, source4, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, Func<T1, T2, T3, T4, T5, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, TResult>(source1, source2, source3, source4, source5, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, TResult>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, TResult>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(source10, "source10");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(source10, "source10");
			Error.ThrowArgumentNullException(source11, "source11");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(source10, "source10");
			Error.ThrowArgumentNullException(source11, "source11");
			Error.ThrowArgumentNullException(source12, "source12");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(source10, "source10");
			Error.ThrowArgumentNullException(source11, "source11");
			Error.ThrowArgumentNullException(source12, "source12");
			Error.ThrowArgumentNullException(source13, "source13");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, IUniTaskAsyncEnumerable<T14> source14, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(source10, "source10");
			Error.ThrowArgumentNullException(source11, "source11");
			Error.ThrowArgumentNullException(source12, "source12");
			Error.ThrowArgumentNullException(source13, "source13");
			Error.ThrowArgumentNullException(source14, "source14");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(this IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, IUniTaskAsyncEnumerable<T14> source14, IUniTaskAsyncEnumerable<T15> source15, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source1, "source1");
			Error.ThrowArgumentNullException(source2, "source2");
			Error.ThrowArgumentNullException(source3, "source3");
			Error.ThrowArgumentNullException(source4, "source4");
			Error.ThrowArgumentNullException(source5, "source5");
			Error.ThrowArgumentNullException(source6, "source6");
			Error.ThrowArgumentNullException(source7, "source7");
			Error.ThrowArgumentNullException(source8, "source8");
			Error.ThrowArgumentNullException(source9, "source9");
			Error.ThrowArgumentNullException(source10, "source10");
			Error.ThrowArgumentNullException(source11, "source11");
			Error.ThrowArgumentNullException(source12, "source12");
			Error.ThrowArgumentNullException(source13, "source13");
			Error.ThrowArgumentNullException(source14, "source14");
			Error.ThrowArgumentNullException(source15, "source15");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, source15, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TSource> Concat<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			return new Concat<TSource>(first, second);
		}

		public static UniTask<bool> ContainsAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, TSource value, CancellationToken cancellationToken = default(CancellationToken))
		{
			return source.ContainsAsync(value, EqualityComparer<TSource>.Default, cancellationToken);
		}

		public static UniTask<bool> ContainsAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return Contains.ContainsAsync(source, value, comparer, cancellationToken);
		}

		public static UniTask<int> CountAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Count.CountAsync(source, cancellationToken);
		}

		public static UniTask<int> CountAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Count.CountAsync(source, predicate, cancellationToken);
		}

		public static UniTask<int> CountAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Count.CountAwaitAsync(source, predicate, cancellationToken);
		}

		public static UniTask<int> CountAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Count.CountAwaitWithCancellationAsync(source, predicate, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<T> Create<T>(Func<IAsyncWriter<T>, CancellationToken, UniTask> create)
		{
			Error.ThrowArgumentNullException(create, "create");
			return new Create<T>(create);
		}

		public static IUniTaskAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new DefaultIfEmpty<TSource>(source, default(TSource));
		}

		public static IUniTaskAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this IUniTaskAsyncEnumerable<TSource> source, TSource defaultValue)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new DefaultIfEmpty<TSource>(source, defaultValue);
		}

		public static IUniTaskAsyncEnumerable<TSource> Distinct<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			return source.Distinct(EqualityComparer<TSource>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> Distinct<TSource>(this IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new Distinct<TSource>(source, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> Distinct<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return source.Distinct(keySelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> Distinct<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new Distinct<TSource, TKey>(source, keySelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			return source.DistinctAwait(keySelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new DistinctAwait<TSource, TKey>(source, keySelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			return source.DistinctAwaitWithCancellation(keySelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new DistinctAwaitWithCancellation<TSource, TKey>(source, keySelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			return source.DistinctUntilChanged(EqualityComparer<TSource>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new DistinctUntilChanged<TSource>(source, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return source.DistinctUntilChanged(keySelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new DistinctUntilChanged<TSource, TKey>(source, keySelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChangedAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			return source.DistinctUntilChangedAwait(keySelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChangedAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new DistinctUntilChangedAwait<TSource, TKey>(source, keySelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChangedAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			return source.DistinctUntilChangedAwaitWithCancellation(keySelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> DistinctUntilChangedAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new DistinctUntilChangedAwaitWithCancellation<TSource, TKey>(source, keySelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> Do<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext)
		{
			Error.ThrowArgumentNullException(source, "source");
			return source.Do(onNext, null, null);
		}

		public static IUniTaskAsyncEnumerable<TSource> Do<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError)
		{
			Error.ThrowArgumentNullException(source, "source");
			return source.Do(onNext, onError, null);
		}

		public static IUniTaskAsyncEnumerable<TSource> Do<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action onCompleted)
		{
			Error.ThrowArgumentNullException(source, "source");
			return source.Do(onNext, null, onCompleted);
		}

		public static IUniTaskAsyncEnumerable<TSource> Do<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Do<TSource>(source, onNext, onError, onCompleted);
		}

		public static IUniTaskAsyncEnumerable<TSource> Do<TSource>(this IUniTaskAsyncEnumerable<TSource> source, IObserver<TSource> observer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(observer, "observer");
			return source.Do(observer.OnNext, observer.OnError, observer.OnCompleted);
		}

		public static UniTask<TSource> ElementAtAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return ElementAt.ElementAtAsync(source, index, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> ElementAtOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return ElementAt.ElementAtAsync(source, index, cancellationToken, defaultIfEmpty: true);
		}

		public static IUniTaskAsyncEnumerable<T> Empty<T>()
		{
			return Cysharp.Threading.Tasks.Linq.Empty<T>.Instance;
		}

		public static IUniTaskAsyncEnumerable<TSource> Except<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			return new Except<TSource>(first, second, EqualityComparer<TSource>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> Except<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new Except<TSource>(first, second, comparer);
		}

		public static UniTask<TSource> FirstAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return First.FirstAsync(source, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> FirstAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return First.FirstAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> FirstAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return First.FirstAwaitAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return First.FirstAwaitWithCancellationAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> FirstOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return First.FirstAsync(source, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> FirstOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return First.FirstAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> FirstOrDefaultAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return First.FirstAwaitAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return First.FirstAwaitWithCancellationAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask ForEachAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			return ForEach.ForEachAsync(source, action, cancellationToken);
		}

		public static UniTask ForEachAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource, int> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			return ForEach.ForEachAsync(source, action, cancellationToken);
		}

		[Obsolete("Use ForEachAwaitAsync instead.", true)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static UniTask ForEachAsync<T>(this IUniTaskAsyncEnumerable<T> source, Func<T, UniTask> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			throw new NotSupportedException("Use ForEachAwaitAsync instead.");
		}

		[Obsolete("Use ForEachAwaitAsync instead.", true)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static UniTask ForEachAsync<T>(this IUniTaskAsyncEnumerable<T> source, Func<T, int, UniTask> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			throw new NotSupportedException("Use ForEachAwaitAsync instead.");
		}

		public static UniTask ForEachAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			return ForEach.ForEachAwaitAsync(source, action, cancellationToken);
		}

		public static UniTask ForEachAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			return ForEach.ForEachAwaitAsync(source, action, cancellationToken);
		}

		public static UniTask ForEachAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			return ForEach.ForEachAwaitWithCancellationAsync(source, action, cancellationToken);
		}

		public static UniTask ForEachAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask> action, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			return ForEach.ForEachAwaitWithCancellationAsync(source, action, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new GroupBy<TSource, TKey, TSource>(source, keySelector, (TSource x) => x, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupBy<TSource, TKey, TSource>(source, keySelector, (TSource x) => x, comparer);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return new GroupBy<TSource, TKey, TElement>(source, keySelector, elementSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupBy<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupBy<TSource, TKey, TSource, TResult>(source, keySelector, (TSource x) => x, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupBy<TSource, TKey, TSource, TResult>(source, keySelector, (TSource x) => x, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupBy<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupBy<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new GroupByAwait<TSource, TKey, TSource>(source, keySelector, (TSource x) => UniTask.FromResult(x), EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwait<TSource, TKey, TSource>(source, keySelector, (TSource x) => UniTask.FromResult(x), comparer);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return new GroupByAwait<TSource, TKey, TElement>(source, keySelector, elementSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwait<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TKey, IEnumerable<TSource>, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupByAwait<TSource, TKey, TSource, TResult>(source, keySelector, (TSource x) => UniTask.FromResult(x), resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupByAwait<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TKey, IEnumerable<TSource>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwait<TSource, TKey, TSource, TResult>(source, keySelector, (TSource x) => UniTask.FromResult(x), resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwait<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new GroupByAwaitWithCancellation<TSource, TKey, TSource>(source, keySelector, (TSource x, CancellationToken _) => UniTask.FromResult(x), EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwaitWithCancellation<TSource, TKey, TSource>(source, keySelector, (TSource x, CancellationToken _) => UniTask.FromResult(x), comparer);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return new GroupByAwaitWithCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwaitWithCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TKey, IEnumerable<TSource>, CancellationToken, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupByAwaitWithCancellation<TSource, TKey, TSource, TResult>(source, keySelector, (TSource x, CancellationToken _) => UniTask.FromResult(x), resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, CancellationToken, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TKey, IEnumerable<TSource>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwaitWithCancellation<TSource, TKey, TSource, TResult>(source, keySelector, (TSource x, CancellationToken _) => UniTask.FromResult(x), resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupJoin<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupJoin<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupJoinAwait<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupJoinAwait<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, CancellationToken, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> Intersect<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			return new Intersect<TSource>(first, second, EqualityComparer<TSource>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> Intersect<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new Intersect<TSource>(first, second, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new Join<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new Join<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new JoinAwait<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new JoinAwait<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
		}

		public static IUniTaskAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer<TKey>.Default);
		}

		public static IUniTaskAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(outer, "outer");
			Error.ThrowArgumentNullException(inner, "inner");
			Error.ThrowArgumentNullException(outerKeySelector, "outerKeySelector");
			Error.ThrowArgumentNullException(innerKeySelector, "innerKeySelector");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
		}

		public static UniTask<TSource> LastAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Last.LastAsync(source, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> LastAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Last.LastAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> LastAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Last.LastAwaitAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> LastAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Last.LastAwaitWithCancellationAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> LastOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Last.LastAsync(source, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> LastOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Last.LastAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> LastOrDefaultAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Last.LastAwaitAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> LastOrDefaultAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return Last.LastAwaitWithCancellationAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<long> LongCountAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return LongCount.LongCountAsync(source, cancellationToken);
		}

		public static UniTask<long> LongCountAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return LongCount.LongCountAsync(source, predicate, cancellationToken);
		}

		public static UniTask<long> LongCountAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return LongCount.LongCountAwaitAsync(source, predicate, cancellationToken);
		}

		public static UniTask<long> LongCountAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return LongCount.LongCountAwaitWithCancellationAsync(source, predicate, cancellationToken);
		}

		public static UniTask<TSource> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<TResult> MaxAsync<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<TResult> MaxAwaitAsync<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<T> Merge<T>(this IUniTaskAsyncEnumerable<T> first, IUniTaskAsyncEnumerable<T> second)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			return new Merge<T>(new IUniTaskAsyncEnumerable<T>[2] { first, second });
		}

		public static IUniTaskAsyncEnumerable<T> Merge<T>(this IUniTaskAsyncEnumerable<T> first, IUniTaskAsyncEnumerable<T> second, IUniTaskAsyncEnumerable<T> third)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(third, "third");
			return new Merge<T>(new IUniTaskAsyncEnumerable<T>[3] { first, second, third });
		}

		public static IUniTaskAsyncEnumerable<T> Merge<T>(this IEnumerable<IUniTaskAsyncEnumerable<T>> sources)
		{
			if (!(sources is IUniTaskAsyncEnumerable<T>[] sources2))
			{
				return new Merge<T>(sources.ToArray());
			}
			return new Merge<T>(sources2);
		}

		public static IUniTaskAsyncEnumerable<T> Merge<T>(params IUniTaskAsyncEnumerable<T>[] sources)
		{
			return new Merge<T>(sources);
		}

		public static UniTask<TSource> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<TResult> MinAsync<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<TResult> MinAwaitAsync<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> MinAsync(this IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<int> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> MinAsync(this IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<long> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> MinAsync(this IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<float> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> MinAsync(this IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<double> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> MinAsync(this IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<decimal> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> MinAsync(this IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<int?> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> MinAsync(this IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<long?> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> MinAsync(this IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<float?> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> MinAsync(this IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<double?> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> MinAsync(this IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Min.MinAsync(source, cancellationToken);
		}

		public static UniTask<decimal?> MinAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> MinAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> MaxAsync(this IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<int> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> MaxAsync(this IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<long> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> MaxAsync(this IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<float> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> MaxAsync(this IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<double> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> MaxAsync(this IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<decimal> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> MaxAsync(this IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<int?> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> MaxAsync(this IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<long?> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> MaxAsync(this IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<float?> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> MaxAsync(this IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<double?> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> MaxAsync(this IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Max.MaxAsync(source, cancellationToken);
		}

		public static UniTask<decimal?> MaxAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> MaxAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<T> Never<T>()
		{
			return Cysharp.Threading.Tasks.Linq.Never<T>.Instance;
		}

		public static IUniTaskAsyncEnumerable<TResult> OfType<TResult>(this IUniTaskAsyncEnumerable<object> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new OfType<TResult>(source);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, Comparer<TKey>.Default, descending: false, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer, descending: false, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new OrderedAsyncEnumerableAwait<TSource, TKey>(source, keySelector, Comparer<TKey>.Default, descending: false, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new OrderedAsyncEnumerableAwait<TSource, TKey>(source, keySelector, comparer, descending: false, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new OrderedAsyncEnumerableAwaitWithCancellation<TSource, TKey>(source, keySelector, Comparer<TKey>.Default, descending: false, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new OrderedAsyncEnumerableAwaitWithCancellation<TSource, TKey>(source, keySelector, comparer, descending: false, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, Comparer<TKey>.Default, descending: true, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer, descending: true, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new OrderedAsyncEnumerableAwait<TSource, TKey>(source, keySelector, Comparer<TKey>.Default, descending: true, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new OrderedAsyncEnumerableAwait<TSource, TKey>(source, keySelector, comparer, descending: true, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return new OrderedAsyncEnumerableAwaitWithCancellation<TSource, TKey>(source, keySelector, Comparer<TKey>.Default, descending: true, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return new OrderedAsyncEnumerableAwaitWithCancellation<TSource, TKey>(source, keySelector, comparer, descending: true, null);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return source.CreateOrderedEnumerable(keySelector, Comparer<TKey>.Default, descending: false);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return source.CreateOrderedEnumerable(keySelector, comparer, descending: false);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return source.CreateOrderedEnumerable(keySelector, Comparer<TKey>.Default, descending: false);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return source.CreateOrderedEnumerable(keySelector, comparer, descending: false);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return source.CreateOrderedEnumerable(keySelector, Comparer<TKey>.Default, descending: false);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return source.CreateOrderedEnumerable(keySelector, comparer, descending: false);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return source.CreateOrderedEnumerable(keySelector, Comparer<TKey>.Default, descending: true);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return source.CreateOrderedEnumerable(keySelector, comparer, descending: true);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return source.CreateOrderedEnumerable(keySelector, Comparer<TKey>.Default, descending: true);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return source.CreateOrderedEnumerable(keySelector, comparer, descending: true);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return source.CreateOrderedEnumerable(keySelector, Comparer<TKey>.Default, descending: true);
		}

		public static IUniTaskOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this IUniTaskOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return source.CreateOrderedEnumerable(keySelector, comparer, descending: true);
		}

		public static IUniTaskAsyncEnumerable<(TSource, TSource)> Pairwise<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Pairwise<TSource>(source);
		}

		public static IConnectableUniTaskAsyncEnumerable<TSource> Publish<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Publish<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TSource> Queue<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			return new QueueOperator<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<int> Range(int start, int count)
		{
			if (count < 0)
			{
				throw Error.ArgumentOutOfRange("count");
			}
			if ((long)start + (long)count - 1 > int.MaxValue)
			{
				throw Error.ArgumentOutOfRange("count");
			}
			if (count == 0)
			{
				Empty<int>();
			}
			return new Range(start, count);
		}

		public static IUniTaskAsyncEnumerable<TElement> Repeat<TElement>(TElement element, int count)
		{
			if (count < 0)
			{
				throw Error.ArgumentOutOfRange("count");
			}
			return new Repeat<TElement>(element, count);
		}

		public static IUniTaskAsyncEnumerable<TValue> Return<TValue>(TValue value)
		{
			return new Return<TValue>(value);
		}

		public static IUniTaskAsyncEnumerable<TSource> Reverse<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Reverse<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TResult> Select<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new Select<TSource, TResult>(source, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> Select<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectInt<TSource, TResult>(source, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectAwait<TSource, TResult>(source, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<TResult>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectIntAwait<TSource, TResult>(source, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectAwaitWithCancellation<TSource, TResult>(source, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<TResult>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectIntAwaitWithCancellation<TSource, TResult>(source, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, IUniTaskAsyncEnumerable<TResult>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectMany<TSource, TResult, TResult>(source, selector, (TSource x, TResult y) => y);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, IUniTaskAsyncEnumerable<TResult>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectMany<TSource, TResult, TResult>(source, selector, (TSource x, TResult y) => y);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, IUniTaskAsyncEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(collectionSelector, "collectionSelector");
			return new SelectMany<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, IUniTaskAsyncEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(collectionSelector, "collectionSelector");
			return new SelectMany<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<IUniTaskAsyncEnumerable<TResult>>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectManyAwait<TSource, TResult, TResult>(source, selector, (TSource x, TResult y) => UniTask.FromResult(y));
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<IUniTaskAsyncEnumerable<TResult>>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectManyAwait<TSource, TResult, TResult>(source, selector, (TSource x, TResult y) => UniTask.FromResult(y));
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<IUniTaskAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(collectionSelector, "collectionSelector");
			return new SelectManyAwait<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<IUniTaskAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(collectionSelector, "collectionSelector");
			return new SelectManyAwait<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TResult>>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectManyAwaitWithCancellation<TSource, TResult, TResult>(source, selector, (TSource x, TResult y, CancellationToken c) => UniTask.FromResult(y));
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TResult>>> selector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(selector, "selector");
			return new SelectManyAwaitWithCancellation<TSource, TResult, TResult>(source, selector, (TSource x, TResult y, CancellationToken c) => UniTask.FromResult(y));
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(collectionSelector, "collectionSelector");
			return new SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(collectionSelector, "collectionSelector");
			return new SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(source, collectionSelector, resultSelector);
		}

		public static UniTask<bool> SequenceEqualAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, CancellationToken cancellationToken = default(CancellationToken))
		{
			return first.SequenceEqualAsync(second, EqualityComparer<TSource>.Default, cancellationToken);
		}

		public static UniTask<bool> SequenceEqualAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return SequenceEqual.SequenceEqualAsync(first, second, comparer, cancellationToken);
		}

		public static UniTask<TSource> SingleAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return SingleOperator.SingleAsync(source, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> SingleAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return SingleOperator.SingleAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> SingleAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return SingleOperator.SingleAwaitAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return SingleOperator.SingleAwaitWithCancellationAsync(source, predicate, cancellationToken, defaultIfEmpty: false);
		}

		public static UniTask<TSource> SingleOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return SingleOperator.SingleAsync(source, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> SingleOrDefaultAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return SingleOperator.SingleAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> SingleOrDefaultAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return SingleOperator.SingleAwaitAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static UniTask<TSource> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return SingleOperator.SingleAwaitWithCancellationAsync(source, predicate, cancellationToken, defaultIfEmpty: true);
		}

		public static IUniTaskAsyncEnumerable<TSource> Skip<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Skip<TSource>(source, count);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipLast<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			Error.ThrowArgumentNullException(source, "source");
			if (count <= 0)
			{
				return source;
			}
			return new SkipLast<TSource>(source, count);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, UniTask other)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new SkipUntil<TSource>(source, other, null);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<CancellationToken, UniTask> other)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "other");
			return new SkipUntil<TSource>(source, default(UniTask), other);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipUntilCanceled<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new SkipUntilCanceled<TSource>(source, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipWhile<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new SkipWhile<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipWhile<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new SkipWhileInt<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new SkipWhileAwait<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new SkipWhileIntAwait<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new SkipWhileAwaitWithCancellation<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new SkipWhileIntAwaitWithCancellation<TSource>(source, predicate);
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> action)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, action, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> action)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, action, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTaskVoid> action)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, action, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> action, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, action, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> action, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, action, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTaskVoid> action, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(action, "action");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, action, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static IDisposable SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static IDisposable SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> onNext, Action<Exception> onError)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> onNext, Action<Exception> onError, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static IDisposable SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext, Action<Exception> onError)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext, Action<Exception> onError, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static IDisposable SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext, Action<Exception> onError)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext, Action<Exception> onError, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onError, "onError");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, onError, Cysharp.Threading.Tasks.Linq.Subscribe.NopCompleted, cancellationToken).Forget();
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action onCompleted)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> onNext, Action onCompleted)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action onCompleted, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationToken).Forget();
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> onNext, Action onCompleted, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationToken).Forget();
		}

		public static IDisposable SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext, Action onCompleted)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext, Action onCompleted, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationToken).Forget();
		}

		public static IDisposable SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext, Action onCompleted)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void SubscribeAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext, Action onCompleted, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(onNext, "onNext");
			Error.ThrowArgumentNullException(onCompleted, "onCompleted");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeAwaitCore(source, onNext, Cysharp.Threading.Tasks.Linq.Subscribe.NopError, onCompleted, cancellationToken).Forget();
		}

		public static IDisposable Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, IObserver<TSource> observer)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(observer, "observer");
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, observer, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		public static void Subscribe<TSource>(this IUniTaskAsyncEnumerable<TSource> source, IObserver<TSource> observer, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(observer, "observer");
			Cysharp.Threading.Tasks.Linq.Subscribe.SubscribeCore(source, observer, cancellationToken).Forget();
		}

		public static UniTask<int> SumAsync(this IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<int> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<int> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> SumAsync(this IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<long> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<long> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> SumAsync(this IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<float> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> SumAsync(this IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<double> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> SumAsync(this IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<decimal> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> SumAsync(this IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<int?> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<int?> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> SumAsync(this IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<long?> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<long?> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> SumAsync(this IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<float?> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<float?> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> SumAsync(this IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<double?> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<double?> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> SumAsync(this IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return Sum.SumAsync(source, cancellationToken);
		}

		public static UniTask<decimal?> SumAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> SumAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitAsync(source, selector, cancellationToken);
		}

		public static UniTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "selector");
			return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<TSource> Take<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new Take<TSource>(source, count);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeLast<TSource>(this IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			Error.ThrowArgumentNullException(source, "source");
			if (count <= 0)
			{
				return Empty<TSource>();
			}
			return new TakeLast<TSource>(source, count);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, UniTask other)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new TakeUntil<TSource>(source, other, null);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<CancellationToken, UniTask> other)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(source, "other");
			return new TakeUntil<TSource>(source, default(UniTask), other);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeUntilCanceled<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new TakeUntilCanceled<TSource>(source, cancellationToken);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeWhile<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new TakeWhile<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeWhile<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new TakeWhileInt<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new TakeWhileAwait<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new TakeWhileIntAwait<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new TakeWhileAwaitWithCancellation<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new TakeWhileIntAwaitWithCancellation<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TValue> Throw<TValue>(Exception exception)
		{
			return new Throw<TValue>(exception);
		}

		public static UniTask<TSource[]> ToArrayAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return ToArray.ToArrayAsync(source, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return ToDictionary.ToDictionaryAsync(source, keySelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToDictionary.ToDictionaryAsync(source, keySelector, comparer, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return ToDictionary.ToDictionaryAsync(source, keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToDictionary.ToDictionaryAsync(source, keySelector, elementSelector, comparer, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, comparer, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, elementSelector, comparer, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, comparer, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, elementSelector, comparer, cancellationToken);
		}

		public static UniTask<HashSet<TSource>> ToHashSetAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return ToHashSet.ToHashSetAsync(source, EqualityComparer<TSource>.Default, cancellationToken);
		}

		public static UniTask<HashSet<TSource>> ToHashSetAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToHashSet.ToHashSetAsync(source, comparer, cancellationToken);
		}

		public static UniTask<List<TSource>> ToListAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			return ToList.ToListAsync(source, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return ToLookup.ToLookupAsync(source, keySelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToLookup.ToLookupAsync(source, keySelector, comparer, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return ToLookup.ToLookupAsync(source, keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToLookup.ToLookupAsync(source, keySelector, elementSelector, comparer, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return ToLookup.ToLookupAwaitAsync(source, keySelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToLookup.ToLookupAwaitAsync(source, keySelector, comparer, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return ToLookup.ToLookupAwaitAsync(source, keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToLookup.ToLookupAwaitAsync(source, keySelector, elementSelector, comparer, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, comparer, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, elementSelector, EqualityComparer<TKey>.Default, cancellationToken);
		}

		public static UniTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default(CancellationToken))
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(keySelector, "keySelector");
			Error.ThrowArgumentNullException(elementSelector, "elementSelector");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, elementSelector, comparer, cancellationToken);
		}

		public static IObservable<TSource> ToObservable<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new ToObservable<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TSource> ToUniTaskAsyncEnumerable<TSource>(this IEnumerable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new ToUniTaskAsyncEnumerable<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TSource> ToUniTaskAsyncEnumerable<TSource>(this Task<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new ToUniTaskAsyncEnumerableTask<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TSource> ToUniTaskAsyncEnumerable<TSource>(this UniTask<TSource> source)
		{
			return new ToUniTaskAsyncEnumerableUniTask<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TSource> ToUniTaskAsyncEnumerable<TSource>(this IObservable<TSource> source)
		{
			Error.ThrowArgumentNullException(source, "source");
			return new ToUniTaskAsyncEnumerableObservable<TSource>(source);
		}

		public static IUniTaskAsyncEnumerable<TSource> Union<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			return first.Union(second, EqualityComparer<TSource>.Default);
		}

		public static IUniTaskAsyncEnumerable<TSource> Union<TSource>(this IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(comparer, "comparer");
			return first.Concat(second).Distinct(comparer);
		}

		public static IUniTaskAsyncEnumerable<TSource> Where<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new Where<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> Where<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new WhereInt<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> WhereAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new WhereAwait<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> WhereAwait<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new WhereIntAwait<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new WhereAwaitWithCancellation<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate)
		{
			Error.ThrowArgumentNullException(source, "source");
			Error.ThrowArgumentNullException(predicate, "predicate");
			return new WhereIntAwaitWithCancellation<TSource>(source, predicate);
		}

		public static IUniTaskAsyncEnumerable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			return first.Zip(second, (TFirst x, TSecond y) => (x, y));
		}

		public static IUniTaskAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(resultSelector, "resultSelector");
			return new Zip<TFirst, TSecond, TResult>(first, second, resultSelector);
		}

		public static IUniTaskAsyncEnumerable<TResult> ZipAwait<TFirst, TSecond, TResult>(this IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, UniTask<TResult>> selector)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(selector, "selector");
			return new ZipAwait<TFirst, TSecond, TResult>(first, second, selector);
		}

		public static IUniTaskAsyncEnumerable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, CancellationToken, UniTask<TResult>> selector)
		{
			Error.ThrowArgumentNullException(first, "first");
			Error.ThrowArgumentNullException(second, "second");
			Error.ThrowArgumentNullException(selector, "selector");
			return new ZipAwaitWithCancellation<TFirst, TSecond, TResult>(first, second, selector);
		}
	}
	internal static class Aggregate
	{
		internal static async UniTask<TSource> AggregateAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				TSource value = e.Current;
				while (await e.MoveNextAsync())
				{
					value = accumulator(value, e.Current);
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TAccumulate result;
			try
			{
				TAccumulate value = seed;
				while (await e.MoveNextAsync())
				{
					value = accumulator(value, e.Current);
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				TAccumulate value = seed;
				while (await e.MoveNextAsync())
				{
					value = accumulator(value, e.Current);
				}
				result = resultSelector(value);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TSource> AggregateAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TSource, UniTask<TSource>> accumulator, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				TSource value = e.Current;
				while (await e.MoveNextAsync())
				{
					value = await accumulator(value, e.Current);
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, UniTask<TAccumulate>> accumulator, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TAccumulate result;
			try
			{
				TAccumulate value = seed;
				while (await e.MoveNextAsync())
				{
					value = await accumulator(value, e.Current);
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, UniTask<TAccumulate>> accumulator, Func<TAccumulate, UniTask<TResult>> resultSelector, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				TAccumulate value = seed;
				while (await e.MoveNextAsync())
				{
					value = await accumulator(value, e.Current);
				}
				result = await resultSelector(value);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TSource, CancellationToken, UniTask<TSource>> accumulator, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				TSource value = e.Current;
				while (await e.MoveNextAsync())
				{
					value = await accumulator(value, e.Current, cancellationToken);
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, UniTask<TAccumulate>> accumulator, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TAccumulate result;
			try
			{
				TAccumulate value = seed;
				while (await e.MoveNextAsync())
				{
					value = await accumulator(value, e.Current, cancellationToken);
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(IUniTaskAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, UniTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, UniTask<TResult>> resultSelector, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				TAccumulate value = seed;
				while (await e.MoveNextAsync())
				{
					value = await accumulator(value, e.Current, cancellationToken);
				}
				result = await resultSelector(value, cancellationToken);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class All
	{
		internal static async UniTask<bool> AllAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (!predicate(e.Current))
						{
							result = false;
							break;
						}
						continue;
					}
					result = true;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<bool> AllAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (!(await predicate(e.Current)))
						{
							result = false;
							break;
						}
						continue;
					}
					result = true;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<bool> AllAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (!(await predicate(e.Current, cancellationToken)))
						{
							result = false;
							break;
						}
						continue;
					}
					result = true;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class Any
	{
		internal static async UniTask<bool> AnyAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				result = ((await e.MoveNextAsync()) ? true : false);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<bool> AnyAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (predicate(e.Current))
						{
							result = true;
							break;
						}
						continue;
					}
					result = false;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<bool> AnyAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (await predicate(e.Current))
						{
							result = true;
							break;
						}
						continue;
					}
					result = false;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<bool> AnyAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (await predicate(e.Current, cancellationToken))
						{
							result = true;
							break;
						}
						continue;
					}
					result = false;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal sealed class AppendPrepend<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _AppendPrepend : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private enum State : byte
			{
				None,
				RequirePrepend,
				RequireAppend,
				Completed
			}

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly TSource element;

			private CancellationToken cancellationToken;

			private State state;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TSource Current { get; private set; }

			public _AppendPrepend(IUniTaskAsyncEnumerable<TSource> source, TSource element, bool append, CancellationToken cancellationToken)
			{
				this.source = source;
				this.element = element;
				state = ((!append) ? State.RequirePrepend : State.RequireAppend);
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (enumerator == null)
				{
					if (state == State.RequirePrepend)
					{
						Current = element;
						state = State.None;
						return CompletedTasks.True;
					}
					enumerator = source.GetAsyncEnumerator(cancellationToken);
				}
				if (state == State.Completed)
				{
					return CompletedTasks.False;
				}
				awaiter = enumerator.MoveNextAsync().GetAwaiter();
				if (awaiter.IsCompleted)
				{
					MoveNextCoreDelegate(this);
				}
				else
				{
					awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void MoveNextCore(object state)
			{
				_AppendPrepend appendPrepend = (_AppendPrepend)state;
				if (appendPrepend.TryGetResult(appendPrepend.awaiter, out var result))
				{
					if (result)
					{
						appendPrepend.Current = appendPrepend.enumerator.Current;
						appendPrepend.completionSource.TrySetResult(result: true);
					}
					else if (appendPrepend.state == State.RequireAppend)
					{
						appendPrepend.state = State.Completed;
						appendPrepend.Current = appendPrepend.element;
						appendPrepend.completionSource.TrySetResult(result: true);
					}
					else
					{
						appendPrepend.state = State.Completed;
						appendPrepend.completionSource.TrySetResult(result: false);
					}
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly TSource element;

		private readonly bool append;

		public AppendPrepend(IUniTaskAsyncEnumerable<TSource> source, TSource element, bool append)
		{
			this.source = source;
			this.element = element;
			this.append = append;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _AppendPrepend(source, element, append, cancellationToken);
		}
	}
	internal abstract class AsyncEnumeratorBase<TSource, TResult> : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
	{
		private static readonly Action<object> moveNextCallbackDelegate = MoveNextCallBack;

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		protected CancellationToken cancellationToken;

		private IUniTaskAsyncEnumerator<TSource> enumerator;

		private UniTask<bool>.Awaiter sourceMoveNext;

		protected TSource SourceCurrent => enumerator.Current;

		public TResult Current { get; protected set; }

		public AsyncEnumeratorBase(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			this.source = source;
			this.cancellationToken = cancellationToken;
		}

		protected abstract bool TryMoveNextCore(bool sourceHasCurrent, out bool result);

		public UniTask<bool> MoveNextAsync()
		{
			if (enumerator == null)
			{
				enumerator = source.GetAsyncEnumerator(cancellationToken);
			}
			completionSource.Reset();
			if (!OnFirstIteration())
			{
				SourceMoveNext();
			}
			return new UniTask<bool>(this, completionSource.Version);
		}

		protected virtual bool OnFirstIteration()
		{
			return false;
		}

		protected void SourceMoveNext()
		{
			while (true)
			{
				sourceMoveNext = enumerator.MoveNextAsync().GetAwaiter();
				if (!sourceMoveNext.IsCompleted)
				{
					break;
				}
				bool result = false;
				try
				{
					if (!TryMoveNextCore(sourceMoveNext.GetResult(), out result))
					{
						continue;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (cancellationToken.IsCancellationRequested)
				{
					completionSource.TrySetCanceled(cancellationToken);
				}
				else
				{
					completionSource.TrySetResult(result);
				}
				return;
			}
			sourceMoveNext.SourceOnCompleted(moveNextCallbackDelegate, this);
		}

		private static void MoveNextCallBack(object state)
		{
			AsyncEnumeratorBase<TSource, TResult> asyncEnumeratorBase = (AsyncEnumeratorBase<TSource, TResult>)state;
			bool result;
			try
			{
				if (!asyncEnumeratorBase.TryMoveNextCore(asyncEnumeratorBase.sourceMoveNext.GetResult(), out result))
				{
					asyncEnumeratorBase.SourceMoveNext();
					return;
				}
			}
			catch (Exception error)
			{
				asyncEnumeratorBase.completionSource.TrySetException(error);
				return;
			}
			if (asyncEnumeratorBase.cancellationToken.IsCancellationRequested)
			{
				asyncEnumeratorBase.completionSource.TrySetCanceled(asyncEnumeratorBase.cancellationToken);
			}
			else
			{
				asyncEnumeratorBase.completionSource.TrySetResult(result);
			}
		}

		public virtual UniTask DisposeAsync()
		{
			if (enumerator != null)
			{
				return enumerator.DisposeAsync();
			}
			return default(UniTask);
		}
	}
	internal abstract class AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait> : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
	{
		private static readonly Action<object> moveNextCallbackDelegate = MoveNextCallBack;

		private static readonly Action<object> setCurrentCallbackDelegate = SetCurrentCallBack;

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		protected CancellationToken cancellationToken;

		private IUniTaskAsyncEnumerator<TSource> enumerator;

		private UniTask<bool>.Awaiter sourceMoveNext;

		private UniTask<TAwait>.Awaiter resultAwaiter;

		protected TSource SourceCurrent { get; private set; }

		public TResult Current { get; protected set; }

		public AsyncEnumeratorAwaitSelectorBase(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			this.source = source;
			this.cancellationToken = cancellationToken;
		}

		protected abstract UniTask<TAwait> TransformAsync(TSource sourceCurrent);

		protected abstract bool TrySetCurrentCore(TAwait awaitResult, out bool terminateIteration);

		protected (bool waitCallback, bool requireNextIteration) ActionCompleted(bool trySetCurrentResult, out bool moveNextResult)
		{
			if (trySetCurrentResult)
			{
				moveNextResult = true;
				return (false, false);
			}
			moveNextResult = false;
			return (false, true);
		}

		protected (bool waitCallback, bool requireNextIteration) WaitAwaitCallback(out bool moveNextResult)
		{
			moveNextResult = false;
			return (true, false);
		}

		protected (bool waitCallback, bool requireNextIteration) IterateFinished(out bool moveNextResult)
		{
			moveNextResult = false;
			return (false, false);
		}

		public UniTask<bool> MoveNextAsync()
		{
			if (enumerator == null)
			{
				enumerator = source.GetAsyncEnumerator(cancellationToken);
			}
			completionSource.Reset();
			SourceMoveNext();
			return new UniTask<bool>(this, completionSource.Version);
		}

		protected void SourceMoveNext()
		{
			while (true)
			{
				sourceMoveNext = enumerator.MoveNextAsync().GetAwaiter();
				if (!sourceMoveNext.IsCompleted)
				{
					break;
				}
				bool result = false;
				try
				{
					var (flag, flag2) = TryMoveNextCore(sourceMoveNext.GetResult(), out result);
					if (flag)
					{
						return;
					}
					if (flag2)
					{
						continue;
					}
					completionSource.TrySetResult(result);
					return;
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
			}
			sourceMoveNext.SourceOnCompleted(moveNextCallbackDelegate, this);
		}

		private (bool waitCallback, bool requireNextIteration) TryMoveNextCore(bool sourceHasCurrent, out bool result)
		{
			if (sourceHasCurrent)
			{
				SourceCurrent = enumerator.Current;
				UniTask<TAwait> taskResult = TransformAsync(SourceCurrent);
				if (UnwarapTask(taskResult, out var result2))
				{
					bool terminateIteration;
					bool trySetCurrentResult = TrySetCurrentCore(result2, out terminateIteration);
					if (terminateIteration)
					{
						return IterateFinished(out result);
					}
					return ActionCompleted(trySetCurrentResult, out result);
				}
				return WaitAwaitCallback(out result);
			}
			return IterateFinished(out result);
		}

		protected bool UnwarapTask(UniTask<TAwait> taskResult, out TAwait result)
		{
			resultAwaiter = taskResult.GetAwaiter();
			if (resultAwaiter.IsCompleted)
			{
				result = resultAwaiter.GetResult();
				return true;
			}
			resultAwaiter.SourceOnCompleted(setCurrentCallbackDelegate, this);
			result = default(TAwait);
			return false;
		}

		private static void MoveNextCallBack(object state)
		{
			AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait> asyncEnumeratorAwaitSelectorBase = (AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait>)state;
			bool result = false;
			try
			{
				var (flag, flag2) = asyncEnumeratorAwaitSelectorBase.TryMoveNextCore(asyncEnumeratorAwaitSelectorBase.sourceMoveNext.GetResult(), out result);
				if (!flag)
				{
					if (flag2)
					{
						asyncEnumeratorAwaitSelectorBase.SourceMoveNext();
					}
					else
					{
						asyncEnumeratorAwaitSelectorBase.completionSource.TrySetResult(result);
					}
				}
			}
			catch (Exception error)
			{
				asyncEnumeratorAwaitSelectorBase.completionSource.TrySetException(error);
			}
		}

		private static void SetCurrentCallBack(object state)
		{
			AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait> asyncEnumeratorAwaitSelectorBase = (AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait>)state;
			bool flag;
			bool terminateIteration;
			try
			{
				TAwait result = asyncEnumeratorAwaitSelectorBase.resultAwaiter.GetResult();
				flag = asyncEnumeratorAwaitSelectorBase.TrySetCurrentCore(result, out terminateIteration);
			}
			catch (Exception error)
			{
				asyncEnumeratorAwaitSelectorBase.completionSource.TrySetException(error);
				return;
			}
			if (asyncEnumeratorAwaitSelectorBase.cancellationToken.IsCancellationRequested)
			{
				asyncEnumeratorAwaitSelectorBase.completionSource.TrySetCanceled(asyncEnumeratorAwaitSelectorBase.cancellationToken);
			}
			else if (flag)
			{
				asyncEnumeratorAwaitSelectorBase.completionSource.TrySetResult(result: true);
			}
			else if (terminateIteration)
			{
				asyncEnumeratorAwaitSelectorBase.completionSource.TrySetResult(result: false);
			}
			else
			{
				asyncEnumeratorAwaitSelectorBase.SourceMoveNext();
			}
		}

		public virtual UniTask DisposeAsync()
		{
			if (enumerator != null)
			{
				return enumerator.DisposeAsync();
			}
			return default(UniTask);
		}
	}
	internal static class Average
	{
		public static async UniTask<double> AverageAsync(IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			int sum = 0;
			IUniTaskAsyncEnumerator<int> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						sum += e.Current;
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			int sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						sum += selector(e.Current);
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			int sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						int num = sum;
						sum = num + await selector(e.Current);
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			int sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						int num = sum;
						sum = num + await selector(e.Current, cancellationToken);
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAsync(IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			long sum = 0L;
			IUniTaskAsyncEnumerator<long> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						sum += e.Current;
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			long sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						sum += selector(e.Current);
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			long sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						long num = sum;
						sum = num + await selector(e.Current);
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<double> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			long sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						long num = sum;
						sum = num + await selector(e.Current, cancellationToken);
						count++;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum / (double)count;
			}
		}

		public static async UniTask<float> AverageAsync(IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			float sum = 0f;
			IUniTaskAsyncEnumerator<float> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (float)count;
		}

		public static async UniTask<float> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			float sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (float)count;
		}

		public static async UniTask<float> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			float sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float num = sum;
					sum = num + await selector(e.Current);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (float)count;
		}

		public static async UniTask<float> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			float sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float num = sum;
					sum = num + await selector(e.Current, cancellationToken);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (float)count;
		}

		public static async UniTask<double> AverageAsync(IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			double sum = 0.0;
			IUniTaskAsyncEnumerator<double> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<double> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			double sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<double> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			double sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double num = sum;
					sum = num + await selector(e.Current);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<double> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			double sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double num = sum;
					sum = num + await selector(e.Current, cancellationToken);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<decimal> AverageAsync(IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<decimal> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal)count;
		}

		public static async UniTask<decimal> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal)count;
		}

		public static async UniTask<decimal> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal num = sum;
					sum = num + await selector(e.Current);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal)count;
		}

		public static async UniTask<decimal> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal num = sum;
					sum = num + await selector(e.Current, cancellationToken);
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal)count;
		}

		public static async UniTask<double?> AverageAsync(IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			int? sum = 0;
			IUniTaskAsyncEnumerator<int?> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						int? current = e.Current;
						if (current.HasValue)
						{
							sum += current.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			int? sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						int? num = selector(e.Current);
						if (num.HasValue)
						{
							sum += num.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			int? sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						int? num = await selector(e.Current);
						if (num.HasValue)
						{
							sum += num.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			int? sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						int? num = await selector(e.Current, cancellationToken);
						if (num.HasValue)
						{
							sum += num.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAsync(IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			long? sum = 0L;
			IUniTaskAsyncEnumerator<long?> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						long? current = e.Current;
						if (current.HasValue)
						{
							sum += current.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			long? sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						long? num = selector(e.Current);
						if (num.HasValue)
						{
							sum += num.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			long? sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						long? num = await selector(e.Current);
						if (num.HasValue)
						{
							sum += num.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<double?> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			long? sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			checked
			{
				try
				{
					while (await e.MoveNextAsync())
					{
						long? num = await selector(e.Current, cancellationToken);
						if (num.HasValue)
						{
							sum += num.Value;
							count++;
						}
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
					if (asyncDisposable != null)
					{
						await asyncDisposable.DisposeAsync();
					}
				}
				return (double)sum.Value / (double)count;
			}
		}

		public static async UniTask<float?> AverageAsync(IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			float? sum = 0f;
			IUniTaskAsyncEnumerator<float?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float? current = e.Current;
					if (current.HasValue)
					{
						sum += current.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return (sum / (float)count).Value;
		}

		public static async UniTask<float?> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			float? sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float? num = selector(e.Current);
					if (num.HasValue)
					{
						sum += num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return (sum / (float)count).Value;
		}

		public static async UniTask<float?> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			float? sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float? num = await selector(e.Current);
					if (num.HasValue)
					{
						sum += num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return (sum / (float)count).Value;
		}

		public static async UniTask<float?> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			float? sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float? num = await selector(e.Current, cancellationToken);
					if (num.HasValue)
					{
						sum += num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return (sum / (float)count).Value;
		}

		public static async UniTask<double?> AverageAsync(IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			double? sum = 0.0;
			IUniTaskAsyncEnumerator<double?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double? current = e.Current;
					if (current.HasValue)
					{
						sum += current.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<double?> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			double? sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double? num = selector(e.Current);
					if (num.HasValue)
					{
						sum += num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<double?> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			double? sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double? num = await selector(e.Current);
					if (num.HasValue)
					{
						sum += num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<double?> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			double? sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double? num = await selector(e.Current, cancellationToken);
					if (num.HasValue)
					{
						sum += num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (double)count;
		}

		public static async UniTask<decimal?> AverageAsync(IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal? sum = default(decimal);
			IUniTaskAsyncEnumerator<decimal?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal? current = e.Current;
					if (current.HasValue)
					{
						sum += (decimal?)current.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal?)count;
		}

		public static async UniTask<decimal?> AverageAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal? sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal? num = selector(e.Current);
					if (num.HasValue)
					{
						sum += (decimal?)num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal?)count;
		}

		public static async UniTask<decimal?> AverageAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal? sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal? num = await selector(e.Current);
					if (num.HasValue)
					{
						sum += (decimal?)num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal?)count;
		}

		public static async UniTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			long count = 0L;
			decimal? sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal? num = await selector(e.Current, cancellationToken);
					if (num.HasValue)
					{
						sum += (decimal?)num.Value;
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum / (decimal?)count;
		}
	}
	internal sealed class Buffer<TSource> : IUniTaskAsyncEnumerable<IList<TSource>>
	{
		private sealed class _Buffer : MoveNextSource, IUniTaskAsyncEnumerator<IList<TSource>>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly int count;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private bool continueNext;

			private bool completed;

			private List<TSource> buffer;

			public IList<TSource> Current { get; private set; }

			public _Buffer(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
			{
				this.source = source;
				this.count = count;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken);
					buffer = new List<TSource>(count);
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				if (completed)
				{
					if (buffer != null && buffer.Count > 0)
					{
						List<TSource> current = buffer;
						buffer = null;
						Current = current;
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
					return;
				}
				try
				{
					while (true)
					{
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_Buffer buffer = (_Buffer)state;
				if (buffer.TryGetResult(buffer.awaiter, out var result))
				{
					if (result)
					{
						buffer.buffer.Add(buffer.enumerator.Current);
						if (buffer.buffer.Count == buffer.count)
						{
							buffer.Current = buffer.buffer;
							buffer.buffer = new List<TSource>(buffer.count);
							buffer.continueNext = false;
							buffer.completionSource.TrySetResult(result: true);
						}
						else if (!buffer.continueNext)
						{
							buffer.SourceMoveNext();
						}
					}
					else
					{
						buffer.continueNext = false;
						buffer.completed = true;
						buffer.SourceMoveNext();
					}
				}
				else
				{
					buffer.continueNext = false;
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly int count;

		public Buffer(IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			this.source = source;
			this.count = count;
		}

		public IUniTaskAsyncEnumerator<IList<TSource>> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Buffer(source, count, cancellationToken);
		}
	}
	internal sealed class BufferSkip<TSource> : IUniTaskAsyncEnumerable<IList<TSource>>
	{
		private sealed class _BufferSkip : MoveNextSource, IUniTaskAsyncEnumerator<IList<TSource>>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly int count;

			private readonly int skip;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private bool continueNext;

			private bool completed;

			private Queue<List<TSource>> buffers;

			private int index;

			public IList<TSource> Current { get; private set; }

			public _BufferSkip(IUniTaskAsyncEnumerable<TSource> source, int count, int skip, CancellationToken cancellationToken)
			{
				this.source = source;
				this.count = count;
				this.skip = skip;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken);
					buffers = new Queue<List<TSource>>();
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				if (completed)
				{
					if (buffers.Count > 0)
					{
						Current = buffers.Dequeue();
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
					return;
				}
				try
				{
					while (true)
					{
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_BufferSkip bufferSkip = (_BufferSkip)state;
				if (bufferSkip.TryGetResult(bufferSkip.awaiter, out var result))
				{
					if (result)
					{
						if (bufferSkip.index++ % bufferSkip.skip == 0)
						{
							bufferSkip.buffers.Enqueue(new List<TSource>(bufferSkip.count));
						}
						TSource current = bufferSkip.enumerator.Current;
						foreach (List<TSource> buffer in bufferSkip.buffers)
						{
							buffer.Add(current);
						}
						if (bufferSkip.buffers.Count > 0 && bufferSkip.buffers.Peek().Count == bufferSkip.count)
						{
							bufferSkip.Current = bufferSkip.buffers.Dequeue();
							bufferSkip.continueNext = false;
							bufferSkip.completionSource.TrySetResult(result: true);
						}
						else if (!bufferSkip.continueNext)
						{
							bufferSkip.SourceMoveNext();
						}
					}
					else
					{
						bufferSkip.continueNext = false;
						bufferSkip.completed = true;
						bufferSkip.SourceMoveNext();
					}
				}
				else
				{
					bufferSkip.continueNext = false;
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly int count;

		private readonly int skip;

		public BufferSkip(IUniTaskAsyncEnumerable<TSource> source, int count, int skip)
		{
			this.source = source;
			this.count = count;
			this.skip = skip;
		}

		public IUniTaskAsyncEnumerator<IList<TSource>> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _BufferSkip(source, count, skip, cancellationToken);
		}
	}
	internal sealed class Cast<TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _Cast : AsyncEnumeratorBase<object, TResult>
		{
			public _Cast(IUniTaskAsyncEnumerable<object> source, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					base.Current = (TResult)base.SourceCurrent;
					result = true;
					return true;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<object> source;

		public Cast(IUniTaskAsyncEnumerable<object> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Cast(source, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private const int CompleteCount = 2;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly Func<T1, T2, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, Func<T1, T2, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 2)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
				}
				while (!running1 || !running2);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 2)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 2;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 2;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 2)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 2;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 2;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2)
				{
					result = resultSelector(current1, current2);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly Func<T1, T2, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, Func<T1, T2, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private const int CompleteCount = 3;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly Func<T1, T2, T3, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, Func<T1, T2, T3, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 3)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 3)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 3;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 3;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 3)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 3;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 3;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 3)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 3;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 3;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3)
				{
					result = resultSelector(current1, current2, current3);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly Func<T1, T2, T3, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, Func<T1, T2, T3, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private const int CompleteCount = 4;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly Func<T1, T2, T3, T4, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, Func<T1, T2, T3, T4, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 4)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 4)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 4;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 4;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 4)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 4;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 4;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 4)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 4;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 4;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 4)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 4;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 4;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4)
				{
					result = resultSelector(current1, current2, current3, current4);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly Func<T1, T2, T3, T4, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, Func<T1, T2, T3, T4, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private const int CompleteCount = 5;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly Func<T1, T2, T3, T4, T5, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, Func<T1, T2, T3, T4, T5, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 5)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 5)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 5;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 5;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 5)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 5;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 5;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 5)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 5;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 5;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 5)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 5;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 5;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 5)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 5;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 5;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5)
				{
					result = resultSelector(current1, current2, current3, current4, current5);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly Func<T1, T2, T3, T4, T5, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, Func<T1, T2, T3, T4, T5, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private const int CompleteCount = 6;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 6)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 6)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 6;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 6;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 6)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 6;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 6;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 6)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 6;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 6;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 6)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 6;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 6;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 6)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 6;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 6;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 6)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 6;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 6;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private const int CompleteCount = 7;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 7)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 7)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 7;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 7;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private const int CompleteCount = 8;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 8)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 8)
						{
							goto IL_00cb;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 8;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 8;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00cb:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private const int CompleteCount = 9;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 9)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 9)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 9;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 9;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private static readonly Action<object> Completed10Delegate = Completed10;

			private const int CompleteCount = 10;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly IUniTaskAsyncEnumerable<T10> source10;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private IUniTaskAsyncEnumerator<T10> enumerator10;

			private UniTask<bool>.Awaiter awaiter10;

			private bool hasCurrent10;

			private bool running10;

			private T10 current10;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.source10 = source10;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 10)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
					enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
					if (!running10)
					{
						running10 = true;
						awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
						if (awaiter10.IsCompleted)
						{
							Completed10(this);
						}
						else
						{
							awaiter10.SourceOnCompleted(Completed10Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed10(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running10 = false;
				try
				{
					if (!combineLatest.awaiter10.GetResult())
					{
						combineLatest.running10 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 10)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent10 = true;
					combineLatest.current10 = combineLatest.enumerator10.Current;
				}
				catch (Exception error)
				{
					combineLatest.running10 = true;
					combineLatest.completedCount = 10;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running10 = true;
					try
					{
						combineLatest.awaiter10 = combineLatest.enumerator10.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 10;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter10.SourceOnCompleted(Completed10Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
				if (enumerator10 != null)
				{
					await enumerator10.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly IUniTaskAsyncEnumerable<T10> source10;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.source10 = source10;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private static readonly Action<object> Completed10Delegate = Completed10;

			private static readonly Action<object> Completed11Delegate = Completed11;

			private const int CompleteCount = 11;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly IUniTaskAsyncEnumerable<T10> source10;

			private readonly IUniTaskAsyncEnumerable<T11> source11;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private IUniTaskAsyncEnumerator<T10> enumerator10;

			private UniTask<bool>.Awaiter awaiter10;

			private bool hasCurrent10;

			private bool running10;

			private T10 current10;

			private IUniTaskAsyncEnumerator<T11> enumerator11;

			private UniTask<bool>.Awaiter awaiter11;

			private bool hasCurrent11;

			private bool running11;

			private T11 current11;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.source10 = source10;
				this.source11 = source11;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 11)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
					enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
					enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
					if (!running10)
					{
						running10 = true;
						awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
						if (awaiter10.IsCompleted)
						{
							Completed10(this);
						}
						else
						{
							awaiter10.SourceOnCompleted(Completed10Delegate, this);
						}
					}
					if (!running11)
					{
						running11 = true;
						awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
						if (awaiter11.IsCompleted)
						{
							Completed11(this);
						}
						else
						{
							awaiter11.SourceOnCompleted(Completed11Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed10(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running10 = false;
				try
				{
					if (!combineLatest.awaiter10.GetResult())
					{
						combineLatest.running10 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent10 = true;
					combineLatest.current10 = combineLatest.enumerator10.Current;
				}
				catch (Exception error)
				{
					combineLatest.running10 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running10 = true;
					try
					{
						combineLatest.awaiter10 = combineLatest.enumerator10.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter10.SourceOnCompleted(Completed10Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed11(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running11 = false;
				try
				{
					if (!combineLatest.awaiter11.GetResult())
					{
						combineLatest.running11 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 11)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent11 = true;
					combineLatest.current11 = combineLatest.enumerator11.Current;
				}
				catch (Exception error)
				{
					combineLatest.running11 = true;
					combineLatest.completedCount = 11;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running11 = true;
					try
					{
						combineLatest.awaiter11 = combineLatest.enumerator11.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 11;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter11.SourceOnCompleted(Completed11Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
				if (enumerator10 != null)
				{
					await enumerator10.DisposeAsync();
				}
				if (enumerator11 != null)
				{
					await enumerator11.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly IUniTaskAsyncEnumerable<T10> source10;

		private readonly IUniTaskAsyncEnumerable<T11> source11;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.source10 = source10;
			this.source11 = source11;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private static readonly Action<object> Completed10Delegate = Completed10;

			private static readonly Action<object> Completed11Delegate = Completed11;

			private static readonly Action<object> Completed12Delegate = Completed12;

			private const int CompleteCount = 12;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly IUniTaskAsyncEnumerable<T10> source10;

			private readonly IUniTaskAsyncEnumerable<T11> source11;

			private readonly IUniTaskAsyncEnumerable<T12> source12;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private IUniTaskAsyncEnumerator<T10> enumerator10;

			private UniTask<bool>.Awaiter awaiter10;

			private bool hasCurrent10;

			private bool running10;

			private T10 current10;

			private IUniTaskAsyncEnumerator<T11> enumerator11;

			private UniTask<bool>.Awaiter awaiter11;

			private bool hasCurrent11;

			private bool running11;

			private T11 current11;

			private IUniTaskAsyncEnumerator<T12> enumerator12;

			private UniTask<bool>.Awaiter awaiter12;

			private bool hasCurrent12;

			private bool running12;

			private T12 current12;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.source10 = source10;
				this.source11 = source11;
				this.source12 = source12;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 12)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
					enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
					enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
					enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
					if (!running10)
					{
						running10 = true;
						awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
						if (awaiter10.IsCompleted)
						{
							Completed10(this);
						}
						else
						{
							awaiter10.SourceOnCompleted(Completed10Delegate, this);
						}
					}
					if (!running11)
					{
						running11 = true;
						awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
						if (awaiter11.IsCompleted)
						{
							Completed11(this);
						}
						else
						{
							awaiter11.SourceOnCompleted(Completed11Delegate, this);
						}
					}
					if (!running12)
					{
						running12 = true;
						awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
						if (awaiter12.IsCompleted)
						{
							Completed12(this);
						}
						else
						{
							awaiter12.SourceOnCompleted(Completed12Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed10(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running10 = false;
				try
				{
					if (!combineLatest.awaiter10.GetResult())
					{
						combineLatest.running10 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent10 = true;
					combineLatest.current10 = combineLatest.enumerator10.Current;
				}
				catch (Exception error)
				{
					combineLatest.running10 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running10 = true;
					try
					{
						combineLatest.awaiter10 = combineLatest.enumerator10.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter10.SourceOnCompleted(Completed10Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed11(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running11 = false;
				try
				{
					if (!combineLatest.awaiter11.GetResult())
					{
						combineLatest.running11 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent11 = true;
					combineLatest.current11 = combineLatest.enumerator11.Current;
				}
				catch (Exception error)
				{
					combineLatest.running11 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running11 = true;
					try
					{
						combineLatest.awaiter11 = combineLatest.enumerator11.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter11.SourceOnCompleted(Completed11Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed12(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running12 = false;
				try
				{
					if (!combineLatest.awaiter12.GetResult())
					{
						combineLatest.running12 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 12)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent12 = true;
					combineLatest.current12 = combineLatest.enumerator12.Current;
				}
				catch (Exception error)
				{
					combineLatest.running12 = true;
					combineLatest.completedCount = 12;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running12 = true;
					try
					{
						combineLatest.awaiter12 = combineLatest.enumerator12.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 12;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter12.SourceOnCompleted(Completed12Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
				if (enumerator10 != null)
				{
					await enumerator10.DisposeAsync();
				}
				if (enumerator11 != null)
				{
					await enumerator11.DisposeAsync();
				}
				if (enumerator12 != null)
				{
					await enumerator12.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly IUniTaskAsyncEnumerable<T10> source10;

		private readonly IUniTaskAsyncEnumerable<T11> source11;

		private readonly IUniTaskAsyncEnumerable<T12> source12;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.source10 = source10;
			this.source11 = source11;
			this.source12 = source12;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private static readonly Action<object> Completed10Delegate = Completed10;

			private static readonly Action<object> Completed11Delegate = Completed11;

			private static readonly Action<object> Completed12Delegate = Completed12;

			private static readonly Action<object> Completed13Delegate = Completed13;

			private const int CompleteCount = 13;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly IUniTaskAsyncEnumerable<T10> source10;

			private readonly IUniTaskAsyncEnumerable<T11> source11;

			private readonly IUniTaskAsyncEnumerable<T12> source12;

			private readonly IUniTaskAsyncEnumerable<T13> source13;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private IUniTaskAsyncEnumerator<T10> enumerator10;

			private UniTask<bool>.Awaiter awaiter10;

			private bool hasCurrent10;

			private bool running10;

			private T10 current10;

			private IUniTaskAsyncEnumerator<T11> enumerator11;

			private UniTask<bool>.Awaiter awaiter11;

			private bool hasCurrent11;

			private bool running11;

			private T11 current11;

			private IUniTaskAsyncEnumerator<T12> enumerator12;

			private UniTask<bool>.Awaiter awaiter12;

			private bool hasCurrent12;

			private bool running12;

			private T12 current12;

			private IUniTaskAsyncEnumerator<T13> enumerator13;

			private UniTask<bool>.Awaiter awaiter13;

			private bool hasCurrent13;

			private bool running13;

			private T13 current13;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.source10 = source10;
				this.source11 = source11;
				this.source12 = source12;
				this.source13 = source13;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 13)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
					enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
					enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
					enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
					enumerator13 = source13.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
					if (!running10)
					{
						running10 = true;
						awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
						if (awaiter10.IsCompleted)
						{
							Completed10(this);
						}
						else
						{
							awaiter10.SourceOnCompleted(Completed10Delegate, this);
						}
					}
					if (!running11)
					{
						running11 = true;
						awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
						if (awaiter11.IsCompleted)
						{
							Completed11(this);
						}
						else
						{
							awaiter11.SourceOnCompleted(Completed11Delegate, this);
						}
					}
					if (!running12)
					{
						running12 = true;
						awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
						if (awaiter12.IsCompleted)
						{
							Completed12(this);
						}
						else
						{
							awaiter12.SourceOnCompleted(Completed12Delegate, this);
						}
					}
					if (!running13)
					{
						running13 = true;
						awaiter13 = enumerator13.MoveNextAsync().GetAwaiter();
						if (awaiter13.IsCompleted)
						{
							Completed13(this);
						}
						else
						{
							awaiter13.SourceOnCompleted(Completed13Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12 || !running13);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed10(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running10 = false;
				try
				{
					if (!combineLatest.awaiter10.GetResult())
					{
						combineLatest.running10 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent10 = true;
					combineLatest.current10 = combineLatest.enumerator10.Current;
				}
				catch (Exception error)
				{
					combineLatest.running10 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running10 = true;
					try
					{
						combineLatest.awaiter10 = combineLatest.enumerator10.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter10.SourceOnCompleted(Completed10Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed11(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running11 = false;
				try
				{
					if (!combineLatest.awaiter11.GetResult())
					{
						combineLatest.running11 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent11 = true;
					combineLatest.current11 = combineLatest.enumerator11.Current;
				}
				catch (Exception error)
				{
					combineLatest.running11 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running11 = true;
					try
					{
						combineLatest.awaiter11 = combineLatest.enumerator11.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter11.SourceOnCompleted(Completed11Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed12(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running12 = false;
				try
				{
					if (!combineLatest.awaiter12.GetResult())
					{
						combineLatest.running12 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent12 = true;
					combineLatest.current12 = combineLatest.enumerator12.Current;
				}
				catch (Exception error)
				{
					combineLatest.running12 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running12 = true;
					try
					{
						combineLatest.awaiter12 = combineLatest.enumerator12.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter12.SourceOnCompleted(Completed12Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed13(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running13 = false;
				try
				{
					if (!combineLatest.awaiter13.GetResult())
					{
						combineLatest.running13 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 13)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent13 = true;
					combineLatest.current13 = combineLatest.enumerator13.Current;
				}
				catch (Exception error)
				{
					combineLatest.running13 = true;
					combineLatest.completedCount = 13;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running13 = true;
					try
					{
						combineLatest.awaiter13 = combineLatest.enumerator13.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 13;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter13.SourceOnCompleted(Completed13Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12 && hasCurrent13)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12, current13);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
				if (enumerator10 != null)
				{
					await enumerator10.DisposeAsync();
				}
				if (enumerator11 != null)
				{
					await enumerator11.DisposeAsync();
				}
				if (enumerator12 != null)
				{
					await enumerator12.DisposeAsync();
				}
				if (enumerator13 != null)
				{
					await enumerator13.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly IUniTaskAsyncEnumerable<T10> source10;

		private readonly IUniTaskAsyncEnumerable<T11> source11;

		private readonly IUniTaskAsyncEnumerable<T12> source12;

		private readonly IUniTaskAsyncEnumerable<T13> source13;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.source10 = source10;
			this.source11 = source11;
			this.source12 = source12;
			this.source13 = source13;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private static readonly Action<object> Completed10Delegate = Completed10;

			private static readonly Action<object> Completed11Delegate = Completed11;

			private static readonly Action<object> Completed12Delegate = Completed12;

			private static readonly Action<object> Completed13Delegate = Completed13;

			private static readonly Action<object> Completed14Delegate = Completed14;

			private const int CompleteCount = 14;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly IUniTaskAsyncEnumerable<T10> source10;

			private readonly IUniTaskAsyncEnumerable<T11> source11;

			private readonly IUniTaskAsyncEnumerable<T12> source12;

			private readonly IUniTaskAsyncEnumerable<T13> source13;

			private readonly IUniTaskAsyncEnumerable<T14> source14;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private IUniTaskAsyncEnumerator<T10> enumerator10;

			private UniTask<bool>.Awaiter awaiter10;

			private bool hasCurrent10;

			private bool running10;

			private T10 current10;

			private IUniTaskAsyncEnumerator<T11> enumerator11;

			private UniTask<bool>.Awaiter awaiter11;

			private bool hasCurrent11;

			private bool running11;

			private T11 current11;

			private IUniTaskAsyncEnumerator<T12> enumerator12;

			private UniTask<bool>.Awaiter awaiter12;

			private bool hasCurrent12;

			private bool running12;

			private T12 current12;

			private IUniTaskAsyncEnumerator<T13> enumerator13;

			private UniTask<bool>.Awaiter awaiter13;

			private bool hasCurrent13;

			private bool running13;

			private T13 current13;

			private IUniTaskAsyncEnumerator<T14> enumerator14;

			private UniTask<bool>.Awaiter awaiter14;

			private bool hasCurrent14;

			private bool running14;

			private T14 current14;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, IUniTaskAsyncEnumerable<T14> source14, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.source10 = source10;
				this.source11 = source11;
				this.source12 = source12;
				this.source13 = source13;
				this.source14 = source14;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 14)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
					enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
					enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
					enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
					enumerator13 = source13.GetAsyncEnumerator(cancellationToken);
					enumerator14 = source14.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
					if (!running10)
					{
						running10 = true;
						awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
						if (awaiter10.IsCompleted)
						{
							Completed10(this);
						}
						else
						{
							awaiter10.SourceOnCompleted(Completed10Delegate, this);
						}
					}
					if (!running11)
					{
						running11 = true;
						awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
						if (awaiter11.IsCompleted)
						{
							Completed11(this);
						}
						else
						{
							awaiter11.SourceOnCompleted(Completed11Delegate, this);
						}
					}
					if (!running12)
					{
						running12 = true;
						awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
						if (awaiter12.IsCompleted)
						{
							Completed12(this);
						}
						else
						{
							awaiter12.SourceOnCompleted(Completed12Delegate, this);
						}
					}
					if (!running13)
					{
						running13 = true;
						awaiter13 = enumerator13.MoveNextAsync().GetAwaiter();
						if (awaiter13.IsCompleted)
						{
							Completed13(this);
						}
						else
						{
							awaiter13.SourceOnCompleted(Completed13Delegate, this);
						}
					}
					if (!running14)
					{
						running14 = true;
						awaiter14 = enumerator14.MoveNextAsync().GetAwaiter();
						if (awaiter14.IsCompleted)
						{
							Completed14(this);
						}
						else
						{
							awaiter14.SourceOnCompleted(Completed14Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12 || !running13 || !running14);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed10(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running10 = false;
				try
				{
					if (!combineLatest.awaiter10.GetResult())
					{
						combineLatest.running10 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent10 = true;
					combineLatest.current10 = combineLatest.enumerator10.Current;
				}
				catch (Exception error)
				{
					combineLatest.running10 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running10 = true;
					try
					{
						combineLatest.awaiter10 = combineLatest.enumerator10.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter10.SourceOnCompleted(Completed10Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed11(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running11 = false;
				try
				{
					if (!combineLatest.awaiter11.GetResult())
					{
						combineLatest.running11 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent11 = true;
					combineLatest.current11 = combineLatest.enumerator11.Current;
				}
				catch (Exception error)
				{
					combineLatest.running11 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running11 = true;
					try
					{
						combineLatest.awaiter11 = combineLatest.enumerator11.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter11.SourceOnCompleted(Completed11Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed12(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running12 = false;
				try
				{
					if (!combineLatest.awaiter12.GetResult())
					{
						combineLatest.running12 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent12 = true;
					combineLatest.current12 = combineLatest.enumerator12.Current;
				}
				catch (Exception error)
				{
					combineLatest.running12 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running12 = true;
					try
					{
						combineLatest.awaiter12 = combineLatest.enumerator12.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter12.SourceOnCompleted(Completed12Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed13(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running13 = false;
				try
				{
					if (!combineLatest.awaiter13.GetResult())
					{
						combineLatest.running13 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent13 = true;
					combineLatest.current13 = combineLatest.enumerator13.Current;
				}
				catch (Exception error)
				{
					combineLatest.running13 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running13 = true;
					try
					{
						combineLatest.awaiter13 = combineLatest.enumerator13.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter13.SourceOnCompleted(Completed13Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed14(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running14 = false;
				try
				{
					if (!combineLatest.awaiter14.GetResult())
					{
						combineLatest.running14 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 14)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent14 = true;
					combineLatest.current14 = combineLatest.enumerator14.Current;
				}
				catch (Exception error)
				{
					combineLatest.running14 = true;
					combineLatest.completedCount = 14;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running14 = true;
					try
					{
						combineLatest.awaiter14 = combineLatest.enumerator14.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 14;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter14.SourceOnCompleted(Completed14Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12 && hasCurrent13 && hasCurrent14)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12, current13, current14);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
				if (enumerator10 != null)
				{
					await enumerator10.DisposeAsync();
				}
				if (enumerator11 != null)
				{
					await enumerator11.DisposeAsync();
				}
				if (enumerator12 != null)
				{
					await enumerator12.DisposeAsync();
				}
				if (enumerator13 != null)
				{
					await enumerator13.DisposeAsync();
				}
				if (enumerator14 != null)
				{
					await enumerator14.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly IUniTaskAsyncEnumerable<T10> source10;

		private readonly IUniTaskAsyncEnumerable<T11> source11;

		private readonly IUniTaskAsyncEnumerable<T12> source12;

		private readonly IUniTaskAsyncEnumerable<T13> source13;

		private readonly IUniTaskAsyncEnumerable<T14> source14;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, IUniTaskAsyncEnumerable<T14> source14, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.source10 = source10;
			this.source11 = source11;
			this.source12 = source12;
			this.source13 = source13;
			this.source14 = source14;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, resultSelector, cancellationToken);
		}
	}
	internal class CombineLatest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> Completed1Delegate = Completed1;

			private static readonly Action<object> Completed2Delegate = Completed2;

			private static readonly Action<object> Completed3Delegate = Completed3;

			private static readonly Action<object> Completed4Delegate = Completed4;

			private static readonly Action<object> Completed5Delegate = Completed5;

			private static readonly Action<object> Completed6Delegate = Completed6;

			private static readonly Action<object> Completed7Delegate = Completed7;

			private static readonly Action<object> Completed8Delegate = Completed8;

			private static readonly Action<object> Completed9Delegate = Completed9;

			private static readonly Action<object> Completed10Delegate = Completed10;

			private static readonly Action<object> Completed11Delegate = Completed11;

			private static readonly Action<object> Completed12Delegate = Completed12;

			private static readonly Action<object> Completed13Delegate = Completed13;

			private static readonly Action<object> Completed14Delegate = Completed14;

			private static readonly Action<object> Completed15Delegate = Completed15;

			private const int CompleteCount = 15;

			private readonly IUniTaskAsyncEnumerable<T1> source1;

			private readonly IUniTaskAsyncEnumerable<T2> source2;

			private readonly IUniTaskAsyncEnumerable<T3> source3;

			private readonly IUniTaskAsyncEnumerable<T4> source4;

			private readonly IUniTaskAsyncEnumerable<T5> source5;

			private readonly IUniTaskAsyncEnumerable<T6> source6;

			private readonly IUniTaskAsyncEnumerable<T7> source7;

			private readonly IUniTaskAsyncEnumerable<T8> source8;

			private readonly IUniTaskAsyncEnumerable<T9> source9;

			private readonly IUniTaskAsyncEnumerable<T10> source10;

			private readonly IUniTaskAsyncEnumerable<T11> source11;

			private readonly IUniTaskAsyncEnumerable<T12> source12;

			private readonly IUniTaskAsyncEnumerable<T13> source13;

			private readonly IUniTaskAsyncEnumerable<T14> source14;

			private readonly IUniTaskAsyncEnumerable<T15> source15;

			private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<T1> enumerator1;

			private UniTask<bool>.Awaiter awaiter1;

			private bool hasCurrent1;

			private bool running1;

			private T1 current1;

			private IUniTaskAsyncEnumerator<T2> enumerator2;

			private UniTask<bool>.Awaiter awaiter2;

			private bool hasCurrent2;

			private bool running2;

			private T2 current2;

			private IUniTaskAsyncEnumerator<T3> enumerator3;

			private UniTask<bool>.Awaiter awaiter3;

			private bool hasCurrent3;

			private bool running3;

			private T3 current3;

			private IUniTaskAsyncEnumerator<T4> enumerator4;

			private UniTask<bool>.Awaiter awaiter4;

			private bool hasCurrent4;

			private bool running4;

			private T4 current4;

			private IUniTaskAsyncEnumerator<T5> enumerator5;

			private UniTask<bool>.Awaiter awaiter5;

			private bool hasCurrent5;

			private bool running5;

			private T5 current5;

			private IUniTaskAsyncEnumerator<T6> enumerator6;

			private UniTask<bool>.Awaiter awaiter6;

			private bool hasCurrent6;

			private bool running6;

			private T6 current6;

			private IUniTaskAsyncEnumerator<T7> enumerator7;

			private UniTask<bool>.Awaiter awaiter7;

			private bool hasCurrent7;

			private bool running7;

			private T7 current7;

			private IUniTaskAsyncEnumerator<T8> enumerator8;

			private UniTask<bool>.Awaiter awaiter8;

			private bool hasCurrent8;

			private bool running8;

			private T8 current8;

			private IUniTaskAsyncEnumerator<T9> enumerator9;

			private UniTask<bool>.Awaiter awaiter9;

			private bool hasCurrent9;

			private bool running9;

			private T9 current9;

			private IUniTaskAsyncEnumerator<T10> enumerator10;

			private UniTask<bool>.Awaiter awaiter10;

			private bool hasCurrent10;

			private bool running10;

			private T10 current10;

			private IUniTaskAsyncEnumerator<T11> enumerator11;

			private UniTask<bool>.Awaiter awaiter11;

			private bool hasCurrent11;

			private bool running11;

			private T11 current11;

			private IUniTaskAsyncEnumerator<T12> enumerator12;

			private UniTask<bool>.Awaiter awaiter12;

			private bool hasCurrent12;

			private bool running12;

			private T12 current12;

			private IUniTaskAsyncEnumerator<T13> enumerator13;

			private UniTask<bool>.Awaiter awaiter13;

			private bool hasCurrent13;

			private bool running13;

			private T13 current13;

			private IUniTaskAsyncEnumerator<T14> enumerator14;

			private UniTask<bool>.Awaiter awaiter14;

			private bool hasCurrent14;

			private bool running14;

			private T14 current14;

			private IUniTaskAsyncEnumerator<T15> enumerator15;

			private UniTask<bool>.Awaiter awaiter15;

			private bool hasCurrent15;

			private bool running15;

			private T15 current15;

			private int completedCount;

			private bool syncRunning;

			private TResult result;

			public TResult Current => result;

			public _CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, IUniTaskAsyncEnumerable<T14> source14, IUniTaskAsyncEnumerable<T15> source15, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source1 = source1;
				this.source2 = source2;
				this.source3 = source3;
				this.source4 = source4;
				this.source5 = source5;
				this.source6 = source6;
				this.source7 = source7;
				this.source8 = source8;
				this.source9 = source9;
				this.source10 = source10;
				this.source11 = source11;
				this.source12 = source12;
				this.source13 = source13;
				this.source14 = source14;
				this.source15 = source15;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (completedCount == 15)
				{
					return CompletedTasks.False;
				}
				if (enumerator1 == null)
				{
					enumerator1 = source1.GetAsyncEnumerator(cancellationToken);
					enumerator2 = source2.GetAsyncEnumerator(cancellationToken);
					enumerator3 = source3.GetAsyncEnumerator(cancellationToken);
					enumerator4 = source4.GetAsyncEnumerator(cancellationToken);
					enumerator5 = source5.GetAsyncEnumerator(cancellationToken);
					enumerator6 = source6.GetAsyncEnumerator(cancellationToken);
					enumerator7 = source7.GetAsyncEnumerator(cancellationToken);
					enumerator8 = source8.GetAsyncEnumerator(cancellationToken);
					enumerator9 = source9.GetAsyncEnumerator(cancellationToken);
					enumerator10 = source10.GetAsyncEnumerator(cancellationToken);
					enumerator11 = source11.GetAsyncEnumerator(cancellationToken);
					enumerator12 = source12.GetAsyncEnumerator(cancellationToken);
					enumerator13 = source13.GetAsyncEnumerator(cancellationToken);
					enumerator14 = source14.GetAsyncEnumerator(cancellationToken);
					enumerator15 = source15.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				do
				{
					syncRunning = true;
					if (!running1)
					{
						running1 = true;
						awaiter1 = enumerator1.MoveNextAsync().GetAwaiter();
						if (awaiter1.IsCompleted)
						{
							Completed1(this);
						}
						else
						{
							awaiter1.SourceOnCompleted(Completed1Delegate, this);
						}
					}
					if (!running2)
					{
						running2 = true;
						awaiter2 = enumerator2.MoveNextAsync().GetAwaiter();
						if (awaiter2.IsCompleted)
						{
							Completed2(this);
						}
						else
						{
							awaiter2.SourceOnCompleted(Completed2Delegate, this);
						}
					}
					if (!running3)
					{
						running3 = true;
						awaiter3 = enumerator3.MoveNextAsync().GetAwaiter();
						if (awaiter3.IsCompleted)
						{
							Completed3(this);
						}
						else
						{
							awaiter3.SourceOnCompleted(Completed3Delegate, this);
						}
					}
					if (!running4)
					{
						running4 = true;
						awaiter4 = enumerator4.MoveNextAsync().GetAwaiter();
						if (awaiter4.IsCompleted)
						{
							Completed4(this);
						}
						else
						{
							awaiter4.SourceOnCompleted(Completed4Delegate, this);
						}
					}
					if (!running5)
					{
						running5 = true;
						awaiter5 = enumerator5.MoveNextAsync().GetAwaiter();
						if (awaiter5.IsCompleted)
						{
							Completed5(this);
						}
						else
						{
							awaiter5.SourceOnCompleted(Completed5Delegate, this);
						}
					}
					if (!running6)
					{
						running6 = true;
						awaiter6 = enumerator6.MoveNextAsync().GetAwaiter();
						if (awaiter6.IsCompleted)
						{
							Completed6(this);
						}
						else
						{
							awaiter6.SourceOnCompleted(Completed6Delegate, this);
						}
					}
					if (!running7)
					{
						running7 = true;
						awaiter7 = enumerator7.MoveNextAsync().GetAwaiter();
						if (awaiter7.IsCompleted)
						{
							Completed7(this);
						}
						else
						{
							awaiter7.SourceOnCompleted(Completed7Delegate, this);
						}
					}
					if (!running8)
					{
						running8 = true;
						awaiter8 = enumerator8.MoveNextAsync().GetAwaiter();
						if (awaiter8.IsCompleted)
						{
							Completed8(this);
						}
						else
						{
							awaiter8.SourceOnCompleted(Completed8Delegate, this);
						}
					}
					if (!running9)
					{
						running9 = true;
						awaiter9 = enumerator9.MoveNextAsync().GetAwaiter();
						if (awaiter9.IsCompleted)
						{
							Completed9(this);
						}
						else
						{
							awaiter9.SourceOnCompleted(Completed9Delegate, this);
						}
					}
					if (!running10)
					{
						running10 = true;
						awaiter10 = enumerator10.MoveNextAsync().GetAwaiter();
						if (awaiter10.IsCompleted)
						{
							Completed10(this);
						}
						else
						{
							awaiter10.SourceOnCompleted(Completed10Delegate, this);
						}
					}
					if (!running11)
					{
						running11 = true;
						awaiter11 = enumerator11.MoveNextAsync().GetAwaiter();
						if (awaiter11.IsCompleted)
						{
							Completed11(this);
						}
						else
						{
							awaiter11.SourceOnCompleted(Completed11Delegate, this);
						}
					}
					if (!running12)
					{
						running12 = true;
						awaiter12 = enumerator12.MoveNextAsync().GetAwaiter();
						if (awaiter12.IsCompleted)
						{
							Completed12(this);
						}
						else
						{
							awaiter12.SourceOnCompleted(Completed12Delegate, this);
						}
					}
					if (!running13)
					{
						running13 = true;
						awaiter13 = enumerator13.MoveNextAsync().GetAwaiter();
						if (awaiter13.IsCompleted)
						{
							Completed13(this);
						}
						else
						{
							awaiter13.SourceOnCompleted(Completed13Delegate, this);
						}
					}
					if (!running14)
					{
						running14 = true;
						awaiter14 = enumerator14.MoveNextAsync().GetAwaiter();
						if (awaiter14.IsCompleted)
						{
							Completed14(this);
						}
						else
						{
							awaiter14.SourceOnCompleted(Completed14Delegate, this);
						}
					}
					if (!running15)
					{
						running15 = true;
						awaiter15 = enumerator15.MoveNextAsync().GetAwaiter();
						if (awaiter15.IsCompleted)
						{
							Completed15(this);
						}
						else
						{
							awaiter15.SourceOnCompleted(Completed15Delegate, this);
						}
					}
				}
				while (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12 || !running13 || !running14 || !running15);
				syncRunning = false;
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void Completed1(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running1 = false;
				try
				{
					if (!combineLatest.awaiter1.GetResult())
					{
						combineLatest.running1 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent1 = true;
					combineLatest.current1 = combineLatest.enumerator1.Current;
				}
				catch (Exception error)
				{
					combineLatest.running1 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running1 = true;
					try
					{
						combineLatest.awaiter1 = combineLatest.enumerator1.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter1.SourceOnCompleted(Completed1Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed2(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running2 = false;
				try
				{
					if (!combineLatest.awaiter2.GetResult())
					{
						combineLatest.running2 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent2 = true;
					combineLatest.current2 = combineLatest.enumerator2.Current;
				}
				catch (Exception error)
				{
					combineLatest.running2 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running2 = true;
					try
					{
						combineLatest.awaiter2 = combineLatest.enumerator2.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter2.SourceOnCompleted(Completed2Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed3(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running3 = false;
				try
				{
					if (!combineLatest.awaiter3.GetResult())
					{
						combineLatest.running3 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent3 = true;
					combineLatest.current3 = combineLatest.enumerator3.Current;
				}
				catch (Exception error)
				{
					combineLatest.running3 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running3 = true;
					try
					{
						combineLatest.awaiter3 = combineLatest.enumerator3.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter3.SourceOnCompleted(Completed3Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed4(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running4 = false;
				try
				{
					if (!combineLatest.awaiter4.GetResult())
					{
						combineLatest.running4 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent4 = true;
					combineLatest.current4 = combineLatest.enumerator4.Current;
				}
				catch (Exception error)
				{
					combineLatest.running4 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running4 = true;
					try
					{
						combineLatest.awaiter4 = combineLatest.enumerator4.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter4.SourceOnCompleted(Completed4Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed5(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running5 = false;
				try
				{
					if (!combineLatest.awaiter5.GetResult())
					{
						combineLatest.running5 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent5 = true;
					combineLatest.current5 = combineLatest.enumerator5.Current;
				}
				catch (Exception error)
				{
					combineLatest.running5 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running5 = true;
					try
					{
						combineLatest.awaiter5 = combineLatest.enumerator5.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter5.SourceOnCompleted(Completed5Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed6(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running6 = false;
				try
				{
					if (!combineLatest.awaiter6.GetResult())
					{
						combineLatest.running6 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent6 = true;
					combineLatest.current6 = combineLatest.enumerator6.Current;
				}
				catch (Exception error)
				{
					combineLatest.running6 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running6 = true;
					try
					{
						combineLatest.awaiter6 = combineLatest.enumerator6.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter6.SourceOnCompleted(Completed6Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed7(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running7 = false;
				try
				{
					if (!combineLatest.awaiter7.GetResult())
					{
						combineLatest.running7 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent7 = true;
					combineLatest.current7 = combineLatest.enumerator7.Current;
				}
				catch (Exception error)
				{
					combineLatest.running7 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running7 = true;
					try
					{
						combineLatest.awaiter7 = combineLatest.enumerator7.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter7.SourceOnCompleted(Completed7Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed8(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running8 = false;
				try
				{
					if (!combineLatest.awaiter8.GetResult())
					{
						combineLatest.running8 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent8 = true;
					combineLatest.current8 = combineLatest.enumerator8.Current;
				}
				catch (Exception error)
				{
					combineLatest.running8 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running8 = true;
					try
					{
						combineLatest.awaiter8 = combineLatest.enumerator8.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter8.SourceOnCompleted(Completed8Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed9(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running9 = false;
				try
				{
					if (!combineLatest.awaiter9.GetResult())
					{
						combineLatest.running9 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent9 = true;
					combineLatest.current9 = combineLatest.enumerator9.Current;
				}
				catch (Exception error)
				{
					combineLatest.running9 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running9 = true;
					try
					{
						combineLatest.awaiter9 = combineLatest.enumerator9.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter9.SourceOnCompleted(Completed9Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed10(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running10 = false;
				try
				{
					if (!combineLatest.awaiter10.GetResult())
					{
						combineLatest.running10 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent10 = true;
					combineLatest.current10 = combineLatest.enumerator10.Current;
				}
				catch (Exception error)
				{
					combineLatest.running10 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running10 = true;
					try
					{
						combineLatest.awaiter10 = combineLatest.enumerator10.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter10.SourceOnCompleted(Completed10Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed11(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running11 = false;
				try
				{
					if (!combineLatest.awaiter11.GetResult())
					{
						combineLatest.running11 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent11 = true;
					combineLatest.current11 = combineLatest.enumerator11.Current;
				}
				catch (Exception error)
				{
					combineLatest.running11 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running11 = true;
					try
					{
						combineLatest.awaiter11 = combineLatest.enumerator11.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter11.SourceOnCompleted(Completed11Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed12(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running12 = false;
				try
				{
					if (!combineLatest.awaiter12.GetResult())
					{
						combineLatest.running12 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent12 = true;
					combineLatest.current12 = combineLatest.enumerator12.Current;
				}
				catch (Exception error)
				{
					combineLatest.running12 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running12 = true;
					try
					{
						combineLatest.awaiter12 = combineLatest.enumerator12.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter12.SourceOnCompleted(Completed12Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed13(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running13 = false;
				try
				{
					if (!combineLatest.awaiter13.GetResult())
					{
						combineLatest.running13 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent13 = true;
					combineLatest.current13 = combineLatest.enumerator13.Current;
				}
				catch (Exception error)
				{
					combineLatest.running13 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running13 = true;
					try
					{
						combineLatest.awaiter13 = combineLatest.enumerator13.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter13.SourceOnCompleted(Completed13Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed14(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running14 = false;
				try
				{
					if (!combineLatest.awaiter14.GetResult())
					{
						combineLatest.running14 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent14 = true;
					combineLatest.current14 = combineLatest.enumerator14.Current;
				}
				catch (Exception error)
				{
					combineLatest.running14 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running14 = true;
					try
					{
						combineLatest.awaiter14 = combineLatest.enumerator14.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter14.SourceOnCompleted(Completed14Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private static void Completed15(object state)
			{
				_CombineLatest combineLatest = (_CombineLatest)state;
				combineLatest.running15 = false;
				try
				{
					if (!combineLatest.awaiter15.GetResult())
					{
						combineLatest.running15 = true;
						if (Interlocked.Increment(ref combineLatest.completedCount) == 15)
						{
							goto IL_00d1;
						}
						return;
					}
					combineLatest.hasCurrent15 = true;
					combineLatest.current15 = combineLatest.enumerator15.Current;
				}
				catch (Exception error)
				{
					combineLatest.running15 = true;
					combineLatest.completedCount = 15;
					combineLatest.completionSource.TrySetException(error);
					return;
				}
				if (!combineLatest.TrySetResult() && !combineLatest.syncRunning)
				{
					combineLatest.running15 = true;
					try
					{
						combineLatest.awaiter15 = combineLatest.enumerator15.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error2)
					{
						combineLatest.completedCount = 15;
						combineLatest.completionSource.TrySetException(error2);
						return;
					}
					combineLatest.awaiter15.SourceOnCompleted(Completed15Delegate, combineLatest);
				}
				return;
				IL_00d1:
				combineLatest.completionSource.TrySetResult(result: false);
			}

			private bool TrySetResult()
			{
				if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12 && hasCurrent13 && hasCurrent14 && hasCurrent15)
				{
					result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12, current13, current14, current15);
					completionSource.TrySetResult(result: true);
					return true;
				}
				return false;
			}

			public async UniTask DisposeAsync()
			{
				if (enumerator1 != null)
				{
					await enumerator1.DisposeAsync();
				}
				if (enumerator2 != null)
				{
					await enumerator2.DisposeAsync();
				}
				if (enumerator3 != null)
				{
					await enumerator3.DisposeAsync();
				}
				if (enumerator4 != null)
				{
					await enumerator4.DisposeAsync();
				}
				if (enumerator5 != null)
				{
					await enumerator5.DisposeAsync();
				}
				if (enumerator6 != null)
				{
					await enumerator6.DisposeAsync();
				}
				if (enumerator7 != null)
				{
					await enumerator7.DisposeAsync();
				}
				if (enumerator8 != null)
				{
					await enumerator8.DisposeAsync();
				}
				if (enumerator9 != null)
				{
					await enumerator9.DisposeAsync();
				}
				if (enumerator10 != null)
				{
					await enumerator10.DisposeAsync();
				}
				if (enumerator11 != null)
				{
					await enumerator11.DisposeAsync();
				}
				if (enumerator12 != null)
				{
					await enumerator12.DisposeAsync();
				}
				if (enumerator13 != null)
				{
					await enumerator13.DisposeAsync();
				}
				if (enumerator14 != null)
				{
					await enumerator14.DisposeAsync();
				}
				if (enumerator15 != null)
				{
					await enumerator15.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T1> source1;

		private readonly IUniTaskAsyncEnumerable<T2> source2;

		private readonly IUniTaskAsyncEnumerable<T3> source3;

		private readonly IUniTaskAsyncEnumerable<T4> source4;

		private readonly IUniTaskAsyncEnumerable<T5> source5;

		private readonly IUniTaskAsyncEnumerable<T6> source6;

		private readonly IUniTaskAsyncEnumerable<T7> source7;

		private readonly IUniTaskAsyncEnumerable<T8> source8;

		private readonly IUniTaskAsyncEnumerable<T9> source9;

		private readonly IUniTaskAsyncEnumerable<T10> source10;

		private readonly IUniTaskAsyncEnumerable<T11> source11;

		private readonly IUniTaskAsyncEnumerable<T12> source12;

		private readonly IUniTaskAsyncEnumerable<T13> source13;

		private readonly IUniTaskAsyncEnumerable<T14> source14;

		private readonly IUniTaskAsyncEnumerable<T15> source15;

		private readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector;

		public CombineLatest(IUniTaskAsyncEnumerable<T1> source1, IUniTaskAsyncEnumerable<T2> source2, IUniTaskAsyncEnumerable<T3> source3, IUniTaskAsyncEnumerable<T4> source4, IUniTaskAsyncEnumerable<T5> source5, IUniTaskAsyncEnumerable<T6> source6, IUniTaskAsyncEnumerable<T7> source7, IUniTaskAsyncEnumerable<T8> source8, IUniTaskAsyncEnumerable<T9> source9, IUniTaskAsyncEnumerable<T10> source10, IUniTaskAsyncEnumerable<T11> source11, IUniTaskAsyncEnumerable<T12> source12, IUniTaskAsyncEnumerable<T13> source13, IUniTaskAsyncEnumerable<T14> source14, IUniTaskAsyncEnumerable<T15> source15, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> resultSelector)
		{
			this.source1 = source1;
			this.source2 = source2;
			this.source3 = source3;
			this.source4 = source4;
			this.source5 = source5;
			this.source6 = source6;
			this.source7 = source7;
			this.source8 = source8;
			this.source9 = source9;
			this.source10 = source10;
			this.source11 = source11;
			this.source12 = source12;
			this.source13 = source13;
			this.source14 = source14;
			this.source15 = source15;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, source15, resultSelector, cancellationToken);
		}
	}
	internal sealed class Concat<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Concat : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private enum IteratingState
			{
				IteratingFirst,
				IteratingSecond,
				Complete
			}

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> first;

			private readonly IUniTaskAsyncEnumerable<TSource> second;

			private CancellationToken cancellationToken;

			private IteratingState iteratingState;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TSource Current { get; private set; }

			public _Concat(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, CancellationToken cancellationToken)
			{
				this.first = first;
				this.second = second;
				this.cancellationToken = cancellationToken;
				iteratingState = IteratingState.IteratingFirst;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (iteratingState == IteratingState.Complete)
				{
					return CompletedTasks.False;
				}
				completionSource.Reset();
				StartIterate();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void StartIterate()
			{
				if (enumerator == null)
				{
					if (iteratingState == IteratingState.IteratingFirst)
					{
						enumerator = first.GetAsyncEnumerator(cancellationToken);
					}
					else if (iteratingState == IteratingState.IteratingSecond)
					{
						enumerator = second.GetAsyncEnumerator(cancellationToken);
					}
				}
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (awaiter.IsCompleted)
				{
					MoveNextCoreDelegate(this);
				}
				else
				{
					awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
				}
			}

			private static void MoveNextCore(object state)
			{
				_Concat concat = (_Concat)state;
				if (concat.TryGetResult(concat.awaiter, out var result))
				{
					if (result)
					{
						concat.Current = concat.enumerator.Current;
						concat.completionSource.TrySetResult(result: true);
					}
					else if (concat.iteratingState == IteratingState.IteratingFirst)
					{
						concat.RunSecondAfterDisposeAsync().Forget();
					}
					else
					{
						concat.iteratingState = IteratingState.Complete;
						concat.completionSource.TrySetResult(result: false);
					}
				}
			}

			private async UniTaskVoid RunSecondAfterDisposeAsync()
			{
				try
				{
					await enumerator.DisposeAsync();
					enumerator = null;
					awaiter = default(UniTask<bool>.Awaiter);
					iteratingState = IteratingState.IteratingSecond;
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
				StartIterate();
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> first;

		private readonly IUniTaskAsyncEnumerable<TSource> second;

		public Concat(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second)
		{
			this.first = first;
			this.second = second;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Concat(first, second, cancellationToken);
		}
	}
	internal static class Contains
	{
		internal static async UniTask<bool> ContainsAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (comparer.Equals(value, e.Current))
						{
							result = true;
							break;
						}
						continue;
					}
					result = false;
					break;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class Count
	{
		internal static async UniTask<int> CountAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			int count = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}

		internal static async UniTask<int> CountAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
		{
			int count = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					if (predicate(e.Current))
					{
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}

		internal static async UniTask<int> CountAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			int count = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					if (await predicate(e.Current))
					{
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}

		internal static async UniTask<int> CountAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			int count = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					if (await predicate(e.Current, cancellationToken))
					{
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}
	}
	public interface IAsyncWriter<T>
	{
		UniTask YieldAsync(T value);
	}
	internal sealed class Create<T> : IUniTaskAsyncEnumerable<T>
	{
		private sealed class _Create : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private readonly Func<IAsyncWriter<T>, CancellationToken, UniTask> create;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private AsyncWriter writer;

			public T Current { get; private set; }

			public _Create(Func<IAsyncWriter<T>, CancellationToken, UniTask> create, CancellationToken cancellationToken)
			{
				this.create = create;
				this.cancellationToken = cancellationToken;
			}

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

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					case -1:
						writer = new AsyncWriter(this);
						RunWriterTask(create(writer, cancellationToken)).Forget();
						if (Volatile.Read(ref state) != -2)
						{
							state = 0;
						}
						return;
					case 0:
						writer.SignalWriter();
						return;
					}
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
			}

			private async UniTaskVoid RunWriterTask(UniTask task)
			{
				try
				{
					await task;
				}
				catch (Exception error)
				{
					Volatile.Write(ref state, -2);
					completionSource.TrySetException(error);
					return;
				}
				Volatile.Write(ref state, -2);
				completionSource.TrySetResult(result: false);
			}

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

		private sealed class AsyncWriter : IUniTaskSource, IAsyncWriter<T>, IDisposable
		{
			private readonly _Create enumerator;

			private UniTaskCompletionSourceCore<AsyncUnit> core;

			public AsyncWriter(_Create enumerator)
			{
				this.enumerator = enumerator;
			}

			public void Dispose()
			{
				if (core.GetStatus(core.Version) == UniTaskStatus.Pending)
				{
					core.TrySetCanceled();
				}
			}

			public void GetResult(short token)
			{
				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 UniTask YieldAsync(T value)
			{
				core.Reset();
				enumerator.SetResult(value);
				return new UniTask(this, core.Version);
			}

			public void SignalWriter()
			{
				core.TrySetResult(AsyncUnit.Default);
			}
		}

		private readonly Func<IAsyncWriter<T>, CancellationToken, UniTask> create;

		public Create(Func<IAsyncWriter<T>, CancellationToken, UniTask> create)
		{
			this.create = create;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Create(create, cancellationToken);
		}
	}
	internal sealed class DefaultIfEmpty<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _DefaultIfEmpty : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private enum IteratingState : byte
			{
				Empty,
				Iterating,
				Completed
			}

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly TSource defaultValue;

			private CancellationToken cancellationToken;

			private IteratingState iteratingState;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TSource Current { get; private set; }

			public _DefaultIfEmpty(IUniTaskAsyncEnumerable<TSource> source, TSource defaultValue, CancellationToken cancellationToken)
			{
				this.source = source;
				this.defaultValue = defaultValue;
				this.cancellationToken = cancellationToken;
				iteratingState = IteratingState.Empty;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (iteratingState == IteratingState.Completed)
				{
					return CompletedTasks.False;
				}
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken);
				}
				awaiter = enumerator.MoveNextAsync().GetAwaiter();
				if (awaiter.IsCompleted)
				{
					MoveNextCore(this);
				}
				else
				{
					awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void MoveNextCore(object state)
			{
				_DefaultIfEmpty defaultIfEmpty = (_DefaultIfEmpty)state;
				if (defaultIfEmpty.TryGetResult(defaultIfEmpty.awaiter, out var result))
				{
					if (result)
					{
						defaultIfEmpty.iteratingState = IteratingState.Iterating;
						defaultIfEmpty.Current = defaultIfEmpty.enumerator.Current;
						defaultIfEmpty.completionSource.TrySetResult(result: true);
					}
					else if (defaultIfEmpty.iteratingState == IteratingState.Empty)
					{
						defaultIfEmpty.iteratingState = IteratingState.Completed;
						defaultIfEmpty.Current = defaultIfEmpty.defaultValue;
						defaultIfEmpty.completionSource.TrySetResult(result: true);
					}
					else
					{
						defaultIfEmpty.completionSource.TrySetResult(result: false);
					}
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly TSource defaultValue;

		public DefaultIfEmpty(IUniTaskAsyncEnumerable<TSource> source, TSource defaultValue)
		{
			this.source = source;
			this.defaultValue = defaultValue;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DefaultIfEmpty(source, defaultValue, cancellationToken);
		}
	}
	internal sealed class Distinct<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _Distinct : AsyncEnumeratorBase<TSource, TSource>
		{
			private readonly HashSet<TSource> set;

			public _Distinct(IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				set = new HashSet<TSource>(comparer);
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					TSource sourceCurrent = base.SourceCurrent;
					if (set.Add(sourceCurrent))
					{
						base.Current = sourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly IEqualityComparer<TSource> comparer;

		public Distinct(IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			this.source = source;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Distinct(source, comparer, cancellationToken);
		}
	}
	internal sealed class Distinct<TSource, TKey> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _Distinct : AsyncEnumeratorBase<TSource, TSource>
		{
			private readonly HashSet<TKey> set;

			private readonly Func<TSource, TKey> keySelector;

			public _Distinct(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				set = new HashSet<TKey>(comparer);
				this.keySelector = keySelector;
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					TSource sourceCurrent = base.SourceCurrent;
					if (set.Add(keySelector(sourceCurrent)))
					{
						base.Current = sourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, TKey> keySelector;

		private readonly IEqualityComparer<TKey> comparer;

		public Distinct(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Distinct(source, keySelector, comparer, cancellationToken);
		}
	}
	internal sealed class DistinctAwait<TSource, TKey> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _DistinctAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, TKey>
		{
			private readonly HashSet<TKey> set;

			private readonly Func<TSource, UniTask<TKey>> keySelector;

			public _DistinctAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				set = new HashSet<TKey>(comparer);
				this.keySelector = keySelector;
			}

			protected override UniTask<TKey> TransformAsync(TSource sourceCurrent)
			{
				return keySelector(sourceCurrent);
			}

			protected override bool TrySetCurrentCore(TKey awaitResult, out bool terminateIteration)
			{
				if (set.Add(awaitResult))
				{
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = false;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<TKey>> keySelector;

		private readonly IEqualityComparer<TKey> comparer;

		public DistinctAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DistinctAwait(source, keySelector, comparer, cancellationToken);
		}
	}
	internal sealed class DistinctAwaitWithCancellation<TSource, TKey> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _DistinctAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, TKey>
		{
			private readonly HashSet<TKey> set;

			private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

			public _DistinctAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				set = new HashSet<TKey>(comparer);
				this.keySelector = keySelector;
			}

			protected override UniTask<TKey> TransformAsync(TSource sourceCurrent)
			{
				return keySelector(sourceCurrent, cancellationToken);
			}

			protected override bool TrySetCurrentCore(TKey awaitResult, out bool terminateIteration)
			{
				if (set.Add(awaitResult))
				{
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = false;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

		private readonly IEqualityComparer<TKey> comparer;

		public DistinctAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DistinctAwaitWithCancellation(source, keySelector, comparer, cancellationToken);
		}
	}
	internal sealed class DistinctUntilChanged<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _DistinctUntilChanged : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly IEqualityComparer<TSource> comparer;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Action moveNextAction;

			public TSource Current { get; private set; }

			public _DistinctUntilChanged(IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = -3;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case -3;
						case -3:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								goto end_IL_0001_2;
							}
							goto end_IL_0001;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						case 1:
							break;
						case -2:
							goto end_IL_0001;
						}
						if (awaiter.GetResult())
						{
							TSource current = enumerator.Current;
							if (!comparer.Equals(Current, current))
							{
								Current = current;
								break;
							}
							state = 0;
							continue;
						}
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
					continue;
					end_IL_0001_2:
					break;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly IEqualityComparer<TSource> comparer;

		public DistinctUntilChanged(IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			this.source = source;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DistinctUntilChanged(source, comparer, cancellationToken);
		}
	}
	internal sealed class DistinctUntilChanged<TSource, TKey> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _DistinctUntilChanged : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, TKey> keySelector;

			private readonly IEqualityComparer<TKey> comparer;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Action moveNextAction;

			private TKey prev;

			public TSource Current { get; private set; }

			public _DistinctUntilChanged(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = -3;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case -3;
						case -3:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								goto end_IL_0001_2;
							}
							goto end_IL_0001;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						case 1:
							break;
						case -2:
							goto end_IL_0001;
						}
						if (awaiter.GetResult())
						{
							TSource current = enumerator.Current;
							TKey y = keySelector(current);
							if (!comparer.Equals(prev, y))
							{
								prev = y;
								Current = current;
								break;
							}
							state = 0;
							continue;
						}
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
					continue;
					end_IL_0001_2:
					break;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, TKey> keySelector;

		private readonly IEqualityComparer<TKey> comparer;

		public DistinctUntilChanged(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DistinctUntilChanged(source, keySelector, comparer, cancellationToken);
		}
	}
	internal sealed class DistinctUntilChangedAwait<TSource, TKey> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _DistinctUntilChangedAwait : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, UniTask<TKey>> keySelector;

			private readonly IEqualityComparer<TKey> comparer;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TKey>.Awaiter awaiter2;

			private Action moveNextAction;

			private TSource enumeratorCurrent;

			private TKey prev;

			public TSource Current { get; private set; }

			public _DistinctUntilChangedAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = -3;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case -3;
						case -3:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								goto end_IL_0001_2;
							}
							goto end_IL_0001;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case 1;
						case 1:
							if (awaiter.GetResult())
							{
								enumeratorCurrent = enumerator.Current;
								awaiter2 = keySelector(enumeratorCurrent).GetAwaiter();
								if (!awaiter2.IsCompleted)
								{
									state = 2;
									awaiter2.UnsafeOnCompleted(moveNextAction);
									return;
								}
								break;
							}
							goto end_IL_0001;
						case 2:
							break;
						case -2:
							goto end_IL_0001;
						}
						TKey result = awaiter2.GetResult();
						if (!comparer.Equals(prev, result))
						{
							prev = result;
							Current = enumeratorCurrent;
							break;
						}
						state = 0;
						continue;
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
					continue;
					end_IL_0001_2:
					break;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<TKey>> keySelector;

		private readonly IEqualityComparer<TKey> comparer;

		public DistinctUntilChangedAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DistinctUntilChangedAwait(source, keySelector, comparer, cancellationToken);
		}
	}
	internal sealed class DistinctUntilChangedAwaitWithCancellation<TSource, TKey> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _DistinctUntilChangedAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

			private readonly IEqualityComparer<TKey> comparer;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TKey>.Awaiter awaiter2;

			private Action moveNextAction;

			private TSource enumeratorCurrent;

			private TKey prev;

			public TSource Current { get; private set; }

			public _DistinctUntilChangedAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = -3;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case -3;
						case -3:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								goto end_IL_0001_2;
							}
							goto end_IL_0001;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case 1;
						case 1:
							if (awaiter.GetResult())
							{
								enumeratorCurrent = enumerator.Current;
								awaiter2 = keySelector(enumeratorCurrent, cancellationToken).GetAwaiter();
								if (!awaiter2.IsCompleted)
								{
									state = 2;
									awaiter2.UnsafeOnCompleted(moveNextAction);
									return;
								}
								break;
							}
							goto end_IL_0001;
						case 2:
							break;
						case -2:
							goto end_IL_0001;
						}
						TKey result = awaiter2.GetResult();
						if (!comparer.Equals(prev, result))
						{
							prev = result;
							Current = enumeratorCurrent;
							break;
						}
						state = 0;
						continue;
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
					continue;
					end_IL_0001_2:
					break;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

		private readonly IEqualityComparer<TKey> comparer;

		public DistinctUntilChangedAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _DistinctUntilChangedAwaitWithCancellation(source, keySelector, comparer, cancellationToken);
		}
	}
	internal sealed class Do<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Do : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Action<TSource> onNext;

			private readonly Action<Exception> onError;

			private readonly Action onCompleted;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TSource Current { get; private set; }

			public _Do(IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted, CancellationToken cancellationToken)
			{
				this.source = source;
				this.onNext = onNext;
				this.onError = onError;
				this.onCompleted = onCompleted;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				bool flag = false;
				try
				{
					if (enumerator == null)
					{
						enumerator = source.GetAsyncEnumerator(cancellationToken);
					}
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					flag = awaiter.IsCompleted;
				}
				catch (Exception ex)
				{
					CallTrySetExceptionAfterNotification(ex);
					return new UniTask<bool>(this, completionSource.Version);
				}
				if (flag)
				{
					MoveNextCore(this);
				}
				else
				{
					awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void CallTrySetExceptionAfterNotification(Exception ex)
			{
				if (onError != null)
				{
					try
					{
						onError(ex);
					}
					catch (Exception error)
					{
						completionSource.TrySetException(error);
						return;
					}
				}
				completionSource.TrySetException(ex);
			}

			private bool TryGetResultWithNotification<T>(UniTask<T>.Awaiter awaiter, out T result)
			{
				try
				{
					result = awaiter.GetResult();
					return true;
				}
				catch (Exception ex)
				{
					CallTrySetExceptionAfterNotification(ex);
					result = default(T);
					return false;
				}
			}

			private static void MoveNextCore(object state)
			{
				_Do @do = (_Do)state;
				if (!@do.TryGetResultWithNotification(@do.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					TSource current = @do.enumerator.Current;
					if (@do.onNext != null)
					{
						try
						{
							@do.onNext(current);
						}
						catch (Exception ex)
						{
							@do.CallTrySetExceptionAfterNotification(ex);
						}
					}
					@do.Current = current;
					@do.completionSource.TrySetResult(result: true);
					return;
				}
				if (@do.onCompleted != null)
				{
					try
					{
						@do.onCompleted();
					}
					catch (Exception ex2)
					{
						@do.CallTrySetExceptionAfterNotification(ex2);
						return;
					}
				}
				@do.completionSource.TrySetResult(result: false);
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Action<TSource> onNext;

		private readonly Action<Exception> onError;

		private readonly Action onCompleted;

		public Do(IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted)
		{
			this.source = source;
			this.onNext = onNext;
			this.onError = onError;
			this.onCompleted = onCompleted;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Do(source, onNext, onError, onCompleted, cancellationToken);
		}
	}
	internal static class ElementAt
	{
		public static async UniTask<TSource> ElementAtAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, int index, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				int i = 0;
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						if (i++ == index)
						{
							result = e.Current;
							break;
						}
						continue;
					}
					if (defaultIfEmpty)
					{
						result = default(TSource);
						break;
					}
					throw Error.ArgumentOutOfRange("index");
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal class Empty<T> : IUniTaskAsyncEnumerable<T>
	{
		private class _Empty : IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			public static readonly IUniTaskAsyncEnumerator<T> Instance = new _Empty();

			public T Current => default(T);

			private _Empty()
			{
			}

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

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		public static readonly IUniTaskAsyncEnumerable<T> Instance = new Empty<T>();

		private Empty()
		{
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return _Empty.Instance;
		}
	}
	internal sealed class Except<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _Except : AsyncEnumeratorBase<TSource, TSource>
		{
			private static Action<object> HashSetAsyncCoreDelegate = HashSetAsyncCore;

			private readonly IEqualityComparer<TSource> comparer;

			private readonly IUniTaskAsyncEnumerable<TSource> second;

			private HashSet<TSource> set;

			private UniTask<HashSet<TSource>>.Awaiter awaiter;

			public _Except(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
				: base(first, cancellationToken)
			{
				this.second = second;
				this.comparer = comparer;
			}

			protected override bool OnFirstIteration()
			{
				if (set != null)
				{
					return false;
				}
				awaiter = second.ToHashSetAsync(cancellationToken).GetAwaiter();
				if (awaiter.IsCompleted)
				{
					set = awaiter.GetResult();
					SourceMoveNext();
				}
				else
				{
					awaiter.SourceOnCompleted(HashSetAsyncCoreDelegate, this);
				}
				return true;
			}

			private static void HashSetAsyncCore(object state)
			{
				_Except except = (_Except)state;
				if (except.TryGetResult(except.awaiter, out var result))
				{
					except.set = result;
					except.SourceMoveNext();
				}
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					TSource sourceCurrent = base.SourceCurrent;
					if (set.Add(sourceCurrent))
					{
						base.Current = sourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> first;

		private readonly IUniTaskAsyncEnumerable<TSource> second;

		private readonly IEqualityComparer<TSource> comparer;

		public Except(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			this.first = first;
			this.second = second;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Except(first, second, comparer, cancellationToken);
		}
	}
	internal static class First
	{
		public static async UniTask<TSource> FirstAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (await e.MoveNextAsync())
				{
					result = e.Current;
				}
				else
				{
					if (!defaultIfEmpty)
					{
						throw Error.NoElements();
					}
					result = default(TSource);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> FirstAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						TSource current = e.Current;
						if (predicate(current))
						{
							result = current;
							break;
						}
						continue;
					}
					if (defaultIfEmpty)
					{
						result = default(TSource);
						break;
					}
					throw Error.NoElements();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> FirstAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						TSource v = e.Current;
						if (await predicate(v))
						{
							result = v;
							break;
						}
						continue;
					}
					if (defaultIfEmpty)
					{
						result = default(TSource);
						break;
					}
					throw Error.NoElements();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> FirstAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				while (true)
				{
					if (await e.MoveNextAsync())
					{
						TSource v = e.Current;
						if (await predicate(v, cancellationToken))
						{
							result = v;
							break;
						}
						continue;
					}
					if (defaultIfEmpty)
					{
						result = default(TSource);
						break;
					}
					throw Error.NoElements();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class ForEach
	{
		public static async UniTask ForEachAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Action<TSource> action, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					action(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTask ForEachAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Action<TSource, int> action, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				int index = 0;
				while (await e.MoveNextAsync())
				{
					action(e.Current, checked(index++));
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTask ForEachAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> action, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					await action(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTask ForEachAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask> action, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				int index = 0;
				while (await e.MoveNextAsync())
				{
					await action(e.Current, checked(index++));
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTask ForEachAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> action, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					await action(e.Current, cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTask ForEachAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask> action, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				int index = 0;
				while (await e.MoveNextAsync())
				{
					await action(e.Current, checked(index++), cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}
	}
	internal sealed class GroupBy<TSource, TKey, TElement> : IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>>
	{
		private sealed class _GroupBy : MoveNextSource, IUniTaskAsyncEnumerator<IGrouping<TKey, TElement>>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, TKey> keySelector;

			private readonly Func<TSource, TElement> elementSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private IEnumerator<IGrouping<TKey, TElement>> groupEnumerator;

			public IGrouping<TKey, TElement> Current { get; private set; }

			public _GroupBy(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.elementSelector = elementSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (groupEnumerator == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					groupEnumerator = (await source.ToLookupAsync(keySelector, elementSelector, comparer, cancellationToken)).GetEnumerator();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					if (groupEnumerator.MoveNext())
					{
						Current = groupEnumerator.Current;
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			public UniTask DisposeAsync()
			{
				if (groupEnumerator != null)
				{
					groupEnumerator.Dispose();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, TKey> keySelector;

		private readonly Func<TSource, TElement> elementSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupBy(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.elementSelector = elementSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<IGrouping<TKey, TElement>> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupBy(source, keySelector, elementSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupBy<TSource, TKey, TElement, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _GroupBy : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, TKey> keySelector;

			private readonly Func<TSource, TElement> elementSelector;

			private readonly Func<TKey, IEnumerable<TElement>, TResult> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private IEnumerator<IGrouping<TKey, TElement>> groupEnumerator;

			public TResult Current { get; private set; }

			public _GroupBy(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.elementSelector = elementSelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (groupEnumerator == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					groupEnumerator = (await source.ToLookupAsync(keySelector, elementSelector, comparer, cancellationToken)).GetEnumerator();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					if (groupEnumerator.MoveNext())
					{
						IGrouping<TKey, TElement> current = groupEnumerator.Current;
						Current = resultSelector(current.Key, current);
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			public UniTask DisposeAsync()
			{
				if (groupEnumerator != null)
				{
					groupEnumerator.Dispose();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, TKey> keySelector;

		private readonly Func<TSource, TElement> elementSelector;

		private readonly Func<TKey, IEnumerable<TElement>, TResult> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupBy(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.elementSelector = elementSelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupBy(source, keySelector, elementSelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupByAwait<TSource, TKey, TElement> : IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>>
	{
		private sealed class _GroupByAwait : MoveNextSource, IUniTaskAsyncEnumerator<IGrouping<TKey, TElement>>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, UniTask<TKey>> keySelector;

			private readonly Func<TSource, UniTask<TElement>> elementSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private IEnumerator<IGrouping<TKey, TElement>> groupEnumerator;

			public IGrouping<TKey, TElement> Current { get; private set; }

			public _GroupByAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.elementSelector = elementSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (groupEnumerator == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					groupEnumerator = (await source.ToLookupAwaitAsync(keySelector, elementSelector, comparer, cancellationToken)).GetEnumerator();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					if (groupEnumerator.MoveNext())
					{
						Current = groupEnumerator.Current;
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			public UniTask DisposeAsync()
			{
				if (groupEnumerator != null)
				{
					groupEnumerator.Dispose();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<TKey>> keySelector;

		private readonly Func<TSource, UniTask<TElement>> elementSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupByAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.elementSelector = elementSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<IGrouping<TKey, TElement>> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupByAwait(source, keySelector, elementSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupByAwait<TSource, TKey, TElement, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _GroupByAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> ResultSelectCoreDelegate = ResultSelectCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, UniTask<TKey>> keySelector;

			private readonly Func<TSource, UniTask<TElement>> elementSelector;

			private readonly Func<TKey, IEnumerable<TElement>, UniTask<TResult>> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private IEnumerator<IGrouping<TKey, TElement>> groupEnumerator;

			private UniTask<TResult>.Awaiter awaiter;

			public TResult Current { get; private set; }

			public _GroupByAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.elementSelector = elementSelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (groupEnumerator == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					groupEnumerator = (await source.ToLookupAwaitAsync(keySelector, elementSelector, comparer, cancellationToken)).GetEnumerator();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					if (groupEnumerator.MoveNext())
					{
						IGrouping<TKey, TElement> current = groupEnumerator.Current;
						awaiter = resultSelector(current.Key, current).GetAwaiter();
						if (awaiter.IsCompleted)
						{
							ResultSelectCore(this);
						}
						else
						{
							awaiter.SourceOnCompleted(ResultSelectCoreDelegate, this);
						}
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void ResultSelectCore(object state)
			{
				_GroupByAwait groupByAwait = (_GroupByAwait)state;
				if (groupByAwait.TryGetResult(groupByAwait.awaiter, out var result))
				{
					groupByAwait.Current = result;
					groupByAwait.completionSource.TrySetResult(result: true);
				}
			}

			public UniTask DisposeAsync()
			{
				if (groupEnumerator != null)
				{
					groupEnumerator.Dispose();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<TKey>> keySelector;

		private readonly Func<TSource, UniTask<TElement>> elementSelector;

		private readonly Func<TKey, IEnumerable<TElement>, UniTask<TResult>> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupByAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.elementSelector = elementSelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupByAwait(source, keySelector, elementSelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupByAwaitWithCancellation<TSource, TKey, TElement> : IUniTaskAsyncEnumerable<IGrouping<TKey, TElement>>
	{
		private sealed class _GroupByAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<IGrouping<TKey, TElement>>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

			private readonly Func<TSource, CancellationToken, UniTask<TElement>> elementSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private IEnumerator<IGrouping<TKey, TElement>> groupEnumerator;

			public IGrouping<TKey, TElement> Current { get; private set; }

			public _GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.elementSelector = elementSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (groupEnumerator == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					groupEnumerator = (await source.ToLookupAwaitWithCancellationAsync(keySelector, elementSelector, comparer, cancellationToken)).GetEnumerator();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					if (groupEnumerator.MoveNext())
					{
						Current = groupEnumerator.Current;
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			public UniTask DisposeAsync()
			{
				if (groupEnumerator != null)
				{
					groupEnumerator.Dispose();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

		private readonly Func<TSource, CancellationToken, UniTask<TElement>> elementSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.elementSelector = elementSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<IGrouping<TKey, TElement>> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupByAwaitWithCancellation(source, keySelector, elementSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _GroupByAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> ResultSelectCoreDelegate = ResultSelectCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

			private readonly Func<TSource, CancellationToken, UniTask<TElement>> elementSelector;

			private readonly Func<TKey, IEnumerable<TElement>, CancellationToken, UniTask<TResult>> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private IEnumerator<IGrouping<TKey, TElement>> groupEnumerator;

			private UniTask<TResult>.Awaiter awaiter;

			public TResult Current { get; private set; }

			public _GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.source = source;
				this.keySelector = keySelector;
				this.elementSelector = elementSelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (groupEnumerator == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					groupEnumerator = (await source.ToLookupAwaitWithCancellationAsync(keySelector, elementSelector, comparer, cancellationToken)).GetEnumerator();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					if (groupEnumerator.MoveNext())
					{
						IGrouping<TKey, TElement> current = groupEnumerator.Current;
						awaiter = resultSelector(current.Key, current, cancellationToken).GetAwaiter();
						if (awaiter.IsCompleted)
						{
							ResultSelectCore(this);
						}
						else
						{
							awaiter.SourceOnCompleted(ResultSelectCoreDelegate, this);
						}
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void ResultSelectCore(object state)
			{
				_GroupByAwaitWithCancellation groupByAwaitWithCancellation = (_GroupByAwaitWithCancellation)state;
				if (groupByAwaitWithCancellation.TryGetResult(groupByAwaitWithCancellation.awaiter, out var result))
				{
					groupByAwaitWithCancellation.Current = result;
					groupByAwaitWithCancellation.completionSource.TrySetResult(result: true);
				}
			}

			public UniTask DisposeAsync()
			{
				if (groupEnumerator != null)
				{
					groupEnumerator.Dispose();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;

		private readonly Func<TSource, CancellationToken, UniTask<TElement>> elementSelector;

		private readonly Func<TKey, IEnumerable<TElement>, CancellationToken, UniTask<TResult>> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, Func<TKey, IEnumerable<TElement>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.source = source;
			this.keySelector = keySelector;
			this.elementSelector = elementSelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupByAwaitWithCancellation(source, keySelector, elementSelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupJoin<TOuter, TInner, TKey, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _GroupJoin : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TOuter> outer;

			private readonly IUniTaskAsyncEnumerable<TInner> inner;

			private readonly Func<TOuter, TKey> outerKeySelector;

			private readonly Func<TInner, TKey> innerKeySelector;

			private readonly Func<TOuter, IEnumerable<TInner>, TResult> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private ILookup<TKey, TInner> lookup;

			private IUniTaskAsyncEnumerator<TOuter> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TResult Current { get; private set; }

			public _GroupJoin(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.outer = outer;
				this.inner = inner;
				this.outerKeySelector = outerKeySelector;
				this.innerKeySelector = innerKeySelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (lookup == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					lookup = await inner.ToLookupAsync(innerKeySelector, comparer, cancellationToken);
					enumerator = outer.GetAsyncEnumerator(cancellationToken);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_GroupJoin groupJoin = (_GroupJoin)state;
				if (groupJoin.TryGetResult(groupJoin.awaiter, out var result))
				{
					if (result)
					{
						TOuter current = groupJoin.enumerator.Current;
						TKey key = groupJoin.outerKeySelector(current);
						IEnumerable<TInner> arg = groupJoin.lookup[key];
						groupJoin.Current = groupJoin.resultSelector(current, arg);
						groupJoin.completionSource.TrySetResult(result: true);
					}
					else
					{
						groupJoin.completionSource.TrySetResult(result: false);
					}
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TOuter> outer;

		private readonly IUniTaskAsyncEnumerable<TInner> inner;

		private readonly Func<TOuter, TKey> outerKeySelector;

		private readonly Func<TInner, TKey> innerKeySelector;

		private readonly Func<TOuter, IEnumerable<TInner>, TResult> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupJoin(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.outer = outer;
			this.inner = inner;
			this.outerKeySelector = outerKeySelector;
			this.innerKeySelector = innerKeySelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupJoin(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupJoinAwait<TOuter, TInner, TKey, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _GroupJoinAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private static readonly Action<object> ResultSelectCoreDelegate = ResultSelectCore;

			private static readonly Action<object> OuterKeySelectCoreDelegate = OuterKeySelectCore;

			private readonly IUniTaskAsyncEnumerable<TOuter> outer;

			private readonly IUniTaskAsyncEnumerable<TInner> inner;

			private readonly Func<TOuter, UniTask<TKey>> outerKeySelector;

			private readonly Func<TInner, UniTask<TKey>> innerKeySelector;

			private readonly Func<TOuter, IEnumerable<TInner>, UniTask<TResult>> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private ILookup<TKey, TInner> lookup;

			private IUniTaskAsyncEnumerator<TOuter> enumerator;

			private TOuter outerValue;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TKey>.Awaiter outerKeyAwaiter;

			private UniTask<TResult>.Awaiter resultAwaiter;

			public TResult Current { get; private set; }

			public _GroupJoinAwait(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.outer = outer;
				this.inner = inner;
				this.outerKeySelector = outerKeySelector;
				this.innerKeySelector = innerKeySelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (lookup == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					lookup = await inner.ToLookupAwaitAsync(innerKeySelector, comparer, cancellationToken);
					enumerator = outer.GetAsyncEnumerator(cancellationToken);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_GroupJoinAwait groupJoinAwait = (_GroupJoinAwait)state;
				if (!groupJoinAwait.TryGetResult(groupJoinAwait.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						groupJoinAwait.outerValue = groupJoinAwait.enumerator.Current;
						groupJoinAwait.outerKeyAwaiter = groupJoinAwait.outerKeySelector(groupJoinAwait.outerValue).GetAwaiter();
						if (groupJoinAwait.outerKeyAwaiter.IsCompleted)
						{
							OuterKeySelectCore(groupJoinAwait);
						}
						else
						{
							groupJoinAwait.outerKeyAwaiter.SourceOnCompleted(OuterKeySelectCoreDelegate, groupJoinAwait);
						}
						return;
					}
					catch (Exception error)
					{
						groupJoinAwait.completionSource.TrySetException(error);
						return;
					}
				}
				groupJoinAwait.completionSource.TrySetResult(result: false);
			}

			private static void OuterKeySelectCore(object state)
			{
				_GroupJoinAwait groupJoinAwait = (_GroupJoinAwait)state;
				if (!groupJoinAwait.TryGetResult(groupJoinAwait.outerKeyAwaiter, out var result))
				{
					return;
				}
				try
				{
					IEnumerable<TInner> arg = groupJoinAwait.lookup[result];
					groupJoinAwait.resultAwaiter = groupJoinAwait.resultSelector(groupJoinAwait.outerValue, arg).GetAwaiter();
					if (groupJoinAwait.resultAwaiter.IsCompleted)
					{
						ResultSelectCore(groupJoinAwait);
					}
					else
					{
						groupJoinAwait.resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, groupJoinAwait);
					}
				}
				catch (Exception error)
				{
					groupJoinAwait.completionSource.TrySetException(error);
				}
			}

			private static void ResultSelectCore(object state)
			{
				_GroupJoinAwait groupJoinAwait = (_GroupJoinAwait)state;
				if (groupJoinAwait.TryGetResult(groupJoinAwait.resultAwaiter, out var result))
				{
					groupJoinAwait.Current = result;
					groupJoinAwait.completionSource.TrySetResult(result: true);
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TOuter> outer;

		private readonly IUniTaskAsyncEnumerable<TInner> inner;

		private readonly Func<TOuter, UniTask<TKey>> outerKeySelector;

		private readonly Func<TInner, UniTask<TKey>> innerKeySelector;

		private readonly Func<TOuter, IEnumerable<TInner>, UniTask<TResult>> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupJoinAwait(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.outer = outer;
			this.inner = inner;
			this.outerKeySelector = outerKeySelector;
			this.innerKeySelector = innerKeySelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupJoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _GroupJoinAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private static readonly Action<object> ResultSelectCoreDelegate = ResultSelectCore;

			private static readonly Action<object> OuterKeySelectCoreDelegate = OuterKeySelectCore;

			private readonly IUniTaskAsyncEnumerable<TOuter> outer;

			private readonly IUniTaskAsyncEnumerable<TInner> inner;

			private readonly Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector;

			private readonly Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector;

			private readonly Func<TOuter, IEnumerable<TInner>, CancellationToken, UniTask<TResult>> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private ILookup<TKey, TInner> lookup;

			private IUniTaskAsyncEnumerator<TOuter> enumerator;

			private TOuter outerValue;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TKey>.Awaiter outerKeyAwaiter;

			private UniTask<TResult>.Awaiter resultAwaiter;

			public TResult Current { get; private set; }

			public _GroupJoinAwaitWithCancellation(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.outer = outer;
				this.inner = inner;
				this.outerKeySelector = outerKeySelector;
				this.innerKeySelector = innerKeySelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (lookup == null)
				{
					CreateLookup().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateLookup()
			{
				try
				{
					lookup = await inner.ToLookupAwaitWithCancellationAsync(innerKeySelector, comparer, cancellationToken);
					enumerator = outer.GetAsyncEnumerator(cancellationToken);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_GroupJoinAwaitWithCancellation groupJoinAwaitWithCancellation = (_GroupJoinAwaitWithCancellation)state;
				if (!groupJoinAwaitWithCancellation.TryGetResult(groupJoinAwaitWithCancellation.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						groupJoinAwaitWithCancellation.outerValue = groupJoinAwaitWithCancellation.enumerator.Current;
						groupJoinAwaitWithCancellation.outerKeyAwaiter = groupJoinAwaitWithCancellation.outerKeySelector(groupJoinAwaitWithCancellation.outerValue, groupJoinAwaitWithCancellation.cancellationToken).GetAwaiter();
						if (groupJoinAwaitWithCancellation.outerKeyAwaiter.IsCompleted)
						{
							OuterKeySelectCore(groupJoinAwaitWithCancellation);
						}
						else
						{
							groupJoinAwaitWithCancellation.outerKeyAwaiter.SourceOnCompleted(OuterKeySelectCoreDelegate, groupJoinAwaitWithCancellation);
						}
						return;
					}
					catch (Exception error)
					{
						groupJoinAwaitWithCancellation.completionSource.TrySetException(error);
						return;
					}
				}
				groupJoinAwaitWithCancellation.completionSource.TrySetResult(result: false);
			}

			private static void OuterKeySelectCore(object state)
			{
				_GroupJoinAwaitWithCancellation groupJoinAwaitWithCancellation = (_GroupJoinAwaitWithCancellation)state;
				if (!groupJoinAwaitWithCancellation.TryGetResult(groupJoinAwaitWithCancellation.outerKeyAwaiter, out var result))
				{
					return;
				}
				try
				{
					IEnumerable<TInner> arg = groupJoinAwaitWithCancellation.lookup[result];
					groupJoinAwaitWithCancellation.resultAwaiter = groupJoinAwaitWithCancellation.resultSelector(groupJoinAwaitWithCancellation.outerValue, arg, groupJoinAwaitWithCancellation.cancellationToken).GetAwaiter();
					if (groupJoinAwaitWithCancellation.resultAwaiter.IsCompleted)
					{
						ResultSelectCore(groupJoinAwaitWithCancellation);
					}
					else
					{
						groupJoinAwaitWithCancellation.resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, groupJoinAwaitWithCancellation);
					}
				}
				catch (Exception error)
				{
					groupJoinAwaitWithCancellation.completionSource.TrySetException(error);
				}
			}

			private static void ResultSelectCore(object state)
			{
				_GroupJoinAwaitWithCancellation groupJoinAwaitWithCancellation = (_GroupJoinAwaitWithCancellation)state;
				if (groupJoinAwaitWithCancellation.TryGetResult(groupJoinAwaitWithCancellation.resultAwaiter, out var result))
				{
					groupJoinAwaitWithCancellation.Current = result;
					groupJoinAwaitWithCancellation.completionSource.TrySetResult(result: true);
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TOuter> outer;

		private readonly IUniTaskAsyncEnumerable<TInner> inner;

		private readonly Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector;

		private readonly Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector;

		private readonly Func<TOuter, IEnumerable<TInner>, CancellationToken, UniTask<TResult>> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public GroupJoinAwaitWithCancellation(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, IEnumerable<TInner>, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.outer = outer;
			this.inner = inner;
			this.outerKeySelector = outerKeySelector;
			this.innerKeySelector = innerKeySelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _GroupJoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class Intersect<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _Intersect : AsyncEnumeratorBase<TSource, TSource>
		{
			private static Action<object> HashSetAsyncCoreDelegate = HashSetAsyncCore;

			private readonly IEqualityComparer<TSource> comparer;

			private readonly IUniTaskAsyncEnumerable<TSource> second;

			private HashSet<TSource> set;

			private UniTask<HashSet<TSource>>.Awaiter awaiter;

			public _Intersect(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
				: base(first, cancellationToken)
			{
				this.second = second;
				this.comparer = comparer;
			}

			protected override bool OnFirstIteration()
			{
				if (set != null)
				{
					return false;
				}
				awaiter = second.ToHashSetAsync(cancellationToken).GetAwaiter();
				if (awaiter.IsCompleted)
				{
					set = awaiter.GetResult();
					SourceMoveNext();
				}
				else
				{
					awaiter.SourceOnCompleted(HashSetAsyncCoreDelegate, this);
				}
				return true;
			}

			private static void HashSetAsyncCore(object state)
			{
				_Intersect intersect = (_Intersect)state;
				if (intersect.TryGetResult(intersect.awaiter, out var result))
				{
					intersect.set = result;
					intersect.SourceMoveNext();
				}
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					TSource sourceCurrent = base.SourceCurrent;
					if (set.Remove(sourceCurrent))
					{
						base.Current = sourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> first;

		private readonly IUniTaskAsyncEnumerable<TSource> second;

		private readonly IEqualityComparer<TSource> comparer;

		public Intersect(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			this.first = first;
			this.second = second;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Intersect(first, second, comparer, cancellationToken);
		}
	}
	internal sealed class Join<TOuter, TInner, TKey, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _Join : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TOuter> outer;

			private readonly IUniTaskAsyncEnumerable<TInner> inner;

			private readonly Func<TOuter, TKey> outerKeySelector;

			private readonly Func<TInner, TKey> innerKeySelector;

			private readonly Func<TOuter, TInner, TResult> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private ILookup<TKey, TInner> lookup;

			private IUniTaskAsyncEnumerator<TOuter> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private TOuter currentOuterValue;

			private IEnumerator<TInner> valueEnumerator;

			private bool continueNext;

			public TResult Current { get; private set; }

			public _Join(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.outer = outer;
				this.inner = inner;
				this.outerKeySelector = outerKeySelector;
				this.innerKeySelector = innerKeySelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (lookup == null)
				{
					CreateInnerHashSet().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateInnerHashSet()
			{
				try
				{
					lookup = await inner.ToLookupAsync(innerKeySelector, comparer, cancellationToken);
					enumerator = outer.GetAsyncEnumerator(cancellationToken);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					while (true)
					{
						if (valueEnumerator != null)
						{
							if (valueEnumerator.MoveNext())
							{
								break;
							}
							valueEnumerator.Dispose();
							valueEnumerator = null;
						}
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							return;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						return;
					}
					Current = resultSelector(currentOuterValue, valueEnumerator.Current);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				completionSource.TrySetResult(result: true);
			}

			private static void MoveNextCore(object state)
			{
				_Join join = (_Join)state;
				if (join.TryGetResult(join.awaiter, out var result))
				{
					if (result)
					{
						join.currentOuterValue = join.enumerator.Current;
						TKey key = join.outerKeySelector(join.currentOuterValue);
						join.valueEnumerator = join.lookup[key].GetEnumerator();
						if (!join.continueNext)
						{
							join.SourceMoveNext();
						}
					}
					else
					{
						join.continueNext = false;
						join.completionSource.TrySetResult(result: false);
					}
				}
				else
				{
					join.continueNext = false;
				}
			}

			public UniTask DisposeAsync()
			{
				if (valueEnumerator != null)
				{
					valueEnumerator.Dispose();
				}
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TOuter> outer;

		private readonly IUniTaskAsyncEnumerable<TInner> inner;

		private readonly Func<TOuter, TKey> outerKeySelector;

		private readonly Func<TInner, TKey> innerKeySelector;

		private readonly Func<TOuter, TInner, TResult> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public Join(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.outer = outer;
			this.inner = inner;
			this.outerKeySelector = outerKeySelector;
			this.innerKeySelector = innerKeySelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Join(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class JoinAwait<TOuter, TInner, TKey, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _JoinAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private static readonly Action<object> OuterSelectCoreDelegate = OuterSelectCore;

			private static readonly Action<object> ResultSelectCoreDelegate = ResultSelectCore;

			private readonly IUniTaskAsyncEnumerable<TOuter> outer;

			private readonly IUniTaskAsyncEnumerable<TInner> inner;

			private readonly Func<TOuter, UniTask<TKey>> outerKeySelector;

			private readonly Func<TInner, UniTask<TKey>> innerKeySelector;

			private readonly Func<TOuter, TInner, UniTask<TResult>> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private ILookup<TKey, TInner> lookup;

			private IUniTaskAsyncEnumerator<TOuter> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private TOuter currentOuterValue;

			private IEnumerator<TInner> valueEnumerator;

			private UniTask<TResult>.Awaiter resultAwaiter;

			private UniTask<TKey>.Awaiter outerKeyAwaiter;

			private bool continueNext;

			public TResult Current { get; private set; }

			public _JoinAwait(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.outer = outer;
				this.inner = inner;
				this.outerKeySelector = outerKeySelector;
				this.innerKeySelector = innerKeySelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (lookup == null)
				{
					CreateInnerHashSet().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateInnerHashSet()
			{
				try
				{
					lookup = await inner.ToLookupAwaitAsync(innerKeySelector, comparer, cancellationToken);
					enumerator = outer.GetAsyncEnumerator(cancellationToken);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					while (true)
					{
						if (valueEnumerator != null)
						{
							if (valueEnumerator.MoveNext())
							{
								resultAwaiter = resultSelector(currentOuterValue, valueEnumerator.Current).GetAwaiter();
								if (resultAwaiter.IsCompleted)
								{
									ResultSelectCore(this);
								}
								else
								{
									resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, this);
								}
								break;
							}
							valueEnumerator.Dispose();
							valueEnumerator = null;
						}
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_JoinAwait joinAwait = (_JoinAwait)state;
				if (joinAwait.TryGetResult(joinAwait.awaiter, out var result))
				{
					if (result)
					{
						joinAwait.currentOuterValue = joinAwait.enumerator.Current;
						joinAwait.outerKeyAwaiter = joinAwait.outerKeySelector(joinAwait.currentOuterValue).GetAwaiter();
						if (joinAwait.outerKeyAwaiter.IsCompleted)
						{
							OuterSelectCore(joinAwait);
							return;
						}
						joinAwait.continueNext = false;
						joinAwait.outerKeyAwaiter.SourceOnCompleted(OuterSelectCoreDelegate, joinAwait);
					}
					else
					{
						joinAwait.continueNext = false;
						joinAwait.completionSource.TrySetResult(result: false);
					}
				}
				else
				{
					joinAwait.continueNext = false;
				}
			}

			private static void OuterSelectCore(object state)
			{
				_JoinAwait joinAwait = (_JoinAwait)state;
				if (joinAwait.TryGetResult(joinAwait.outerKeyAwaiter, out var result))
				{
					joinAwait.valueEnumerator = joinAwait.lookup[result].GetEnumerator();
					if (!joinAwait.continueNext)
					{
						joinAwait.SourceMoveNext();
					}
				}
				else
				{
					joinAwait.continueNext = false;
				}
			}

			private static void ResultSelectCore(object state)
			{
				_JoinAwait joinAwait = (_JoinAwait)state;
				if (joinAwait.TryGetResult(joinAwait.resultAwaiter, out var result))
				{
					joinAwait.Current = result;
					joinAwait.completionSource.TrySetResult(result: true);
				}
			}

			public UniTask DisposeAsync()
			{
				if (valueEnumerator != null)
				{
					valueEnumerator.Dispose();
				}
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TOuter> outer;

		private readonly IUniTaskAsyncEnumerable<TInner> inner;

		private readonly Func<TOuter, UniTask<TKey>> outerKeySelector;

		private readonly Func<TInner, UniTask<TKey>> innerKeySelector;

		private readonly Func<TOuter, TInner, UniTask<TResult>> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public JoinAwait(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, UniTask<TKey>> outerKeySelector, Func<TInner, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.outer = outer;
			this.inner = inner;
			this.outerKeySelector = outerKeySelector;
			this.innerKeySelector = innerKeySelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _JoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal sealed class JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _JoinAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private static readonly Action<object> OuterSelectCoreDelegate = OuterSelectCore;

			private static readonly Action<object> ResultSelectCoreDelegate = ResultSelectCore;

			private readonly IUniTaskAsyncEnumerable<TOuter> outer;

			private readonly IUniTaskAsyncEnumerable<TInner> inner;

			private readonly Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector;

			private readonly Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector;

			private readonly Func<TOuter, TInner, CancellationToken, UniTask<TResult>> resultSelector;

			private readonly IEqualityComparer<TKey> comparer;

			private CancellationToken cancellationToken;

			private ILookup<TKey, TInner> lookup;

			private IUniTaskAsyncEnumerator<TOuter> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private TOuter currentOuterValue;

			private IEnumerator<TInner> valueEnumerator;

			private UniTask<TResult>.Awaiter resultAwaiter;

			private UniTask<TKey>.Awaiter outerKeyAwaiter;

			private bool continueNext;

			public TResult Current { get; private set; }

			public _JoinAwaitWithCancellation(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				this.outer = outer;
				this.inner = inner;
				this.outerKeySelector = outerKeySelector;
				this.innerKeySelector = innerKeySelector;
				this.resultSelector = resultSelector;
				this.comparer = comparer;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				if (lookup == null)
				{
					CreateInnerHashSet().Forget();
				}
				else
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private async UniTaskVoid CreateInnerHashSet()
			{
				try
				{
					lookup = await inner.ToLookupAwaitWithCancellationAsync(innerKeySelector, comparer, cancellationToken);
					enumerator = outer.GetAsyncEnumerator(cancellationToken);
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				SourceMoveNext();
			}

			private void SourceMoveNext()
			{
				try
				{
					while (true)
					{
						if (valueEnumerator != null)
						{
							if (valueEnumerator.MoveNext())
							{
								resultAwaiter = resultSelector(currentOuterValue, valueEnumerator.Current, cancellationToken).GetAwaiter();
								if (resultAwaiter.IsCompleted)
								{
									ResultSelectCore(this);
								}
								else
								{
									resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, this);
								}
								break;
							}
							valueEnumerator.Dispose();
							valueEnumerator = null;
						}
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_JoinAwaitWithCancellation joinAwaitWithCancellation = (_JoinAwaitWithCancellation)state;
				if (joinAwaitWithCancellation.TryGetResult(joinAwaitWithCancellation.awaiter, out var result))
				{
					if (result)
					{
						joinAwaitWithCancellation.currentOuterValue = joinAwaitWithCancellation.enumerator.Current;
						joinAwaitWithCancellation.outerKeyAwaiter = joinAwaitWithCancellation.outerKeySelector(joinAwaitWithCancellation.currentOuterValue, joinAwaitWithCancellation.cancellationToken).GetAwaiter();
						if (joinAwaitWithCancellation.outerKeyAwaiter.IsCompleted)
						{
							OuterSelectCore(joinAwaitWithCancellation);
							return;
						}
						joinAwaitWithCancellation.continueNext = false;
						joinAwaitWithCancellation.outerKeyAwaiter.SourceOnCompleted(OuterSelectCoreDelegate, joinAwaitWithCancellation);
					}
					else
					{
						joinAwaitWithCancellation.continueNext = false;
						joinAwaitWithCancellation.completionSource.TrySetResult(result: false);
					}
				}
				else
				{
					joinAwaitWithCancellation.continueNext = false;
				}
			}

			private static void OuterSelectCore(object state)
			{
				_JoinAwaitWithCancellation joinAwaitWithCancellation = (_JoinAwaitWithCancellation)state;
				if (joinAwaitWithCancellation.TryGetResult(joinAwaitWithCancellation.outerKeyAwaiter, out var result))
				{
					joinAwaitWithCancellation.valueEnumerator = joinAwaitWithCancellation.lookup[result].GetEnumerator();
					if (!joinAwaitWithCancellation.continueNext)
					{
						joinAwaitWithCancellation.SourceMoveNext();
					}
				}
				else
				{
					joinAwaitWithCancellation.continueNext = false;
				}
			}

			private static void ResultSelectCore(object state)
			{
				_JoinAwaitWithCancellation joinAwaitWithCancellation = (_JoinAwaitWithCancellation)state;
				if (joinAwaitWithCancellation.TryGetResult(joinAwaitWithCancellation.resultAwaiter, out var result))
				{
					joinAwaitWithCancellation.Current = result;
					joinAwaitWithCancellation.completionSource.TrySetResult(result: true);
				}
			}

			public UniTask DisposeAsync()
			{
				if (valueEnumerator != null)
				{
					valueEnumerator.Dispose();
				}
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TOuter> outer;

		private readonly IUniTaskAsyncEnumerable<TInner> inner;

		private readonly Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector;

		private readonly Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector;

		private readonly Func<TOuter, TInner, CancellationToken, UniTask<TResult>> resultSelector;

		private readonly IEqualityComparer<TKey> comparer;

		public JoinAwaitWithCancellation(IUniTaskAsyncEnumerable<TOuter> outer, IUniTaskAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, UniTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, UniTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, UniTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
		{
			this.outer = outer;
			this.inner = inner;
			this.outerKeySelector = outerKeySelector;
			this.innerKeySelector = innerKeySelector;
			this.resultSelector = resultSelector;
			this.comparer = comparer;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _JoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken);
		}
	}
	internal static class Last
	{
		public static async UniTask<TSource> LastAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				if (await e.MoveNextAsync())
				{
					value = e.Current;
					while (await e.MoveNextAsync())
					{
						value = e.Current;
					}
					result = value;
				}
				else
				{
					if (!defaultIfEmpty)
					{
						throw Error.NoElements();
					}
					result = value;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> LastAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				bool found = false;
				while (await e.MoveNextAsync())
				{
					TSource current = e.Current;
					if (predicate(current))
					{
						found = true;
						value = current;
					}
				}
				if (defaultIfEmpty)
				{
					result = value;
				}
				else
				{
					if (!found)
					{
						throw Error.NoElements();
					}
					result = value;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> LastAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				bool found = false;
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					if (await predicate(v))
					{
						found = true;
						value = v;
					}
				}
				if (defaultIfEmpty)
				{
					result = value;
				}
				else
				{
					if (!found)
					{
						throw Error.NoElements();
					}
					result = value;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> LastAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				bool found = false;
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					if (await predicate(v, cancellationToken))
					{
						found = true;
						value = v;
					}
				}
				if (defaultIfEmpty)
				{
					result = value;
				}
				else
				{
					if (!found)
					{
						throw Error.NoElements();
					}
					result = value;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class LongCount
	{
		internal static async UniTask<long> LongCountAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			long count = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					count = checked(count + 1);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}

		internal static async UniTask<long> LongCountAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
		{
			long count = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					if (predicate(e.Current))
					{
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}

		internal static async UniTask<long> LongCountAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			long count = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					if (await predicate(e.Current))
					{
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}

		internal static async UniTask<long> LongCountAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
		{
			long count = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					if (await predicate(e.Current, cancellationToken))
					{
						count = checked(count + 1);
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return count;
		}
	}
	internal static class Max
	{
		public static async UniTask<TSource> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			TSource value = default(TSource);
			Comparer<TSource> comparer = Comparer<TSource>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = e.Current;
					while (await e.MoveNextAsync())
					{
						TSource current = e.Current;
						if (comparer.Compare(value, current) < 0)
						{
							value = current;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TResult> MaxAsync<TSource, TResult>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken)
		{
			TResult value = default(TResult);
			Comparer<TResult> comparer = Comparer<TResult>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					while (await e.MoveNextAsync())
					{
						TResult val = selector(e.Current);
						if (comparer.Compare(value, val) < 0)
						{
							value = val;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TResult> MaxAwaitAsync<TSource, TResult>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector, CancellationToken cancellationToken)
		{
			TResult value = default(TResult);
			Comparer<TResult> comparer = Comparer<TResult>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					while (await e.MoveNextAsync())
					{
						TResult val = await selector(e.Current);
						if (comparer.Compare(value, val) < 0)
						{
							value = val;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
		{
			TResult value = default(TResult);
			Comparer<TResult> comparer = Comparer<TResult>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					while (await e.MoveNextAsync())
					{
						TResult val = await selector(e.Current, cancellationToken);
						if (comparer.Compare(value, val) < 0)
						{
							value = val;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int> MaxAsync(IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<int> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					int current = e.Current;
					if (value < current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					int num = selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					int num = await selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					int num = await selector(e.Current, cancellationToken);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MaxAsync(IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<long> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					long current = e.Current;
					if (value < current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					long num = selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					long num = await selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					long num = await selector(e.Current, cancellationToken);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MaxAsync(IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<float> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					float current = e.Current;
					if (value < current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					float num = selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					float num = await selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					float num = await selector(e.Current, cancellationToken);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MaxAsync(IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<double> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					double current = e.Current;
					if (value < current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					double num = selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					double num = await selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					double num = await selector(e.Current, cancellationToken);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MaxAsync(IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<decimal> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					decimal current = e.Current;
					if (value < current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					decimal num = selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					decimal num = await selector(e.Current);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					decimal num = await selector(e.Current, cancellationToken);
					if (value < num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int?> MaxAsync(IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<int?> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? current = e.Current;
						if (current.HasValue && value < current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int?> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? num = selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int?> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? num = await selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int?> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MaxAsync(IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<long?> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? current = e.Current;
						if (current.HasValue && value < current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? num = selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? num = await selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MaxAsync(IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<float?> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? current = e.Current;
						if (current.HasValue && value < current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? num = selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? num = await selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MaxAsync(IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<double?> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? current = e.Current;
						if (current.HasValue && value < current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? num = selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? num = await selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MaxAsync(IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<decimal?> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? current = e.Current;
						if (current.HasValue && value < current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MaxAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? num = selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MaxAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? num = await selector(e.Current);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value < num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal sealed class Merge<T> : IUniTaskAsyncEnumerable<T>
	{
		private enum MergeSourceState
		{
			Pending,
			Running,
			Completed
		}

		private sealed class _Merge : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> GetResultAtAction = GetResultAt;

			private readonly int length;

			private readonly IUniTaskAsyncEnumerator<T>[] enumerators;

			private readonly MergeSourceState[] states;

			private readonly Queue<(T, Exception, bool)> queuedResult = new Queue<(T, Exception, bool)>();

			private readonly CancellationToken cancellationToken;

			private int moveNextCompleted;

			public T Current { get; private set; }

			public _Merge(IUniTaskAsyncEnumerable<T>[] sources, CancellationToken cancellationToken)
			{
				this.cancellationToken = cancellationToken;
				length = sources.Length;
				states = ArrayPool<MergeSourceState>.Shared.Rent(length);
				enumerators = ArrayPool<IUniTaskAsyncEnumerator<T>>.Shared.Rent(length);
				for (int i = 0; i < length; i++)
				{
					enumerators[i] = sources[i].GetAsyncEnumerator(cancellationToken);
					states[i] = MergeSourceState.Pending;
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				CancellationToken cancellationToken = this.cancellationToken;
				cancellationToken.ThrowIfCancellationRequested();
				completionSource.Reset();
				Interlocked.Exchange(ref moveNextCompleted, 0);
				if (HasQueuedResult() && Interlocked.CompareExchange(ref moveNextCompleted, 1, 0) == 0)
				{
					(T, Exception, bool) tuple;
					lock (states)
					{
						tuple = queuedResult.Dequeue();
					}
					var (current, ex, result) = tuple;
					if (ex != null)
					{
						completionSource.TrySetException(ex);
					}
					else
					{
						Current = current;
						completionSource.TrySetResult(result);
					}
					return new UniTask<bool>(this, completionSource.Version);
				}
				for (int i = 0; i < length; i++)
				{
					lock (states)
					{
						if (states[i] == MergeSourceState.Pending)
						{
							states[i] = MergeSourceState.Running;
							goto IL_00fe;
						}
					}
					continue;
					IL_00fe:
					UniTask<bool>.Awaiter awaiter = enumerators[i].MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						GetResultAt(i, awaiter);
					}
					else
					{
						awaiter.SourceOnCompleted(GetResultAtAction, StateTuple.Create(this, i, awaiter));
					}
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			public async UniTask DisposeAsync()
			{
				for (int i = 0; i < length; i++)
				{
					await enumerators[i].DisposeAsync();
				}
				ArrayPool<MergeSourceState>.Shared.Return(states, clearArray: true);
				ArrayPool<IUniTaskAsyncEnumerator<T>>.Shared.Return(enumerators, clearArray: true);
			}

			private static void GetResultAt(object state)
			{
				using StateTuple<_Merge, int, UniTask<bool>.Awaiter> stateTuple = (StateTuple<_Merge, int, UniTask<bool>.Awaiter>)state;
				stateTuple.Item1.GetResultAt(stateTuple.Item2, stateTuple.Item3);
			}

			private void GetResultAt(int index, UniTask<bool>.Awaiter awaiter)
			{
				bool result;
				try
				{
					result = awaiter.GetResult();
				}
				catch (Exception ex)
				{
					if (Interlocked.CompareExchange(ref moveNextCompleted, 1, 0) == 0)
					{
						completionSource.TrySetException(ex);
						return;
					}
					lock (states)
					{
						queuedResult.Enqueue((default(T), ex, false));
						return;
					}
				}
				bool flag;
				lock (states)
				{
					states[index] = ((!result) ? MergeSourceState.Completed : MergeSourceState.Pending);
					flag = !result && IsCompletedAll();
				}
				if (!(result || flag))
				{
					return;
				}
				if (Interlocked.CompareExchange(ref moveNextCompleted, 1, 0) == 0)
				{
					Current = enumerators[index].Current;
					completionSource.TrySetResult(!flag);
					return;
				}
				lock (states)
				{
					queuedResult.Enqueue((enumerators[index].Current, null, !flag));
				}
			}

			private bool HasQueuedResult()
			{
				lock (states)
				{
					return queuedResult.Count > 0;
				}
			}

			private bool IsCompletedAll()
			{
				lock (states)
				{
					for (int i = 0; i < length; i++)
					{
						if (states[i] != MergeSourceState.Completed)
						{
							return false;
						}
					}
				}
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<T>[] sources;

		public Merge(IUniTaskAsyncEnumerable<T>[] sources)
		{
			if (sources.Length == 0)
			{
				Error.ThrowArgumentException("No source async enumerable to merge");
			}
			this.sources = sources;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Merge(sources, cancellationToken);
		}
	}
	internal static class Min
	{
		public static async UniTask<TSource> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			TSource value = default(TSource);
			Comparer<TSource> comparer = Comparer<TSource>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = e.Current;
					while (await e.MoveNextAsync())
					{
						TSource current = e.Current;
						if (comparer.Compare(value, current) > 0)
						{
							value = current;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TResult> MinAsync<TSource, TResult>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken)
		{
			TResult value = default(TResult);
			Comparer<TResult> comparer = Comparer<TResult>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					while (await e.MoveNextAsync())
					{
						TResult val = selector(e.Current);
						if (comparer.Compare(value, val) > 0)
						{
							value = val;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TResult> MinAwaitAsync<TSource, TResult>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector, CancellationToken cancellationToken)
		{
			TResult value = default(TResult);
			Comparer<TResult> comparer = Comparer<TResult>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					while (await e.MoveNextAsync())
					{
						TResult val = await selector(e.Current);
						if (comparer.Compare(value, val) > 0)
						{
							value = val;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
		{
			TResult value = default(TResult);
			Comparer<TResult> comparer = Comparer<TResult>.Default;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TResult result;
			try
			{
				if (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					while (await e.MoveNextAsync())
					{
						TResult val = await selector(e.Current, cancellationToken);
						if (comparer.Compare(value, val) > 0)
						{
							value = val;
						}
					}
					return value;
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int> MinAsync(IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<int> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					int current = e.Current;
					if (value > current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					int num = selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					int num = await selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			int value = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					int num = await selector(e.Current, cancellationToken);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MinAsync(IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<long> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					long current = e.Current;
					if (value > current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					long num = selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					long num = await selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<long> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long value = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					long num = await selector(e.Current, cancellationToken);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MinAsync(IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<float> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					float current = e.Current;
					if (value > current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					float num = selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					float num = await selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<float> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			float value = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					float num = await selector(e.Current, cancellationToken);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MinAsync(IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<double> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					double current = e.Current;
					if (value > current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					double num = selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					double num = await selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<double> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			double value = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					double num = await selector(e.Current, cancellationToken);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MinAsync(IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<decimal> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = e.Current;
				while (await e.MoveNextAsync())
				{
					decimal current = e.Current;
					if (value > current)
					{
						value = current;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = selector(e.Current);
				while (await e.MoveNextAsync())
				{
					decimal num = selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current);
				while (await e.MoveNextAsync())
				{
					decimal num = await selector(e.Current);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<decimal> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			decimal value = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				if (!(await e.MoveNextAsync()))
				{
					throw Error.NoElements();
				}
				value = await selector(e.Current, cancellationToken);
				while (await e.MoveNextAsync())
				{
					decimal num = await selector(e.Current, cancellationToken);
					if (value > num)
					{
						value = num;
					}
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return value;
		}

		public static async UniTask<int?> MinAsync(IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<int?> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? current = e.Current;
						if (current.HasValue && value > current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int?> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? num = selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int?> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? num = await selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<int?> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			int? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			int? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						int? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MinAsync(IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<long?> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? current = e.Current;
						if (current.HasValue && value > current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? num = selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? num = await selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<long?> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			long? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						long? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MinAsync(IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<float?> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? current = e.Current;
						if (current.HasValue && value > current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? num = selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? num = await selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<float?> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			float? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			float? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						float? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MinAsync(IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<double?> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? current = e.Current;
						if (current.HasValue && value > current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? num = selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? num = await selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<double?> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			double? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			double? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						double? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MinAsync(IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<decimal?> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = e.Current;
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? current = e.Current;
						if (current.HasValue && value > current)
						{
							value = current;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MinAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? num = selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MinAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? num = await selector(e.Current);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<decimal?> MinAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			decimal? value = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			decimal? result;
			try
			{
				while (await e.MoveNextAsync())
				{
					value = await selector(e.Current, cancellationToken);
					if (!value.HasValue)
					{
						continue;
					}
					while (await e.MoveNextAsync())
					{
						decimal? num = await selector(e.Current, cancellationToken);
						if (num.HasValue && value > num)
						{
							value = num;
						}
					}
					return value;
				}
				result = null;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal class Never<T> : IUniTaskAsyncEnumerable<T>
	{
		private class _Never : IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private CancellationToken cancellationToken;

			public T Current => default(T);

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

			public UniTask<bool> MoveNextAsync()
			{
				UniTaskCompletionSource<bool> uniTaskCompletionSource = new UniTaskCompletionSource<bool>();
				cancellationToken.Register(delegate(object state)
				{
					((UniTaskCompletionSource<bool>)state).TrySetCanceled(cancellationToken);
				}, uniTaskCompletionSource);
				return uniTaskCompletionSource.Task;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		public static readonly IUniTaskAsyncEnumerable<T> Instance = new Never<T>();

		private Never()
		{
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Never(cancellationToken);
		}
	}
	internal sealed class OfType<TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private class _OfType : AsyncEnumeratorBase<object, TResult>
		{
			public _OfType(IUniTaskAsyncEnumerable<object> source, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					if (base.SourceCurrent is TResult current)
					{
						base.Current = current;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<object> source;

		public OfType(IUniTaskAsyncEnumerable<object> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _OfType(source, cancellationToken);
		}
	}
	internal abstract class AsyncEnumerableSorter<TElement>
	{
		internal abstract UniTask ComputeKeysAsync(TElement[] elements, int count);

		internal abstract int CompareKeys(int index1, int index2);

		internal async UniTask<int[]> SortAsync(TElement[] elements, int count)
		{
			await ComputeKeysAsync(elements, count);
			int[] array = new int[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = i;
			}
			QuickSort(array, 0, count - 1);
			return array;
		}

		private void QuickSort(int[] map, int left, int right)
		{
			do
			{
				int num = left;
				int num2 = right;
				int index = map[num + (num2 - num >> 1)];
				while (true)
				{
					if (num < map.Length && CompareKeys(index, map[num]) > 0)
					{
						num++;
						continue;
					}
					while (num2 >= 0 && CompareKeys(index, map[num2]) < 0)
					{
						num2--;
					}
					if (num > num2)
					{
						break;
					}
					if (num < num2)
					{
						int num3 = map[num];
						map[num] = map[num2];
						map[num2] = num3;
					}
					num++;
					num2--;
					if (num > num2)
					{
						break;
					}
				}
				if (num2 - left <= right - num)
				{
					if (left < num2)
					{
						QuickSort(map, left, num2);
					}
					left = num;
				}
				else
				{
					if (num < right)
					{
						QuickSort(map, num, right);
					}
					right = num2;
				}
			}
			while (left < right);
		}
	}
	internal class SyncSelectorAsyncEnumerableSorter<TElement, TKey> : AsyncEnumerableSorter<TElement>
	{
		private readonly Func<TElement, TKey> keySelector;

		private readonly IComparer<TKey> comparer;

		private readonly bool descending;

		private readonly AsyncEnumerableSorter<TElement> next;

		private TKey[] keys;

		internal SyncSelectorAsyncEnumerableSorter(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending, AsyncEnumerableSorter<TElement> next)
		{
			this.keySelector = keySelector;
			this.comparer = comparer;
			this.descending = descending;
			this.next = next;
		}

		internal override async UniTask ComputeKeysAsync(TElement[] elements, int count)
		{
			keys = new TKey[count];
			for (int i = 0; i < count; i++)
			{
				keys[i] = keySelector(elements[i]);
			}
			if (next != null)
			{
				await next.ComputeKeysAsync(elements, count);
			}
		}

		internal override int CompareKeys(int index1, int index2)
		{
			int num = comparer.Compare(keys[index1], keys[index2]);
			if (num == 0)
			{
				if (next == null)
				{
					return index1 - index2;
				}
				return next.CompareKeys(index1, index2);
			}
			if (!descending)
			{
				return num;
			}
			return -num;
		}
	}
	internal class AsyncSelectorEnumerableSorter<TElement, TKey> : AsyncEnumerableSorter<TElement>
	{
		private readonly Func<TElement, UniTask<TKey>> keySelector;

		private readonly IComparer<TKey> comparer;

		private readonly bool descending;

		private readonly AsyncEnumerableSorter<TElement> next;

		private TKey[] keys;

		internal AsyncSelectorEnumerableSorter(Func<TElement, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending, AsyncEnumerableSorter<TElement> next)
		{
			this.keySelector = keySelector;
			this.comparer = comparer;
			this.descending = descending;
			this.next = next;
		}

		internal override async UniTask ComputeKeysAsync(TElement[] elements, int count)
		{
			keys = new TKey[count];
			for (int i = 0; i < count; i++)
			{
				TKey[] array = keys;
				int num = i;
				array[num] = await keySelector(elements[i]);
			}
			if (next != null)
			{
				await next.ComputeKeysAsync(elements, count);
			}
		}

		internal override int CompareKeys(int index1, int index2)
		{
			int num = comparer.Compare(keys[index1], keys[index2]);
			if (num == 0)
			{
				if (next == null)
				{
					return index1 - index2;
				}
				return next.CompareKeys(index1, index2);
			}
			if (!descending)
			{
				return num;
			}
			return -num;
		}
	}
	internal class AsyncSelectorWithCancellationEnumerableSorter<TElement, TKey> : AsyncEnumerableSorter<TElement>
	{
		private readonly Func<TElement, CancellationToken, UniTask<TKey>> keySelector;

		private readonly IComparer<TKey> comparer;

		private readonly bool descending;

		private readonly AsyncEnumerableSorter<TElement> next;

		private CancellationToken cancellationToken;

		private TKey[] keys;

		internal AsyncSelectorWithCancellationEnumerableSorter(Func<TElement, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending, AsyncEnumerableSorter<TElement> next, CancellationToken cancellationToken)
		{
			this.keySelector = keySelector;
			this.comparer = comparer;
			this.descending = descending;
			this.next = next;
			this.cancellationToken = cancellationToken;
		}

		internal override async UniTask ComputeKeysAsync(TElement[] elements, int count)
		{
			keys = new TKey[count];
			for (int i = 0; i < count; i++)
			{
				TKey[] array = keys;
				int num = i;
				array[num] = await keySelector(elements[i], cancellationToken);
			}
			if (next != null)
			{
				await next.ComputeKeysAsync(elements, count);
			}
		}

		internal override int CompareKeys(int index1, int index2)
		{
			int num = comparer.Compare(keys[index1], keys[index2]);
			if (num == 0)
			{
				if (next == null)
				{
					return index1 - index2;
				}
				return next.CompareKeys(index1, index2);
			}
			if (!descending)
			{
				return num;
			}
			return -num;
		}
	}
	internal abstract class OrderedAsyncEnumerable<TElement> : IUniTaskOrderedAsyncEnumerable<TElement>, IUniTaskAsyncEnumerable<TElement>
	{
		private class _OrderedAsyncEnumerator : MoveNextSource, IUniTaskAsyncEnumerator<TElement>, IUniTaskAsyncDisposable
		{
			protected readonly OrderedAsyncEnumerable<TElement> parent;

			private CancellationToken cancellationToken;

			private TElement[] buffer;

			private int[] map;

			private int index;

			public TElement Current { get; private set; }

			public _OrderedAsyncEnumerator(OrderedAsyncEnumerable<TElement> parent, CancellationToken cancellationToken)
			{
				this.parent = parent;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (map == null)
				{
					completionSource.Reset();
					CreateSortSource().Forget();
					return new UniTask<bool>(this, completionSource.Version);
				}
				if (index < buffer.Length)
				{
					Current = buffer[map[index++]];
					return CompletedTasks.True;
				}
				return CompletedTasks.False;
			}

			private async UniTaskVoid CreateSortSource()
			{
				_ = 1;
				try
				{
					buffer = await parent.source.ToArrayAsync();
					if (buffer.Length == 0)
					{
						completionSource.TrySetResult(result: false);
						return;
					}
					map = await parent.GetAsyncEnumerableSorter(null, cancellationToken).SortAsync(buffer, buffer.Length);
					Current = buffer[map[index++]];
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				completionSource.TrySetResult(result: true);
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		protected readonly IUniTaskAsyncEnumerable<TElement> source;

		public OrderedAsyncEnumerable(IUniTaskAsyncEnumerable<TElement> source)
		{
			this.source = source;
		}

		public IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending)
		{
			return new OrderedAsyncEnumerable<TElement, TKey>(source, keySelector, comparer, descending, this);
		}

		public IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending)
		{
			return new OrderedAsyncEnumerableAwait<TElement, TKey>(source, keySelector, comparer, descending, this);
		}

		public IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending)
		{
			return new OrderedAsyncEnumerableAwaitWithCancellation<TElement, TKey>(source, keySelector, comparer, descending, this);
		}

		internal abstract AsyncEnumerableSorter<TElement> GetAsyncEnumerableSorter(AsyncEnumerableSorter<TElement> next, CancellationToken cancellationToken);

		public IUniTaskAsyncEnumerator<TElement> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _OrderedAsyncEnumerator(this, cancellationToken);
		}
	}
	internal class OrderedAsyncEnumerable<TElement, TKey> : OrderedAsyncEnumerable<TElement>
	{
		private readonly Func<TElement, TKey> keySelector;

		private readonly IComparer<TKey> comparer;

		private readonly bool descending;

		private readonly OrderedAsyncEnumerable<TElement> parent;

		public OrderedAsyncEnumerable(IUniTaskAsyncEnumerable<TElement> source, Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending, OrderedAsyncEnumerable<TElement> parent)
			: base(source)
		{
			this.keySelector = keySelector;
			this.comparer = comparer;
			this.descending = descending;
			this.parent = parent;
		}

		internal override AsyncEnumerableSorter<TElement> GetAsyncEnumerableSorter(AsyncEnumerableSorter<TElement> next, CancellationToken cancellationToken)
		{
			AsyncEnumerableSorter<TElement> asyncEnumerableSorter = new SyncSelectorAsyncEnumerableSorter<TElement, TKey>(keySelector, comparer, descending, next);
			if (parent != null)
			{
				asyncEnumerableSorter = parent.GetAsyncEnumerableSorter(asyncEnumerableSorter, cancellationToken);
			}
			return asyncEnumerableSorter;
		}
	}
	internal class OrderedAsyncEnumerableAwait<TElement, TKey> : OrderedAsyncEnumerable<TElement>
	{
		private readonly Func<TElement, UniTask<TKey>> keySelector;

		private readonly IComparer<TKey> comparer;

		private readonly bool descending;

		private readonly OrderedAsyncEnumerable<TElement> parent;

		public OrderedAsyncEnumerableAwait(IUniTaskAsyncEnumerable<TElement> source, Func<TElement, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending, OrderedAsyncEnumerable<TElement> parent)
			: base(source)
		{
			this.keySelector = keySelector;
			this.comparer = comparer;
			this.descending = descending;
			this.parent = parent;
		}

		internal override AsyncEnumerableSorter<TElement> GetAsyncEnumerableSorter(AsyncEnumerableSorter<TElement> next, CancellationToken cancellationToken)
		{
			AsyncEnumerableSorter<TElement> asyncEnumerableSorter = new AsyncSelectorEnumerableSorter<TElement, TKey>(keySelector, comparer, descending, next);
			if (parent != null)
			{
				asyncEnumerableSorter = parent.GetAsyncEnumerableSorter(asyncEnumerableSorter, cancellationToken);
			}
			return asyncEnumerableSorter;
		}
	}
	internal class OrderedAsyncEnumerableAwaitWithCancellation<TElement, TKey> : OrderedAsyncEnumerable<TElement>
	{
		private readonly Func<TElement, CancellationToken, UniTask<TKey>> keySelector;

		private readonly IComparer<TKey> comparer;

		private readonly bool descending;

		private readonly OrderedAsyncEnumerable<TElement> parent;

		public OrderedAsyncEnumerableAwaitWithCancellation(IUniTaskAsyncEnumerable<TElement> source, Func<TElement, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending, OrderedAsyncEnumerable<TElement> parent)
			: base(source)
		{
			this.keySelector = keySelector;
			this.comparer = comparer;
			this.descending = descending;
			this.parent = parent;
		}

		internal override AsyncEnumerableSorter<TElement> GetAsyncEnumerableSorter(AsyncEnumerableSorter<TElement> next, CancellationToken cancellationToken)
		{
			AsyncEnumerableSorter<TElement> asyncEnumerableSorter = new AsyncSelectorWithCancellationEnumerableSorter<TElement, TKey>(keySelector, comparer, descending, next, cancellationToken);
			if (parent != null)
			{
				asyncEnumerableSorter = parent.GetAsyncEnumerableSorter(asyncEnumerableSorter, cancellationToken);
			}
			return asyncEnumerableSorter;
		}
	}
	internal sealed class Pairwise<TSource> : IUniTaskAsyncEnumerable<(TSource, TSource)>
	{
		private sealed class _Pairwise : MoveNextSource, IUniTaskAsyncEnumerator<(TSource, TSource)>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private TSource prev;

			private bool isFirst;

			public (TSource, TSource) Current { get; private set; }

			public _Pairwise(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					isFirst = true;
					enumerator = source.GetAsyncEnumerator(cancellationToken);
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_Pairwise pairwise = (_Pairwise)state;
				if (!pairwise.TryGetResult(pairwise.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					if (pairwise.isFirst)
					{
						pairwise.isFirst = false;
						pairwise.prev = pairwise.enumerator.Current;
						pairwise.SourceMoveNext();
					}
					else
					{
						TSource item = pairwise.prev;
						pairwise.prev = pairwise.enumerator.Current;
						pairwise.Current = (item, pairwise.prev);
						pairwise.completionSource.TrySetResult(result: true);
					}
				}
				else
				{
					pairwise.completionSource.TrySetResult(result: false);
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		public Pairwise(IUniTaskAsyncEnumerable<TSource> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<(TSource, TSource)> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Pairwise(source, cancellationToken);
		}
	}
	internal sealed class Publish<TSource> : IConnectableUniTaskAsyncEnumerable<TSource>, IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class ConnectDisposable : IDisposable
		{
			private readonly CancellationTokenSource cancellationTokenSource;

			public ConnectDisposable(CancellationTokenSource cancellationTokenSource)
			{
				this.cancellationTokenSource = cancellationTokenSource;
			}

			public void Dispose()
			{
				cancellationTokenSource.Cancel();
			}
		}

		private sealed class _Publish : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable, ITriggerHandler<TSource>
		{
			private static readonly Action<object> CancelDelegate = OnCanceled;

			private readonly Publish<TSource> parent;

			private CancellationToken cancellationToken;

			private CancellationTokenRegistration cancellationTokenRegistration;

			private bool isDisposed;

			public TSource Current { get; private set; }

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

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

			public _Publish(Publish<TSource> parent, CancellationToken cancellationToken)
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					this.parent = parent;
					this.cancellationToken = cancellationToken;
					if (cancellationToken.CanBeCanceled)
					{
						cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(CancelDelegate, this);
					}
					parent.trigger.Add(this);
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (parent.isCompleted)
				{
					return CompletedTasks.False;
				}
				completionSource.Reset();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void OnCanceled(object state)
			{
				_Publish publish = (_Publish)state;
				publish.completionSource.TrySetCanceled(publish.cancellationToken);
				publish.DisposeAsync().Forget();
			}

			public UniTask DisposeAsync()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					cancellationTokenRegistration.Dispose();
					parent.trigger.Remove(this);
				}
				return default(UniTask);
			}

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

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

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

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly CancellationTokenSource cancellationTokenSource;

		private TriggerEvent<TSource> trigger;

		private IUniTaskAsyncEnumerator<TSource> enumerator;

		private IDisposable connectedDisposable;

		private bool isCompleted;

		public Publish(IUniTaskAsyncEnumerable<TSource> source)
		{
			this.source = source;
			cancellationTokenSource = new CancellationTokenSource();
		}

		public IDisposable Connect()
		{
			if (connectedDisposable != null)
			{
				return connectedDisposable;
			}
			if (enumerator == null)
			{
				enumerator = source.GetAsyncEnumerator(cancellationTokenSource.Token);
			}
			ConsumeEnumerator().Forget();
			connectedDisposable = new ConnectDisposable(cancellationTokenSource);
			return connectedDisposable;
		}

		private async UniTaskVoid ConsumeEnumerator()
		{
			try
			{
				while (await enumerator.MoveNextAsync())
				{
					trigger.SetResult(enumerator.Current);
				}
				trigger.SetCompleted();
			}
			catch (Exception error)
			{
				trigger.SetError(error);
			}
			finally
			{
				isCompleted = true;
				await enumerator.DisposeAsync();
			}
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Publish(this, cancellationToken);
		}
	}
	internal sealed class QueueOperator<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Queue : IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken;

			private Channel<TSource> channel;

			private IUniTaskAsyncEnumerator<TSource> channelEnumerator;

			private IUniTaskAsyncEnumerator<TSource> sourceEnumerator;

			private bool channelClosed;

			public TSource Current => channelEnumerator.Current;

			public _Queue(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (sourceEnumerator == null)
				{
					sourceEnumerator = source.GetAsyncEnumerator(cancellationToken);
					channel = Channel.CreateSingleConsumerUnbounded<TSource>();
					channelEnumerator = channel.Reader.ReadAllAsync().GetAsyncEnumerator(cancellationToken);
					ConsumeAll(this, sourceEnumerator, channel).Forget();
				}
				return channelEnumerator.MoveNextAsync();
			}

			private static async UniTaskVoid ConsumeAll(_Queue self, IUniTaskAsyncEnumerator<TSource> enumerator, ChannelWriter<TSource> writer)
			{
				try
				{
					while (await enumerator.MoveNextAsync())
					{
						writer.TryWrite(enumerator.Current);
					}
					writer.TryComplete();
				}
				catch (Exception error)
				{
					writer.TryComplete(error);
				}
				finally
				{
					self.channelClosed = true;
					await enumerator.DisposeAsync();
				}
			}

			public async UniTask DisposeAsync()
			{
				if (sourceEnumerator != null)
				{
					await sourceEnumerator.DisposeAsync();
				}
				if (channelEnumerator != null)
				{
					await channelEnumerator.DisposeAsync();
				}
				if (!channelClosed)
				{
					channelClosed = true;
					channel.Writer.TryComplete(new OperationCanceledException());
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		public QueueOperator(IUniTaskAsyncEnumerable<TSource> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Queue(source, cancellationToken);
		}
	}
	internal class Range : IUniTaskAsyncEnumerable<int>
	{
		private class _Range : IUniTaskAsyncEnumerator<int>, IUniTaskAsyncDisposable
		{
			private readonly int start;

			private readonly int end;

			private int current;

			private CancellationToken cancellationToken;

			public int Current => current;

			public _Range(int start, int end, CancellationToken cancellationToken)
			{
				this.start = start;
				this.end = end;
				this.cancellationToken = cancellationToken;
				current = start - 1;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				current++;
				if (current != end)
				{
					return CompletedTasks.True;
				}
				return CompletedTasks.False;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly int start;

		private readonly int end;

		public Range(int start, int count)
		{
			this.start = start;
			end = start + count;
		}

		public IUniTaskAsyncEnumerator<int> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Range(start, end, cancellationToken);
		}
	}
	internal class Repeat<TElement> : IUniTaskAsyncEnumerable<TElement>
	{
		private class _Repeat : IUniTaskAsyncEnumerator<TElement>, IUniTaskAsyncDisposable
		{
			private readonly TElement element;

			private readonly int count;

			private int remaining;

			private CancellationToken cancellationToken;

			public TElement Current => element;

			public _Repeat(TElement element, int count, CancellationToken cancellationToken)
			{
				this.element = element;
				this.count = count;
				this.cancellationToken = cancellationToken;
				remaining = count;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (remaining-- != 0)
				{
					return CompletedTasks.True;
				}
				return CompletedTasks.False;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly TElement element;

		private readonly int count;

		public Repeat(TElement element, int count)
		{
			this.element = element;
			this.count = count;
		}

		public IUniTaskAsyncEnumerator<TElement> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Repeat(element, count, cancellationToken);
		}
	}
	internal class Return<TValue> : IUniTaskAsyncEnumerable<TValue>
	{
		private class _Return : IUniTaskAsyncEnumerator<TValue>, IUniTaskAsyncDisposable
		{
			private readonly TValue value;

			private CancellationToken cancellationToken;

			private bool called;

			public TValue Current => value;

			public _Return(TValue value, CancellationToken cancellationToken)
			{
				this.value = value;
				this.cancellationToken = cancellationToken;
				called = false;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (!called)
				{
					called = true;
					return CompletedTasks.True;
				}
				return CompletedTasks.False;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly TValue value;

		public Return(TValue value)
		{
			this.value = value;
		}

		public IUniTaskAsyncEnumerator<TValue> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Return(value, cancellationToken);
		}
	}
	internal sealed class Reverse<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Reverse : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken;

			private TSource[] array;

			private int index;

			public TSource Current { get; private set; }

			public _Reverse(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
			}

			public async UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (array == null)
				{
					array = await source.ToArrayAsync(cancellationToken);
					index = array.Length - 1;
				}
				if (index != -1)
				{
					Current = array[index];
					index--;
					return true;
				}
				return false;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		public Reverse(IUniTaskAsyncEnumerable<TSource> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Reverse(source, cancellationToken);
		}
	}
	internal sealed class Select<TSource, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _Select : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, TResult> selector;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Action moveNextAction;

			public TResult Current { get; private set; }

			public _Select(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector = selector;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					default:
						goto end_IL_0000;
					case -1:
						enumerator = source.GetAsyncEnumerator(cancellationToken);
						goto case 0;
					case 0:
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							state = 1;
							awaiter.UnsafeOnCompleted(moveNextAction);
							return;
						}
						break;
					case 1:
						break;
					}
					if (awaiter.GetResult())
					{
						Current = selector(enumerator.Current);
						goto IL_00d2;
					}
					end_IL_0000:;
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
				return;
				IL_00d2:
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, TResult> selector;

		public Select(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector)
		{
			this.source = source;
			this.selector = selector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Select(source, selector, cancellationToken);
		}
	}
	internal sealed class SelectInt<TSource, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _Select : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, int, TResult> selector;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Action moveNextAction;

			private int index;

			public TResult Current { get; private set; }

			public _Select(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector = selector;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					default:
						goto end_IL_0000;
					case -1:
						enumerator = source.GetAsyncEnumerator(cancellationToken);
						goto case 0;
					case 0:
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							state = 1;
							awaiter.UnsafeOnCompleted(moveNextAction);
							return;
						}
						break;
					case 1:
						break;
					}
					if (awaiter.GetResult())
					{
						Current = selector(enumerator.Current, checked(index++));
						goto IL_00e6;
					}
					end_IL_0000:;
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
				return;
				IL_00e6:
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, TResult> selector;

		public SelectInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector)
		{
			this.source = source;
			this.selector = selector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Select(source, selector, cancellationToken);
		}
	}
	internal sealed class SelectAwait<TSource, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, UniTask<TResult>> selector;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TResult>.Awaiter awaiter2;

			private Action moveNextAction;

			public TResult Current { get; private set; }

			public _SelectAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector = selector;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					default:
						goto end_IL_0000;
					case -1:
						enumerator = source.GetAsyncEnumerator(cancellationToken);
						goto case 0;
					case 0:
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							state = 1;
							awaiter.UnsafeOnCompleted(moveNextAction);
							return;
						}
						goto case 1;
					case 1:
						if (awaiter.GetResult())
						{
							awaiter2 = selector(enumerator.Current).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								state = 2;
								awaiter2.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						}
						goto end_IL_0000;
					case 2:
						break;
					}
					Current = awaiter2.GetResult();
					goto IL_011b;
					end_IL_0000:;
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
				return;
				IL_011b:
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<TResult>> selector;

		public SelectAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector)
		{
			this.source = source;
			this.selector = selector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectAwait(source, selector, cancellationToken);
		}
	}
	internal sealed class SelectIntAwait<TSource, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, int, UniTask<TResult>> selector;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TResult>.Awaiter awaiter2;

			private Action moveNextAction;

			private int index;

			public TResult Current { get; private set; }

			public _SelectAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<TResult>> selector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector = selector;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					default:
						goto end_IL_0000;
					case -1:
						enumerator = source.GetAsyncEnumerator(cancellationToken);
						goto case 0;
					case 0:
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							state = 1;
							awaiter.UnsafeOnCompleted(moveNextAction);
							return;
						}
						goto case 1;
					case 1:
						if (awaiter.GetResult())
						{
							awaiter2 = selector(enumerator.Current, checked(index++)).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								state = 2;
								awaiter2.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						}
						goto end_IL_0000;
					case 2:
						break;
					}
					Current = awaiter2.GetResult();
					goto IL_012e;
					end_IL_0000:;
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
				return;
				IL_012e:
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, UniTask<TResult>> selector;

		public SelectIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<TResult>> selector)
		{
			this.source = source;
			this.selector = selector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectAwait(source, selector, cancellationToken);
		}
	}
	internal sealed class SelectAwaitWithCancellation<TSource, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, CancellationToken, UniTask<TResult>> selector;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TResult>.Awaiter awaiter2;

			private Action moveNextAction;

			public TResult Current { get; private set; }

			public _SelectAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector = selector;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					default:
						goto end_IL_0000;
					case -1:
						enumerator = source.GetAsyncEnumerator(cancellationToken);
						goto case 0;
					case 0:
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							state = 1;
							awaiter.UnsafeOnCompleted(moveNextAction);
							return;
						}
						goto case 1;
					case 1:
						if (awaiter.GetResult())
						{
							awaiter2 = selector(enumerator.Current, cancellationToken).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								state = 2;
								awaiter2.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						}
						goto end_IL_0000;
					case 2:
						break;
					}
					Current = awaiter2.GetResult();
					goto IL_0121;
					end_IL_0000:;
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
				return;
				IL_0121:
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<TResult>> selector;

		public SelectAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector)
		{
			this.source = source;
			this.selector = selector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectAwaitWithCancellation(source, selector, cancellationToken);
		}
	}
	internal sealed class SelectIntAwaitWithCancellation<TSource, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, int, CancellationToken, UniTask<TResult>> selector;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<TResult>.Awaiter awaiter2;

			private Action moveNextAction;

			private int index;

			public TResult Current { get; private set; }

			public _SelectAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector = selector;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				try
				{
					switch (state)
					{
					default:
						goto end_IL_0000;
					case -1:
						enumerator = source.GetAsyncEnumerator(cancellationToken);
						goto case 0;
					case 0:
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							state = 1;
							awaiter.UnsafeOnCompleted(moveNextAction);
							return;
						}
						goto case 1;
					case 1:
						if (awaiter.GetResult())
						{
							awaiter2 = selector(enumerator.Current, checked(index++), cancellationToken).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								state = 2;
								awaiter2.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						}
						goto end_IL_0000;
					case 2:
						break;
					}
					Current = awaiter2.GetResult();
					goto IL_0134;
					end_IL_0000:;
				}
				catch (Exception error)
				{
					state = -2;
					completionSource.TrySetException(error);
					return;
				}
				state = -2;
				completionSource.TrySetResult(result: false);
				return;
				IL_0134:
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, CancellationToken, UniTask<TResult>> selector;

		public SelectIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<TResult>> selector)
		{
			this.source = source;
			this.selector = selector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectAwaitWithCancellation(source, selector, cancellationToken);
		}
	}
	internal sealed class SelectMany<TSource, TCollection, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectMany : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> sourceMoveNextCoreDelegate = SourceMoveNextCore;

			private static readonly Action<object> selectedSourceMoveNextCoreDelegate = SeletedSourceMoveNextCore;

			private static readonly Action<object> selectedEnumeratorDisposeAsyncCoreDelegate = SelectedEnumeratorDisposeAsyncCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, IUniTaskAsyncEnumerable<TCollection>> selector1;

			private readonly Func<TSource, int, IUniTaskAsyncEnumerable<TCollection>> selector2;

			private readonly Func<TSource, TCollection, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private TSource sourceCurrent;

			private int sourceIndex;

			private IUniTaskAsyncEnumerator<TSource> sourceEnumerator;

			private IUniTaskAsyncEnumerator<TCollection> selectedEnumerator;

			private UniTask<bool>.Awaiter sourceAwaiter;

			private UniTask<bool>.Awaiter selectedAwaiter;

			private UniTask.Awaiter selectedDisposeAsyncAwaiter;

			public TResult Current { get; private set; }

			public _SelectMany(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, IUniTaskAsyncEnumerable<TCollection>> selector1, Func<TSource, int, IUniTaskAsyncEnumerable<TCollection>> selector2, Func<TSource, TCollection, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector1 = selector1;
				this.selector2 = selector2;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				completionSource.Reset();
				if (selectedEnumerator != null)
				{
					MoveNextSelected();
				}
				else
				{
					if (sourceEnumerator == null)
					{
						sourceEnumerator = source.GetAsyncEnumerator(cancellationToken);
					}
					MoveNextSource();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNextSource()
			{
				try
				{
					sourceAwaiter = sourceEnumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (sourceAwaiter.IsCompleted)
				{
					SourceMoveNextCore(this);
				}
				else
				{
					sourceAwaiter.SourceOnCompleted(sourceMoveNextCoreDelegate, this);
				}
			}

			private void MoveNextSelected()
			{
				try
				{
					selectedAwaiter = selectedEnumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (selectedAwaiter.IsCompleted)
				{
					SeletedSourceMoveNextCore(this);
				}
				else
				{
					selectedAwaiter.SourceOnCompleted(selectedSourceMoveNextCoreDelegate, this);
				}
			}

			private static void SourceMoveNextCore(object state)
			{
				_SelectMany selectMany = (_SelectMany)state;
				if (!selectMany.TryGetResult(selectMany.sourceAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						selectMany.sourceCurrent = selectMany.sourceEnumerator.Current;
						if (selectMany.selector1 != null)
						{
							selectMany.selectedEnumerator = selectMany.selector1(selectMany.sourceCurrent).GetAsyncEnumerator(selectMany.cancellationToken);
						}
						else
						{
							selectMany.selectedEnumerator = selectMany.selector2(selectMany.sourceCurrent, checked(selectMany.sourceIndex++)).GetAsyncEnumerator(selectMany.cancellationToken);
						}
					}
					catch (Exception error)
					{
						selectMany.completionSource.TrySetException(error);
						return;
					}
					selectMany.MoveNextSelected();
				}
				else
				{
					selectMany.completionSource.TrySetResult(result: false);
				}
			}

			private static void SeletedSourceMoveNextCore(object state)
			{
				_SelectMany selectMany = (_SelectMany)state;
				if (!selectMany.TryGetResult(selectMany.selectedAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						selectMany.Current = selectMany.resultSelector(selectMany.sourceCurrent, selectMany.selectedEnumerator.Current);
					}
					catch (Exception error)
					{
						selectMany.completionSource.TrySetException(error);
						return;
					}
					selectMany.completionSource.TrySetResult(result: true);
					return;
				}
				try
				{
					selectMany.selectedDisposeAsyncAwaiter = selectMany.selectedEnumerator.DisposeAsync().GetAwaiter();
				}
				catch (Exception error2)
				{
					selectMany.completionSource.TrySetException(error2);
					return;
				}
				if (selectMany.selectedDisposeAsyncAwaiter.IsCompleted)
				{
					SelectedEnumeratorDisposeAsyncCore(selectMany);
				}
				else
				{
					selectMany.selectedDisposeAsyncAwaiter.SourceOnCompleted(selectedEnumeratorDisposeAsyncCoreDelegate, selectMany);
				}
			}

			private static void SelectedEnumeratorDisposeAsyncCore(object state)
			{
				_SelectMany selectMany = (_SelectMany)state;
				if (selectMany.TryGetResult(selectMany.selectedDisposeAsyncAwaiter))
				{
					selectMany.selectedEnumerator = null;
					selectMany.selectedAwaiter = default(UniTask<bool>.Awaiter);
					selectMany.MoveNextSource();
				}
			}

			public async UniTask DisposeAsync()
			{
				if (selectedEnumerator != null)
				{
					await selectedEnumerator.DisposeAsync();
				}
				if (sourceEnumerator != null)
				{
					await sourceEnumerator.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, IUniTaskAsyncEnumerable<TCollection>> selector1;

		private readonly Func<TSource, int, IUniTaskAsyncEnumerable<TCollection>> selector2;

		private readonly Func<TSource, TCollection, TResult> resultSelector;

		public SelectMany(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, IUniTaskAsyncEnumerable<TCollection>> selector, Func<TSource, TCollection, TResult> resultSelector)
		{
			this.source = source;
			selector1 = selector;
			selector2 = null;
			this.resultSelector = resultSelector;
		}

		public SelectMany(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, IUniTaskAsyncEnumerable<TCollection>> selector, Func<TSource, TCollection, TResult> resultSelector)
		{
			this.source = source;
			selector1 = null;
			selector2 = selector;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectMany(source, selector1, selector2, resultSelector, cancellationToken);
		}
	}
	internal sealed class SelectManyAwait<TSource, TCollection, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectManyAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> sourceMoveNextCoreDelegate = SourceMoveNextCore;

			private static readonly Action<object> selectedSourceMoveNextCoreDelegate = SeletedSourceMoveNextCore;

			private static readonly Action<object> selectedEnumeratorDisposeAsyncCoreDelegate = SelectedEnumeratorDisposeAsyncCore;

			private static readonly Action<object> selectorAwaitCoreDelegate = SelectorAwaitCore;

			private static readonly Action<object> resultSelectorAwaitCoreDelegate = ResultSelectorAwaitCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector1;

			private readonly Func<TSource, int, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector2;

			private readonly Func<TSource, TCollection, UniTask<TResult>> resultSelector;

			private CancellationToken cancellationToken;

			private TSource sourceCurrent;

			private int sourceIndex;

			private IUniTaskAsyncEnumerator<TSource> sourceEnumerator;

			private IUniTaskAsyncEnumerator<TCollection> selectedEnumerator;

			private UniTask<bool>.Awaiter sourceAwaiter;

			private UniTask<bool>.Awaiter selectedAwaiter;

			private UniTask.Awaiter selectedDisposeAsyncAwaiter;

			private UniTask<IUniTaskAsyncEnumerable<TCollection>>.Awaiter collectionSelectorAwaiter;

			private UniTask<TResult>.Awaiter resultSelectorAwaiter;

			public TResult Current { get; private set; }

			public _SelectManyAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector1, Func<TSource, int, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector2, Func<TSource, TCollection, UniTask<TResult>> resultSelector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector1 = selector1;
				this.selector2 = selector2;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				completionSource.Reset();
				if (selectedEnumerator != null)
				{
					MoveNextSelected();
				}
				else
				{
					if (sourceEnumerator == null)
					{
						sourceEnumerator = source.GetAsyncEnumerator(cancellationToken);
					}
					MoveNextSource();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNextSource()
			{
				try
				{
					sourceAwaiter = sourceEnumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (sourceAwaiter.IsCompleted)
				{
					SourceMoveNextCore(this);
				}
				else
				{
					sourceAwaiter.SourceOnCompleted(sourceMoveNextCoreDelegate, this);
				}
			}

			private void MoveNextSelected()
			{
				try
				{
					selectedAwaiter = selectedEnumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (selectedAwaiter.IsCompleted)
				{
					SeletedSourceMoveNextCore(this);
				}
				else
				{
					selectedAwaiter.SourceOnCompleted(selectedSourceMoveNextCoreDelegate, this);
				}
			}

			private static void SourceMoveNextCore(object state)
			{
				_SelectManyAwait selectManyAwait = (_SelectManyAwait)state;
				if (!selectManyAwait.TryGetResult(selectManyAwait.sourceAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						selectManyAwait.sourceCurrent = selectManyAwait.sourceEnumerator.Current;
						if (selectManyAwait.selector1 != null)
						{
							selectManyAwait.collectionSelectorAwaiter = selectManyAwait.selector1(selectManyAwait.sourceCurrent).GetAwaiter();
						}
						else
						{
							selectManyAwait.collectionSelectorAwaiter = selectManyAwait.selector2(selectManyAwait.sourceCurrent, checked(selectManyAwait.sourceIndex++)).GetAwaiter();
						}
						if (selectManyAwait.collectionSelectorAwaiter.IsCompleted)
						{
							SelectorAwaitCore(selectManyAwait);
						}
						else
						{
							selectManyAwait.collectionSelectorAwaiter.SourceOnCompleted(selectorAwaitCoreDelegate, selectManyAwait);
						}
						return;
					}
					catch (Exception error)
					{
						selectManyAwait.completionSource.TrySetException(error);
						return;
					}
				}
				selectManyAwait.completionSource.TrySetResult(result: false);
			}

			private static void SeletedSourceMoveNextCore(object state)
			{
				_SelectManyAwait selectManyAwait = (_SelectManyAwait)state;
				if (!selectManyAwait.TryGetResult(selectManyAwait.selectedAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						selectManyAwait.resultSelectorAwaiter = selectManyAwait.resultSelector(selectManyAwait.sourceCurrent, selectManyAwait.selectedEnumerator.Current).GetAwaiter();
						if (selectManyAwait.resultSelectorAwaiter.IsCompleted)
						{
							ResultSelectorAwaitCore(selectManyAwait);
						}
						else
						{
							selectManyAwait.resultSelectorAwaiter.SourceOnCompleted(resultSelectorAwaitCoreDelegate, selectManyAwait);
						}
						return;
					}
					catch (Exception error)
					{
						selectManyAwait.completionSource.TrySetException(error);
						return;
					}
				}
				try
				{
					selectManyAwait.selectedDisposeAsyncAwaiter = selectManyAwait.selectedEnumerator.DisposeAsync().GetAwaiter();
				}
				catch (Exception error2)
				{
					selectManyAwait.completionSource.TrySetException(error2);
					return;
				}
				if (selectManyAwait.selectedDisposeAsyncAwaiter.IsCompleted)
				{
					SelectedEnumeratorDisposeAsyncCore(selectManyAwait);
				}
				else
				{
					selectManyAwait.selectedDisposeAsyncAwaiter.SourceOnCompleted(selectedEnumeratorDisposeAsyncCoreDelegate, selectManyAwait);
				}
			}

			private static void SelectedEnumeratorDisposeAsyncCore(object state)
			{
				_SelectManyAwait selectManyAwait = (_SelectManyAwait)state;
				if (selectManyAwait.TryGetResult(selectManyAwait.selectedDisposeAsyncAwaiter))
				{
					selectManyAwait.selectedEnumerator = null;
					selectManyAwait.selectedAwaiter = default(UniTask<bool>.Awaiter);
					selectManyAwait.MoveNextSource();
				}
			}

			private static void SelectorAwaitCore(object state)
			{
				_SelectManyAwait selectManyAwait = (_SelectManyAwait)state;
				if (selectManyAwait.TryGetResult(selectManyAwait.collectionSelectorAwaiter, out var result))
				{
					selectManyAwait.selectedEnumerator = result.GetAsyncEnumerator(selectManyAwait.cancellationToken);
					selectManyAwait.MoveNextSelected();
				}
			}

			private static void ResultSelectorAwaitCore(object state)
			{
				_SelectManyAwait selectManyAwait = (_SelectManyAwait)state;
				if (selectManyAwait.TryGetResult(selectManyAwait.resultSelectorAwaiter, out var result))
				{
					selectManyAwait.Current = result;
					selectManyAwait.completionSource.TrySetResult(result: true);
				}
			}

			public async UniTask DisposeAsync()
			{
				if (selectedEnumerator != null)
				{
					await selectedEnumerator.DisposeAsync();
				}
				if (sourceEnumerator != null)
				{
					await sourceEnumerator.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector1;

		private readonly Func<TSource, int, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector2;

		private readonly Func<TSource, TCollection, UniTask<TResult>> resultSelector;

		public SelectManyAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector, Func<TSource, TCollection, UniTask<TResult>> resultSelector)
		{
			this.source = source;
			selector1 = selector;
			selector2 = null;
			this.resultSelector = resultSelector;
		}

		public SelectManyAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector, Func<TSource, TCollection, UniTask<TResult>> resultSelector)
		{
			this.source = source;
			selector1 = null;
			selector2 = selector;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectManyAwait(source, selector1, selector2, resultSelector, cancellationToken);
		}
	}
	internal sealed class SelectManyAwaitWithCancellation<TSource, TCollection, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _SelectManyAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> sourceMoveNextCoreDelegate = SourceMoveNextCore;

			private static readonly Action<object> selectedSourceMoveNextCoreDelegate = SeletedSourceMoveNextCore;

			private static readonly Action<object> selectedEnumeratorDisposeAsyncCoreDelegate = SelectedEnumeratorDisposeAsyncCore;

			private static readonly Action<object> selectorAwaitCoreDelegate = SelectorAwaitCore;

			private static readonly Action<object> resultSelectorAwaitCoreDelegate = ResultSelectorAwaitCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector1;

			private readonly Func<TSource, int, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector2;

			private readonly Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector;

			private CancellationToken cancellationToken;

			private TSource sourceCurrent;

			private int sourceIndex;

			private IUniTaskAsyncEnumerator<TSource> sourceEnumerator;

			private IUniTaskAsyncEnumerator<TCollection> selectedEnumerator;

			private UniTask<bool>.Awaiter sourceAwaiter;

			private UniTask<bool>.Awaiter selectedAwaiter;

			private UniTask.Awaiter selectedDisposeAsyncAwaiter;

			private UniTask<IUniTaskAsyncEnumerable<TCollection>>.Awaiter collectionSelectorAwaiter;

			private UniTask<TResult>.Awaiter resultSelectorAwaiter;

			public TResult Current { get; private set; }

			public _SelectManyAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector1, Func<TSource, int, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector2, Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector, CancellationToken cancellationToken)
			{
				this.source = source;
				this.selector1 = selector1;
				this.selector2 = selector2;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				completionSource.Reset();
				if (selectedEnumerator != null)
				{
					MoveNextSelected();
				}
				else
				{
					if (sourceEnumerator == null)
					{
						sourceEnumerator = source.GetAsyncEnumerator(cancellationToken);
					}
					MoveNextSource();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNextSource()
			{
				try
				{
					sourceAwaiter = sourceEnumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (sourceAwaiter.IsCompleted)
				{
					SourceMoveNextCore(this);
				}
				else
				{
					sourceAwaiter.SourceOnCompleted(sourceMoveNextCoreDelegate, this);
				}
			}

			private void MoveNextSelected()
			{
				try
				{
					selectedAwaiter = selectedEnumerator.MoveNextAsync().GetAwaiter();
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
					return;
				}
				if (selectedAwaiter.IsCompleted)
				{
					SeletedSourceMoveNextCore(this);
				}
				else
				{
					selectedAwaiter.SourceOnCompleted(selectedSourceMoveNextCoreDelegate, this);
				}
			}

			private static void SourceMoveNextCore(object state)
			{
				_SelectManyAwaitWithCancellation selectManyAwaitWithCancellation = (_SelectManyAwaitWithCancellation)state;
				if (!selectManyAwaitWithCancellation.TryGetResult(selectManyAwaitWithCancellation.sourceAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						selectManyAwaitWithCancellation.sourceCurrent = selectManyAwaitWithCancellation.sourceEnumerator.Current;
						if (selectManyAwaitWithCancellation.selector1 != null)
						{
							selectManyAwaitWithCancellation.collectionSelectorAwaiter = selectManyAwaitWithCancellation.selector1(selectManyAwaitWithCancellation.sourceCurrent, selectManyAwaitWithCancellation.cancellationToken).GetAwaiter();
						}
						else
						{
							selectManyAwaitWithCancellation.collectionSelectorAwaiter = selectManyAwaitWithCancellation.selector2(selectManyAwaitWithCancellation.sourceCurrent, checked(selectManyAwaitWithCancellation.sourceIndex++), selectManyAwaitWithCancellation.cancellationToken).GetAwaiter();
						}
						if (selectManyAwaitWithCancellation.collectionSelectorAwaiter.IsCompleted)
						{
							SelectorAwaitCore(selectManyAwaitWithCancellation);
						}
						else
						{
							selectManyAwaitWithCancellation.collectionSelectorAwaiter.SourceOnCompleted(selectorAwaitCoreDelegate, selectManyAwaitWithCancellation);
						}
						return;
					}
					catch (Exception error)
					{
						selectManyAwaitWithCancellation.completionSource.TrySetException(error);
						return;
					}
				}
				selectManyAwaitWithCancellation.completionSource.TrySetResult(result: false);
			}

			private static void SeletedSourceMoveNextCore(object state)
			{
				_SelectManyAwaitWithCancellation selectManyAwaitWithCancellation = (_SelectManyAwaitWithCancellation)state;
				if (!selectManyAwaitWithCancellation.TryGetResult(selectManyAwaitWithCancellation.selectedAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						selectManyAwaitWithCancellation.resultSelectorAwaiter = selectManyAwaitWithCancellation.resultSelector(selectManyAwaitWithCancellation.sourceCurrent, selectManyAwaitWithCancellation.selectedEnumerator.Current, selectManyAwaitWithCancellation.cancellationToken).GetAwaiter();
						if (selectManyAwaitWithCancellation.resultSelectorAwaiter.IsCompleted)
						{
							ResultSelectorAwaitCore(selectManyAwaitWithCancellation);
						}
						else
						{
							selectManyAwaitWithCancellation.resultSelectorAwaiter.SourceOnCompleted(resultSelectorAwaitCoreDelegate, selectManyAwaitWithCancellation);
						}
						return;
					}
					catch (Exception error)
					{
						selectManyAwaitWithCancellation.completionSource.TrySetException(error);
						return;
					}
				}
				try
				{
					selectManyAwaitWithCancellation.selectedDisposeAsyncAwaiter = selectManyAwaitWithCancellation.selectedEnumerator.DisposeAsync().GetAwaiter();
				}
				catch (Exception error2)
				{
					selectManyAwaitWithCancellation.completionSource.TrySetException(error2);
					return;
				}
				if (selectManyAwaitWithCancellation.selectedDisposeAsyncAwaiter.IsCompleted)
				{
					SelectedEnumeratorDisposeAsyncCore(selectManyAwaitWithCancellation);
				}
				else
				{
					selectManyAwaitWithCancellation.selectedDisposeAsyncAwaiter.SourceOnCompleted(selectedEnumeratorDisposeAsyncCoreDelegate, selectManyAwaitWithCancellation);
				}
			}

			private static void SelectedEnumeratorDisposeAsyncCore(object state)
			{
				_SelectManyAwaitWithCancellation selectManyAwaitWithCancellation = (_SelectManyAwaitWithCancellation)state;
				if (selectManyAwaitWithCancellation.TryGetResult(selectManyAwaitWithCancellation.selectedDisposeAsyncAwaiter))
				{
					selectManyAwaitWithCancellation.selectedEnumerator = null;
					selectManyAwaitWithCancellation.selectedAwaiter = default(UniTask<bool>.Awaiter);
					selectManyAwaitWithCancellation.MoveNextSource();
				}
			}

			private static void SelectorAwaitCore(object state)
			{
				_SelectManyAwaitWithCancellation selectManyAwaitWithCancellation = (_SelectManyAwaitWithCancellation)state;
				if (selectManyAwaitWithCancellation.TryGetResult(selectManyAwaitWithCancellation.collectionSelectorAwaiter, out var result))
				{
					selectManyAwaitWithCancellation.selectedEnumerator = result.GetAsyncEnumerator(selectManyAwaitWithCancellation.cancellationToken);
					selectManyAwaitWithCancellation.MoveNextSelected();
				}
			}

			private static void ResultSelectorAwaitCore(object state)
			{
				_SelectManyAwaitWithCancellation selectManyAwaitWithCancellation = (_SelectManyAwaitWithCancellation)state;
				if (selectManyAwaitWithCancellation.TryGetResult(selectManyAwaitWithCancellation.resultSelectorAwaiter, out var result))
				{
					selectManyAwaitWithCancellation.Current = result;
					selectManyAwaitWithCancellation.completionSource.TrySetResult(result: true);
				}
			}

			public async UniTask DisposeAsync()
			{
				if (selectedEnumerator != null)
				{
					await selectedEnumerator.DisposeAsync();
				}
				if (sourceEnumerator != null)
				{
					await sourceEnumerator.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector1;

		private readonly Func<TSource, int, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector2;

		private readonly Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector;

		public SelectManyAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector, Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector)
		{
			this.source = source;
			selector1 = selector;
			selector2 = null;
			this.resultSelector = resultSelector;
		}

		public SelectManyAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<IUniTaskAsyncEnumerable<TCollection>>> selector, Func<TSource, TCollection, CancellationToken, UniTask<TResult>> resultSelector)
		{
			this.source = source;
			selector1 = null;
			selector2 = selector;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SelectManyAwaitWithCancellation(source, selector1, selector2, resultSelector, cancellationToken);
		}
	}
	internal static class SequenceEqual
	{
		internal static async UniTask<bool> SequenceEqualAsync<TSource>(IUniTaskAsyncEnumerable<TSource> first, IUniTaskAsyncEnumerable<TSource> second, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e1 = first.GetAsyncEnumerator(cancellationToken);
			bool result;
			try
			{
				IUniTaskAsyncEnumerator<TSource> e2 = second.GetAsyncEnumerator(cancellationToken);
				bool flag;
				try
				{
					while (true)
					{
						if (await e1.MoveNextAsync())
						{
							if (await e2.MoveNextAsync())
							{
								if (!comparer.Equals(e1.Current, e2.Current))
								{
									flag = false;
									break;
								}
								continue;
							}
							flag = false;
							break;
						}
						flag = ((!(await e2.MoveNextAsync())) ? true : false);
						break;
					}
				}
				finally
				{
					IAsyncDisposable asyncDisposable2 = e2 as IAsyncDisposable;
					if (asyncDisposable2 != null)
					{
						await asyncDisposable2.DisposeAsync();
					}
				}
				result = flag;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e1 as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class SingleOperator
	{
		public static async UniTask<TSource> SingleAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				if (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					if (await e.MoveNextAsync())
					{
						throw Error.MoreThanOneElement();
					}
					result = v;
				}
				else
				{
					if (!defaultIfEmpty)
					{
						throw Error.NoElements();
					}
					result = default(TSource);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> SingleAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				bool found = false;
				while (await e.MoveNextAsync())
				{
					TSource current = e.Current;
					if (predicate(current))
					{
						if (found)
						{
							throw Error.MoreThanOneElement();
						}
						found = true;
						value = current;
					}
				}
				if (!(found || defaultIfEmpty))
				{
					throw Error.NoElements();
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> SingleAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				bool found = false;
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					if (await predicate(v))
					{
						if (found)
						{
							throw Error.MoreThanOneElement();
						}
						found = true;
						value = v;
					}
				}
				if (!(found || defaultIfEmpty))
				{
					throw Error.NoElements();
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}

		public static async UniTask<TSource> SingleAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken, bool defaultIfEmpty)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			TSource result;
			try
			{
				TSource value = default(TSource);
				bool found = false;
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					if (await predicate(v, cancellationToken))
					{
						if (found)
						{
							throw Error.MoreThanOneElement();
						}
						found = true;
						value = v;
					}
				}
				if (!(found || defaultIfEmpty))
				{
					throw Error.NoElements();
				}
				result = value;
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal sealed class Skip<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Skip : AsyncEnumeratorBase<TSource, TSource>
		{
			private readonly int count;

			private int index;

			public _Skip(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.count = count;
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					if (count <= checked(index++))
					{
						base.Current = base.SourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly int count;

		public Skip(IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			this.source = source;
			this.count = count;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Skip(source, count, cancellationToken);
		}
	}
	internal sealed class SkipLast<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _SkipLast : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly int count;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Queue<TSource> queue;

			private bool continueNext;

			public TSource Current { get; private set; }

			public _SkipLast(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
			{
				this.source = source;
				this.count = count;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken);
					queue = new Queue<TSource>();
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					while (true)
					{
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_SkipLast skipLast = (_SkipLast)state;
				if (skipLast.TryGetResult(skipLast.awaiter, out var result))
				{
					if (result)
					{
						if (skipLast.queue.Count == skipLast.count)
						{
							skipLast.continueNext = false;
							TSource current = skipLast.queue.Dequeue();
							skipLast.Current = current;
							skipLast.queue.Enqueue(skipLast.enumerator.Current);
							skipLast.completionSource.TrySetResult(result: true);
						}
						else
						{
							skipLast.queue.Enqueue(skipLast.enumerator.Current);
							if (!skipLast.continueNext)
							{
								skipLast.SourceMoveNext();
							}
						}
					}
					else
					{
						skipLast.continueNext = false;
						skipLast.completionSource.TrySetResult(result: false);
					}
				}
				else
				{
					skipLast.continueNext = false;
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly int count;

		public SkipLast(IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			this.source = source;
			this.count = count;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipLast(source, count, cancellationToken);
		}
	}
	internal sealed class SkipUntil<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _SkipUntil : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> CancelDelegate1 = OnCanceled1;

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken1;

			private bool completed;

			private CancellationTokenRegistration cancellationTokenRegistration1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private bool continueNext;

			private Exception exception;

			public TSource Current { get; private set; }

			public _SkipUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, CancellationToken cancellationToken1)
			{
				this.source = source;
				this.cancellationToken1 = cancellationToken1;
				if (cancellationToken1.CanBeCanceled)
				{
					cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
				}
				RunOther(other).Forget();
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (exception != null)
				{
					return UniTask.FromException<bool>(exception);
				}
				if (cancellationToken1.IsCancellationRequested)
				{
					return UniTask.FromCanceled<bool>(cancellationToken1);
				}
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken1);
				}
				completionSource.Reset();
				if (completed)
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					while (true)
					{
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_SkipUntil skipUntil = (_SkipUntil)state;
				if (!skipUntil.TryGetResult(skipUntil.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					skipUntil.Current = skipUntil.enumerator.Current;
					skipUntil.completionSource.TrySetResult(result: true);
					if (skipUntil.continueNext)
					{
						skipUntil.SourceMoveNext();
					}
				}
				else
				{
					skipUntil.completionSource.TrySetResult(result: false);
				}
			}

			private async UniTaskVoid RunOther(UniTask other)
			{
				try
				{
					await other;
					completed = true;
					SourceMoveNext();
				}
				catch (Exception ex)
				{
					Exception error = (exception = ex);
					completionSource.TrySetException(error);
				}
			}

			private static void OnCanceled1(object state)
			{
				_SkipUntil skipUntil = (_SkipUntil)state;
				skipUntil.completionSource.TrySetCanceled(skipUntil.cancellationToken1);
			}

			public UniTask DisposeAsync()
			{
				cancellationTokenRegistration1.Dispose();
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly UniTask other;

		private readonly Func<CancellationToken, UniTask> other2;

		public SkipUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, Func<CancellationToken, UniTask> other2)
		{
			this.source = source;
			this.other = other;
			this.other2 = other2;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (other2 != null)
			{
				return new _SkipUntil(source, other2(cancellationToken), cancellationToken);
			}
			return new _SkipUntil(source, other, cancellationToken);
		}
	}
	internal sealed class SkipUntilCanceled<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _SkipUntilCanceled : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> CancelDelegate1 = OnCanceled1;

			private static readonly Action<object> CancelDelegate2 = OnCanceled2;

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken1;

			private CancellationToken cancellationToken2;

			private CancellationTokenRegistration cancellationTokenRegistration1;

			private CancellationTokenRegistration cancellationTokenRegistration2;

			private int isCanceled;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private bool continueNext;

			public TSource Current { get; private set; }

			public _SkipUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken1, CancellationToken cancellationToken2)
			{
				this.source = source;
				this.cancellationToken1 = cancellationToken1;
				this.cancellationToken2 = cancellationToken2;
				if (cancellationToken1.CanBeCanceled)
				{
					cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
				}
				if (cancellationToken1 != cancellationToken2 && cancellationToken2.CanBeCanceled)
				{
					cancellationTokenRegistration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(CancelDelegate2, this);
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (enumerator == null)
				{
					if (cancellationToken1.IsCancellationRequested)
					{
						isCanceled = 1;
					}
					if (cancellationToken2.IsCancellationRequested)
					{
						isCanceled = 1;
					}
					enumerator = source.GetAsyncEnumerator(cancellationToken2);
				}
				completionSource.Reset();
				if (isCanceled != 0)
				{
					SourceMoveNext();
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					while (true)
					{
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_SkipUntilCanceled skipUntilCanceled = (_SkipUntilCanceled)state;
				if (!skipUntilCanceled.TryGetResult(skipUntilCanceled.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					skipUntilCanceled.Current = skipUntilCanceled.enumerator.Current;
					skipUntilCanceled.completionSource.TrySetResult(result: true);
					if (skipUntilCanceled.continueNext)
					{
						skipUntilCanceled.SourceMoveNext();
					}
				}
				else
				{
					skipUntilCanceled.completionSource.TrySetResult(result: false);
				}
			}

			private static void OnCanceled1(object state)
			{
				_SkipUntilCanceled skipUntilCanceled = (_SkipUntilCanceled)state;
				if (skipUntilCanceled.isCanceled == 0 && Interlocked.Increment(ref skipUntilCanceled.isCanceled) == 1)
				{
					skipUntilCanceled.cancellationTokenRegistration2.Dispose();
					skipUntilCanceled.SourceMoveNext();
				}
			}

			private static void OnCanceled2(object state)
			{
				_SkipUntilCanceled skipUntilCanceled = (_SkipUntilCanceled)state;
				if (skipUntilCanceled.isCanceled == 0 && Interlocked.Increment(ref skipUntilCanceled.isCanceled) == 1)
				{
					skipUntilCanceled.cancellationTokenRegistration2.Dispose();
					skipUntilCanceled.SourceMoveNext();
				}
			}

			public UniTask DisposeAsync()
			{
				cancellationTokenRegistration1.Dispose();
				cancellationTokenRegistration2.Dispose();
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly CancellationToken cancellationToken;

		public SkipUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			this.source = source;
			this.cancellationToken = cancellationToken;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipUntilCanceled(source, this.cancellationToken, cancellationToken);
		}
	}
	internal sealed class SkipWhile<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _SkipWhile : AsyncEnumeratorBase<TSource, TSource>
		{
			private Func<TSource, bool> predicate;

			public _SkipWhile(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					if (predicate == null || !predicate(base.SourceCurrent))
					{
						predicate = null;
						base.Current = base.SourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, bool> predicate;

		public SkipWhile(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipWhile(source, predicate, cancellationToken);
		}
	}
	internal sealed class SkipWhileInt<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _SkipWhileInt : AsyncEnumeratorBase<TSource, TSource>
		{
			private Func<TSource, int, bool> predicate;

			private int index;

			public _SkipWhileInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent)
				{
					if (predicate == null || !predicate(base.SourceCurrent, checked(index++)))
					{
						predicate = null;
						base.Current = base.SourceCurrent;
						result = true;
						return true;
					}
					result = false;
					return false;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, bool> predicate;

		public SkipWhileInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipWhileInt(source, predicate, cancellationToken);
		}
	}
	internal sealed class SkipWhileAwait<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _SkipWhileAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private Func<TSource, UniTask<bool>> predicate;

			public _SkipWhileAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				if (predicate == null)
				{
					return CompletedTasks.False;
				}
				return predicate(sourceCurrent);
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				if (!awaitResult)
				{
					predicate = null;
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = false;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<bool>> predicate;

		public SkipWhileAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipWhileAwait(source, predicate, cancellationToken);
		}
	}
	internal sealed class SkipWhileIntAwait<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _SkipWhileIntAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private Func<TSource, int, UniTask<bool>> predicate;

			private int index;

			public _SkipWhileIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				if (predicate == null)
				{
					return CompletedTasks.False;
				}
				return predicate(sourceCurrent, checked(index++));
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				terminateIteration = false;
				if (!awaitResult)
				{
					predicate = null;
					base.Current = base.SourceCurrent;
					return true;
				}
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, UniTask<bool>> predicate;

		public SkipWhileIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipWhileIntAwait(source, predicate, cancellationToken);
		}
	}
	internal sealed class SkipWhileAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _SkipWhileAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private Func<TSource, CancellationToken, UniTask<bool>> predicate;

			public _SkipWhileAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				if (predicate == null)
				{
					return CompletedTasks.False;
				}
				return predicate(sourceCurrent, cancellationToken);
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				terminateIteration = false;
				if (!awaitResult)
				{
					predicate = null;
					base.Current = base.SourceCurrent;
					return true;
				}
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<bool>> predicate;

		public SkipWhileAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipWhileAwaitWithCancellation(source, predicate, cancellationToken);
		}
	}
	internal sealed class SkipWhileIntAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _SkipWhileIntAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private Func<TSource, int, CancellationToken, UniTask<bool>> predicate;

			private int index;

			public _SkipWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				if (predicate == null)
				{
					return CompletedTasks.False;
				}
				return predicate(sourceCurrent, checked(index++), cancellationToken);
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				terminateIteration = false;
				if (!awaitResult)
				{
					predicate = null;
					base.Current = base.SourceCurrent;
					return true;
				}
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, CancellationToken, UniTask<bool>> predicate;

		public SkipWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _SkipWhileIntAwaitWithCancellation(source, predicate, cancellationToken);
		}
	}
	internal sealed class CancellationTokenDisposable : IDisposable
	{
		private readonly CancellationTokenSource cts = new CancellationTokenSource();

		public CancellationToken Token => cts.Token;

		public void Dispose()
		{
			if (!cts.IsCancellationRequested)
			{
				cts.Cancel();
			}
		}
	}
	internal static class Subscribe
	{
		public static readonly Action<Exception> NopError = delegate
		{
		};

		public static readonly Action NopCompleted = delegate
		{
		};

		public static async UniTaskVoid SubscribeCore<TSource>(IUniTaskAsyncEnumerable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					try
					{
						onNext(e.Current);
					}
					catch (Exception ex)
					{
						UniTaskScheduler.PublishUnobservedTaskException(ex);
					}
				}
				onCompleted();
			}
			catch (Exception ex2)
			{
				if (onError == NopError)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
					return;
				}
				if (ex2 is OperationCanceledException)
				{
					return;
				}
				onError(ex2);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTaskVoid SubscribeCore<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTaskVoid> onNext, Action<Exception> onError, Action onCompleted, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					try
					{
						onNext(e.Current).Forget();
					}
					catch (Exception ex)
					{
						UniTaskScheduler.PublishUnobservedTaskException(ex);
					}
				}
				onCompleted();
			}
			catch (Exception ex2)
			{
				if (onError == NopError)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
					return;
				}
				if (ex2 is OperationCanceledException)
				{
					return;
				}
				onError(ex2);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTaskVoid SubscribeCore<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTaskVoid> onNext, Action<Exception> onError, Action onCompleted, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					try
					{
						onNext(e.Current, cancellationToken).Forget();
					}
					catch (Exception ex)
					{
						UniTaskScheduler.PublishUnobservedTaskException(ex);
					}
				}
				onCompleted();
			}
			catch (Exception ex2)
			{
				if (onError == NopError)
				{
					UniTaskScheduler.PublishUnobservedTaskException(ex2);
					return;
				}
				if (ex2 is OperationCanceledException)
				{
					return;
				}
				onError(ex2);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTaskVoid SubscribeCore<TSource>(IUniTaskAsyncEnumerable<TSource> source, IObserver<TSource> observer, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					try
					{
						observer.OnNext(e.Current);
					}
					catch (Exception ex)
					{
						UniTaskScheduler.PublishUnobservedTaskException(ex);
					}
				}
				observer.OnCompleted();
			}
			catch (Exception ex2)
			{
				if (ex2 is OperationCanceledException)
				{
					return;
				}
				observer.OnError(ex2);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTaskVoid SubscribeAwaitCore<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> onNext, Action<Exception> onError, Action onCompleted, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				_ = 1;
				try
				{
					while (await e.MoveNextAsync())
					{
						try
						{
							await onNext(e.Current);
						}
						catch (Exception ex)
						{
							UniTaskScheduler.PublishUnobservedTaskException(ex);
						}
					}
					onCompleted();
				}
				catch (Exception ex2)
				{
					if (onError == NopError)
					{
						UniTaskScheduler.PublishUnobservedTaskException(ex2);
						return;
					}
					if (ex2 is OperationCanceledException)
					{
						return;
					}
					onError(ex2);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}

		public static async UniTaskVoid SubscribeAwaitCore<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask> onNext, Action<Exception> onError, Action onCompleted, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				_ = 1;
				try
				{
					while (await e.MoveNextAsync())
					{
						try
						{
							await onNext(e.Current, cancellationToken);
						}
						catch (Exception ex)
						{
							UniTaskScheduler.PublishUnobservedTaskException(ex);
						}
					}
					onCompleted();
				}
				catch (Exception ex2)
				{
					if (onError == NopError)
					{
						UniTaskScheduler.PublishUnobservedTaskException(ex2);
						return;
					}
					if (ex2 is OperationCanceledException)
					{
						return;
					}
					onError(ex2);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}
	}
	internal static class Sum
	{
		public static async UniTask<int> SumAsync(IUniTaskAsyncEnumerable<int> source, CancellationToken cancellationToken)
		{
			int sum = 0;
			IUniTaskAsyncEnumerator<int> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
		{
			int sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			int sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					int num = sum;
					sum = num + await selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int>> selector, CancellationToken cancellationToken)
		{
			int sum = 0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					int num = sum;
					sum = num + await selector(e.Current, cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long> SumAsync(IUniTaskAsyncEnumerable<long> source, CancellationToken cancellationToken)
		{
			long sum = 0L;
			IUniTaskAsyncEnumerator<long> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
		{
			long sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					long num = sum;
					sum = num + await selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long>> selector, CancellationToken cancellationToken)
		{
			long sum = 0L;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					long num = sum;
					sum = num + await selector(e.Current, cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float> SumAsync(IUniTaskAsyncEnumerable<float> source, CancellationToken cancellationToken)
		{
			float sum = 0f;
			IUniTaskAsyncEnumerator<float> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
		{
			float sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			float sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float num = sum;
					sum = num + await selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float>> selector, CancellationToken cancellationToken)
		{
			float sum = 0f;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					float num = sum;
					sum = num + await selector(e.Current, cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double> SumAsync(IUniTaskAsyncEnumerable<double> source, CancellationToken cancellationToken)
		{
			double sum = 0.0;
			IUniTaskAsyncEnumerator<double> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
		{
			double sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			double sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double num = sum;
					sum = num + await selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double>> selector, CancellationToken cancellationToken)
		{
			double sum = 0.0;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					double num = sum;
					sum = num + await selector(e.Current, cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal> SumAsync(IUniTaskAsyncEnumerable<decimal> source, CancellationToken cancellationToken)
		{
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<decimal> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current;
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
		{
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal num = sum;
					sum = num + await selector(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal>> selector, CancellationToken cancellationToken)
		{
			decimal sum = default(decimal);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					decimal num = sum;
					sum = num + await selector(e.Current, cancellationToken);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int?> SumAsync(IUniTaskAsyncEnumerable<int?> source, CancellationToken cancellationToken)
		{
			int? sum = null;
			IUniTaskAsyncEnumerator<int?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current.GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int?> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
		{
			int? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int?> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			int? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<int?> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<int?>> selector, CancellationToken cancellationToken)
		{
			int? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long?> SumAsync(IUniTaskAsyncEnumerable<long?> source, CancellationToken cancellationToken)
		{
			long? sum = null;
			IUniTaskAsyncEnumerator<long?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current.GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long?> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
		{
			long? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long?> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<long?> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<long?>> selector, CancellationToken cancellationToken)
		{
			long? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float?> SumAsync(IUniTaskAsyncEnumerable<float?> source, CancellationToken cancellationToken)
		{
			float? sum = null;
			IUniTaskAsyncEnumerator<float?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current.GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float?> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
		{
			float? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float?> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			float? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<float?> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<float?>> selector, CancellationToken cancellationToken)
		{
			float? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double?> SumAsync(IUniTaskAsyncEnumerable<double?> source, CancellationToken cancellationToken)
		{
			double? sum = null;
			IUniTaskAsyncEnumerator<double?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += e.Current.GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double?> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
		{
			double? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += selector(e.Current).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double?> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			double? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<double?> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<double?>> selector, CancellationToken cancellationToken)
		{
			double? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal?> SumAsync(IUniTaskAsyncEnumerable<decimal?> source, CancellationToken cancellationToken)
		{
			decimal? sum = null;
			IUniTaskAsyncEnumerator<decimal?> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (decimal?)e.Current.GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal?> SumAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
		{
			decimal? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (decimal?)selector(e.Current).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal?> SumAwaitAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			decimal? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (decimal?)(await selector(e.Current)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}

		public static async UniTask<decimal?> SumAwaitWithCancellationAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<decimal?>> selector, CancellationToken cancellationToken)
		{
			decimal? sum = null;
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					sum += (decimal?)(await selector(e.Current, cancellationToken)).GetValueOrDefault();
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return sum;
		}
	}
	internal sealed class Take<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Take : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly int count;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private int index;

			public TSource Current { get; private set; }

			public _Take(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
			{
				this.source = source;
				this.count = count;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken);
				}
				if (index >= count)
				{
					return CompletedTasks.False;
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_Take take = (_Take)state;
				if (take.TryGetResult(take.awaiter, out var result))
				{
					if (result)
					{
						take.index++;
						take.Current = take.enumerator.Current;
						take.completionSource.TrySetResult(result: true);
					}
					else
					{
						take.completionSource.TrySetResult(result: false);
					}
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly int count;

		public Take(IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			this.source = source;
			this.count = count;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Take(source, count, cancellationToken);
		}
	}
	internal sealed class TakeLast<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _TakeLast : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly int count;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Queue<TSource> queue;

			private bool iterateCompleted;

			private bool continueNext;

			public TSource Current { get; private set; }

			public _TakeLast(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
			{
				this.source = source;
				this.count = count;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken);
					queue = new Queue<TSource>();
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				if (iterateCompleted)
				{
					if (queue.Count > 0)
					{
						Current = queue.Dequeue();
						completionSource.TrySetResult(result: true);
					}
					else
					{
						completionSource.TrySetResult(result: false);
					}
					return;
				}
				try
				{
					while (true)
					{
						awaiter = enumerator.MoveNextAsync().GetAwaiter();
						if (awaiter.IsCompleted)
						{
							continueNext = true;
							MoveNextCore(this);
							if (continueNext)
							{
								continueNext = false;
								continue;
							}
							break;
						}
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
						break;
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_TakeLast takeLast = (_TakeLast)state;
				if (takeLast.TryGetResult(takeLast.awaiter, out var result))
				{
					if (result)
					{
						if (takeLast.queue.Count < takeLast.count)
						{
							takeLast.queue.Enqueue(takeLast.enumerator.Current);
							if (!takeLast.continueNext)
							{
								takeLast.SourceMoveNext();
							}
							return;
						}
						takeLast.queue.Dequeue();
						takeLast.queue.Enqueue(takeLast.enumerator.Current);
						if (!takeLast.continueNext)
						{
							takeLast.SourceMoveNext();
						}
					}
					else
					{
						takeLast.continueNext = false;
						takeLast.iterateCompleted = true;
						takeLast.SourceMoveNext();
					}
				}
				else
				{
					takeLast.continueNext = false;
				}
			}

			public UniTask DisposeAsync()
			{
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly int count;

		public TakeLast(IUniTaskAsyncEnumerable<TSource> source, int count)
		{
			this.source = source;
			this.count = count;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeLast(source, count, cancellationToken);
		}
	}
	internal sealed class TakeUntil<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _TakeUntil : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> CancelDelegate1 = OnCanceled1;

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken1;

			private CancellationTokenRegistration cancellationTokenRegistration1;

			private bool completed;

			private Exception exception;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TSource Current { get; private set; }

			public _TakeUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, CancellationToken cancellationToken1)
			{
				this.source = source;
				this.cancellationToken1 = cancellationToken1;
				if (cancellationToken1.CanBeCanceled)
				{
					cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
				}
				RunOther(other).Forget();
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (completed)
				{
					return CompletedTasks.False;
				}
				if (exception != null)
				{
					return UniTask.FromException<bool>(exception);
				}
				if (cancellationToken1.IsCancellationRequested)
				{
					return UniTask.FromCanceled<bool>(cancellationToken1);
				}
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken1);
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_TakeUntil takeUntil = (_TakeUntil)state;
				if (!takeUntil.TryGetResult(takeUntil.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					if (takeUntil.exception != null)
					{
						takeUntil.completionSource.TrySetException(takeUntil.exception);
						return;
					}
					if (takeUntil.cancellationToken1.IsCancellationRequested)
					{
						takeUntil.completionSource.TrySetCanceled(takeUntil.cancellationToken1);
						return;
					}
					takeUntil.Current = takeUntil.enumerator.Current;
					takeUntil.completionSource.TrySetResult(result: true);
				}
				else
				{
					takeUntil.completionSource.TrySetResult(result: false);
				}
			}

			private async UniTaskVoid RunOther(UniTask other)
			{
				try
				{
					await other;
					completed = true;
					completionSource.TrySetResult(result: false);
				}
				catch (Exception ex)
				{
					Exception error = (exception = ex);
					completionSource.TrySetException(error);
				}
			}

			private static void OnCanceled1(object state)
			{
				_TakeUntil takeUntil = (_TakeUntil)state;
				takeUntil.completionSource.TrySetCanceled(takeUntil.cancellationToken1);
			}

			public UniTask DisposeAsync()
			{
				cancellationTokenRegistration1.Dispose();
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly UniTask other;

		private readonly Func<CancellationToken, UniTask> other2;

		public TakeUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, Func<CancellationToken, UniTask> other2)
		{
			this.source = source;
			this.other = other;
			this.other2 = other2;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (other2 != null)
			{
				return new _TakeUntil(source, other2(cancellationToken), cancellationToken);
			}
			return new _TakeUntil(source, other, cancellationToken);
		}
	}
	internal sealed class TakeUntilCanceled<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _TakeUntilCanceled : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> CancelDelegate1 = OnCanceled1;

			private static readonly Action<object> CancelDelegate2 = OnCanceled2;

			private static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private CancellationToken cancellationToken1;

			private CancellationToken cancellationToken2;

			private CancellationTokenRegistration cancellationTokenRegistration1;

			private CancellationTokenRegistration cancellationTokenRegistration2;

			private bool isCanceled;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			public TSource Current { get; private set; }

			public _TakeUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken1, CancellationToken cancellationToken2)
			{
				this.source = source;
				this.cancellationToken1 = cancellationToken1;
				this.cancellationToken2 = cancellationToken2;
				if (cancellationToken1.CanBeCanceled)
				{
					cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
				}
				if (cancellationToken1 != cancellationToken2 && cancellationToken2.CanBeCanceled)
				{
					cancellationTokenRegistration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(CancelDelegate2, this);
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (cancellationToken1.IsCancellationRequested)
				{
					isCanceled = true;
				}
				if (cancellationToken2.IsCancellationRequested)
				{
					isCanceled = true;
				}
				if (enumerator == null)
				{
					enumerator = source.GetAsyncEnumerator(cancellationToken2);
				}
				if (isCanceled)
				{
					return CompletedTasks.False;
				}
				completionSource.Reset();
				SourceMoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void SourceMoveNext()
			{
				try
				{
					awaiter = enumerator.MoveNextAsync().GetAwaiter();
					if (awaiter.IsCompleted)
					{
						MoveNextCore(this);
					}
					else
					{
						awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
					}
				}
				catch (Exception error)
				{
					completionSource.TrySetException(error);
				}
			}

			private static void MoveNextCore(object state)
			{
				_TakeUntilCanceled takeUntilCanceled = (_TakeUntilCanceled)state;
				if (!takeUntilCanceled.TryGetResult(takeUntilCanceled.awaiter, out var result))
				{
					return;
				}
				if (result)
				{
					if (takeUntilCanceled.isCanceled)
					{
						takeUntilCanceled.completionSource.TrySetResult(result: false);
						return;
					}
					takeUntilCanceled.Current = takeUntilCanceled.enumerator.Current;
					takeUntilCanceled.completionSource.TrySetResult(result: true);
				}
				else
				{
					takeUntilCanceled.completionSource.TrySetResult(result: false);
				}
			}

			private static void OnCanceled1(object state)
			{
				_TakeUntilCanceled takeUntilCanceled = (_TakeUntilCanceled)state;
				if (!takeUntilCanceled.isCanceled)
				{
					takeUntilCanceled.cancellationTokenRegistration2.Dispose();
					takeUntilCanceled.completionSource.TrySetResult(result: false);
				}
			}

			private static void OnCanceled2(object state)
			{
				_TakeUntilCanceled takeUntilCanceled = (_TakeUntilCanceled)state;
				if (!takeUntilCanceled.isCanceled)
				{
					takeUntilCanceled.cancellationTokenRegistration1.Dispose();
					takeUntilCanceled.completionSource.TrySetResult(result: false);
				}
			}

			public UniTask DisposeAsync()
			{
				cancellationTokenRegistration1.Dispose();
				cancellationTokenRegistration2.Dispose();
				if (enumerator != null)
				{
					return enumerator.DisposeAsync();
				}
				return default(UniTask);
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly CancellationToken cancellationToken;

		public TakeUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			this.source = source;
			this.cancellationToken = cancellationToken;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeUntilCanceled(source, this.cancellationToken, cancellationToken);
		}
	}
	internal sealed class TakeWhile<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _TakeWhile : AsyncEnumeratorBase<TSource, TSource>
		{
			private Func<TSource, bool> predicate;

			public _TakeWhile(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent && predicate(base.SourceCurrent))
				{
					base.Current = base.SourceCurrent;
					result = true;
					return true;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, bool> predicate;

		public TakeWhile(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeWhile(source, predicate, cancellationToken);
		}
	}
	internal sealed class TakeWhileInt<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _TakeWhileInt : AsyncEnumeratorBase<TSource, TSource>
		{
			private readonly Func<TSource, int, bool> predicate;

			private int index;

			public _TakeWhileInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
			{
				if (sourceHasCurrent && predicate(base.SourceCurrent, checked(index++)))
				{
					base.Current = base.SourceCurrent;
					result = true;
					return true;
				}
				result = false;
				return true;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, bool> predicate;

		public TakeWhileInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeWhileInt(source, predicate, cancellationToken);
		}
	}
	internal sealed class TakeWhileAwait<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _TakeWhileAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private Func<TSource, UniTask<bool>> predicate;

			public _TakeWhileAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				return predicate(sourceCurrent);
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				if (awaitResult)
				{
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = true;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<bool>> predicate;

		public TakeWhileAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeWhileAwait(source, predicate, cancellationToken);
		}
	}
	internal sealed class TakeWhileIntAwait<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _TakeWhileIntAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private readonly Func<TSource, int, UniTask<bool>> predicate;

			private int index;

			public _TakeWhileIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				return predicate(sourceCurrent, checked(index++));
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				if (awaitResult)
				{
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = true;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, UniTask<bool>> predicate;

		public TakeWhileIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeWhileIntAwait(source, predicate, cancellationToken);
		}
	}
	internal sealed class TakeWhileAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _TakeWhileAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private Func<TSource, CancellationToken, UniTask<bool>> predicate;

			public _TakeWhileAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				return predicate(sourceCurrent, cancellationToken);
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				if (awaitResult)
				{
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = true;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<bool>> predicate;

		public TakeWhileAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeWhileAwaitWithCancellation(source, predicate, cancellationToken);
		}
	}
	internal sealed class TakeWhileIntAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private class _TakeWhileIntAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
		{
			private readonly Func<TSource, int, CancellationToken, UniTask<bool>> predicate;

			private int index;

			public _TakeWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
				: base(source, cancellationToken)
			{
				this.predicate = predicate;
			}

			protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
			{
				return predicate(sourceCurrent, checked(index++), cancellationToken);
			}

			protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
			{
				if (awaitResult)
				{
					base.Current = base.SourceCurrent;
					terminateIteration = false;
					return true;
				}
				terminateIteration = true;
				return false;
			}
		}

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, CancellationToken, UniTask<bool>> predicate;

		public TakeWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _TakeWhileIntAwaitWithCancellation(source, predicate, cancellationToken);
		}
	}
	internal class Throw<TValue> : IUniTaskAsyncEnumerable<TValue>
	{
		private class _Throw : IUniTaskAsyncEnumerator<TValue>, IUniTaskAsyncDisposable
		{
			private readonly Exception exception;

			private CancellationToken cancellationToken;

			public TValue Current => default(TValue);

			public _Throw(Exception exception, CancellationToken cancellationToken)
			{
				this.exception = exception;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				return UniTask.FromException<bool>(exception);
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly Exception exception;

		public Throw(Exception exception)
		{
			this.exception = exception;
		}

		public IUniTaskAsyncEnumerator<TValue> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Throw(exception, cancellationToken);
		}
	}
	internal static class ToArray
	{
		internal static async UniTask<TSource[]> ToArrayAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			TSource[] result = null;
			IUniTaskAsyncEnumerator<TSource> e = null;
			try
			{
				e = source.GetAsyncEnumerator(cancellationToken);
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				if (i == 0)
				{
					result = Array.Empty<TSource>();
				}
				else
				{
					result = new TSource[i];
					Array.Copy(array, result, i);
				}
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal static class ToDictionary
	{
		internal static async UniTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			Dictionary<TKey, TSource> dict = new Dictionary<TKey, TSource>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					TSource current = e.Current;
					TKey key = keySelector(current);
					dict.Add(key, current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return dict;
		}

		internal static async UniTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			Dictionary<TKey, TElement> dict = new Dictionary<TKey, TElement>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					TSource current = e.Current;
					TKey key = keySelector(current);
					TElement value = elementSelector(current);
					dict.Add(key, value);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return dict;
		}

		internal static async UniTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			Dictionary<TKey, TSource> dict = new Dictionary<TKey, TSource>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					dict.Add(await keySelector(v), v);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return dict;
		}

		internal static async UniTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			Dictionary<TKey, TElement> dict = new Dictionary<TKey, TElement>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					dict.Add(await keySelector(v), await elementSelector(v));
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return dict;
		}

		internal static async UniTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			Dictionary<TKey, TSource> dict = new Dictionary<TKey, TSource>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					dict.Add(await keySelector(v, cancellationToken), v);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return dict;
		}

		internal static async UniTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			Dictionary<TKey, TElement> dict = new Dictionary<TKey, TElement>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					TSource v = e.Current;
					dict.Add(await keySelector(v, cancellationToken), await elementSelector(v, cancellationToken));
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return dict;
		}
	}
	internal static class ToHashSet
	{
		internal static async UniTask<HashSet<TSource>> ToHashSetAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
		{
			HashSet<TSource> set = new HashSet<TSource>(comparer);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					set.Add(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return set;
		}
	}
	internal static class ToList
	{
		internal static async UniTask<List<TSource>> ToListAsync<TSource>(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
		{
			List<TSource> list = new List<TSource>();
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			try
			{
				while (await e.MoveNextAsync())
				{
					list.Add(e.Current);
				}
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
			return list;
		}
	}
	internal static class ToLookup
	{
		private class Lookup<TKey, TElement> : ILookup<TKey, TElement>, IEnumerable<IGrouping<TKey, TElement>>, IEnumerable
		{
			private static readonly Lookup<TKey, TElement> empty = new Lookup<TKey, TElement>(new Dictionary<TKey, Grouping<TKey, TElement>>());

			private readonly Dictionary<TKey, Grouping<TKey, TElement>> dict;

			public IEnumerable<TElement> this[TKey key]
			{
				get
				{
					if (!dict.TryGetValue(key, out var value))
					{
						return Enumerable.Empty<TElement>();
					}
					return value;
				}
			}

			public int Count => dict.Count;

			private Lookup(Dictionary<TKey, Grouping<TKey, TElement>> dict)
			{
				this.dict = dict;
			}

			public static Lookup<TKey, TElement> CreateEmpty()
			{
				return empty;
			}

			public static Lookup<TKey, TElement> Create(ArraySegment<TElement> source, Func<TElement, TKey> keySelector, IEqualityComparer<TKey> comparer)
			{
				Dictionary<TKey, Grouping<TKey, TElement>> dictionary = new Dictionary<TKey, Grouping<TKey, TElement>>(comparer);
				TElement[] array = source.Array;
				int count = source.Count;
				for (int i = source.Offset; i < count; i++)
				{
					TKey key = keySelector(array[i]);
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = (dictionary[key] = new Grouping<TKey, TElement>(key));
					}
					value.Add(array[i]);
				}
				return new Lookup<TKey, TElement>(dictionary);
			}

			public static Lookup<TKey, TElement> Create<TSource>(ArraySegment<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
			{
				Dictionary<TKey, Grouping<TKey, TElement>> dictionary = new Dictionary<TKey, Grouping<TKey, TElement>>(comparer);
				TSource[] array = source.Array;
				int count = source.Count;
				for (int i = source.Offset; i < count; i++)
				{
					TKey key = keySelector(array[i]);
					TElement value = elementSelector(array[i]);
					if (!dictionary.TryGetValue(key, out var value2))
					{
						value2 = (dictionary[key] = new Grouping<TKey, TElement>(key));
					}
					value2.Add(value);
				}
				return new Lookup<TKey, TElement>(dictionary);
			}

			public static async UniTask<Lookup<TKey, TElement>> CreateAsync(ArraySegment<TElement> source, Func<TElement, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer)
			{
				Dictionary<TKey, Grouping<TKey, TElement>> dict = new Dictionary<TKey, Grouping<TKey, TElement>>(comparer);
				TElement[] arr = source.Array;
				int c = source.Count;
				for (int i = source.Offset; i < c; i++)
				{
					TKey key = await keySelector(arr[i]);
					if (!dict.TryGetValue(key, out var value))
					{
						value = (dict[key] = new Grouping<TKey, TElement>(key));
					}
					value.Add(arr[i]);
				}
				return new Lookup<TKey, TElement>(dict);
			}

			public static async UniTask<Lookup<TKey, TElement>> CreateAsync<TSource>(ArraySegment<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer)
			{
				Dictionary<TKey, Grouping<TKey, TElement>> dict = new Dictionary<TKey, Grouping<TKey, TElement>>(comparer);
				TSource[] arr = source.Array;
				int c = source.Count;
				for (int i = source.Offset; i < c; i++)
				{
					TKey key = await keySelector(arr[i]);
					TElement value = await elementSelector(arr[i]);
					if (!dict.TryGetValue(key, out var value2))
					{
						value2 = (dict[key] = new Grouping<TKey, TElement>(key));
					}
					value2.Add(value);
				}
				return new Lookup<TKey, TElement>(dict);
			}

			public static async UniTask<Lookup<TKey, TElement>> CreateAsync(ArraySegment<TElement> source, Func<TElement, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				Dictionary<TKey, Grouping<TKey, TElement>> dict = new Dictionary<TKey, Grouping<TKey, TElement>>(comparer);
				TElement[] arr = source.Array;
				int c = source.Count;
				for (int i = source.Offset; i < c; i++)
				{
					TKey key = await keySelector(arr[i], cancellationToken);
					if (!dict.TryGetValue(key, out var value))
					{
						value = (dict[key] = new Grouping<TKey, TElement>(key));
					}
					value.Add(arr[i]);
				}
				return new Lookup<TKey, TElement>(dict);
			}

			public static async UniTask<Lookup<TKey, TElement>> CreateAsync<TSource>(ArraySegment<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
			{
				Dictionary<TKey, Grouping<TKey, TElement>> dict = new Dictionary<TKey, Grouping<TKey, TElement>>(comparer);
				TSource[] arr = source.Array;
				int c = source.Count;
				for (int i = source.Offset; i < c; i++)
				{
					TKey key = await keySelector(arr[i], cancellationToken);
					TElement value = await elementSelector(arr[i], cancellationToken);
					if (!dict.TryGetValue(key, out var value2))
					{
						value2 = (dict[key] = new Grouping<TKey, TElement>(key));
					}
					value2.Add(value);
				}
				return new Lookup<TKey, TElement>(dict);
			}

			public bool Contains(TKey key)
			{
				return dict.ContainsKey(key);
			}

			public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
			{
				return dict.Values.GetEnumerator();
			}

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

		private class Grouping<TKey, TElement> : IGrouping<TKey, TElement>, IEnumerable<TElement>, IEnumerable
		{
			private readonly List<TElement> elements;

			public TKey Key { get; private set; }

			public Grouping(TKey key)
			{
				Key = key;
				elements = new List<TElement>();
			}

			public void Add(TElement value)
			{
				elements.Add(value);
			}

			public IEnumerator<TElement> GetEnumerator()
			{
				return elements.GetEnumerator();
			}

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

			public IUniTaskAsyncEnumerator<TElement> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
			{
				return this.ToUniTaskAsyncEnumerable().GetAsyncEnumerator(cancellationToken);
			}

			public override string ToString()
			{
				return "Key: " + Key?.ToString() + ", Count: " + elements.Count;
			}
		}

		internal static async UniTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			IUniTaskAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);
			ILookup<TKey, TSource> result;
			try
			{
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				result = ((i != 0) ? Lookup<TKey, TSource>.Create(new ArraySegment<TSource>(array, 0, i), keySelector, comparer) : Lookup<TKey, TSource>.CreateEmpty());
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			IUniTaskAsyncEnumerator<TSource> e = null;
			ILookup<TKey, TElement> result;
			try
			{
				e = source.GetAsyncEnumerator(cancellationToken);
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				result = ((i != 0) ? Lookup<TKey, TElement>.Create(new ArraySegment<TSource>(array, 0, i), keySelector, elementSelector, comparer) : Lookup<TKey, TElement>.CreateEmpty());
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			IUniTaskAsyncEnumerator<TSource> e = null;
			ILookup<TKey, TSource> result;
			try
			{
				e = source.GetAsyncEnumerator(cancellationToken);
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				result = ((i != 0) ? (await Lookup<TKey, TSource>.CreateAsync(new ArraySegment<TSource>(array, 0, i), keySelector, comparer)) : Lookup<TKey, TSource>.CreateEmpty());
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, Func<TSource, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			IUniTaskAsyncEnumerator<TSource> e = null;
			ILookup<TKey, TElement> result;
			try
			{
				e = source.GetAsyncEnumerator(cancellationToken);
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				result = ((i != 0) ? (await Lookup<TKey, TElement>.CreateAsync(new ArraySegment<TSource>(array, 0, i), keySelector, elementSelector, comparer)) : Lookup<TKey, TElement>.CreateEmpty());
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			IUniTaskAsyncEnumerator<TSource> e = null;
			ILookup<TKey, TSource> result;
			try
			{
				e = source.GetAsyncEnumerator(cancellationToken);
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				result = ((i != 0) ? (await Lookup<TKey, TSource>.CreateAsync(new ArraySegment<TSource>(array, 0, i), keySelector, comparer, cancellationToken)) : Lookup<TKey, TSource>.CreateEmpty());
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}

		internal static async UniTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, Func<TSource, CancellationToken, UniTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
		{
			ArrayPool<TSource> pool = ArrayPool<TSource>.Shared;
			TSource[] array = pool.Rent(16);
			IUniTaskAsyncEnumerator<TSource> e = null;
			ILookup<TKey, TElement> result;
			try
			{
				e = source.GetAsyncEnumerator(cancellationToken);
				int i = 0;
				while (await e.MoveNextAsync())
				{
					ArrayPoolUtil.EnsureCapacity(ref array, i, pool);
					array[i++] = e.Current;
				}
				result = ((i != 0) ? (await Lookup<TKey, TElement>.CreateAsync(new ArraySegment<TSource>(array, 0, i), keySelector, elementSelector, comparer, cancellationToken)) : Lookup<TKey, TElement>.CreateEmpty());
			}
			finally
			{
				pool.Return(array, !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<TSource>());
				if (e != null)
				{
					await e.DisposeAsync();
				}
			}
			return result;
		}
	}
	internal sealed class ToObservable<T> : IObservable<T>
	{
		internal sealed class CancellationTokenDisposable : IDisposable
		{
			private readonly CancellationTokenSource cts = new CancellationTokenSource();

			public CancellationToken Token => cts.Token;

			public void Dispose()
			{
				if (!cts.IsCancellationRequested)
				{
					cts.Cancel();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<T> source;

		public ToObservable(IUniTaskAsyncEnumerable<T> source)
		{
			this.source = source;
		}

		public IDisposable Subscribe(IObserver<T> observer)
		{
			CancellationTokenDisposable cancellationTokenDisposable = new CancellationTokenDisposable();
			RunAsync(source, observer, cancellationTokenDisposable.Token).Forget();
			return cancellationTokenDisposable;
		}

		private static async UniTaskVoid RunAsync(IUniTaskAsyncEnumerable<T> src, IObserver<T> observer, CancellationToken cancellationToken)
		{
			IUniTaskAsyncEnumerator<T> e = src.GetAsyncEnumerator(cancellationToken);
			try
			{
				do
				{
					bool flag;
					try
					{
						flag = await e.MoveNextAsync();
					}
					catch (Exception error)
					{
						if (!cancellationToken.IsCancellationRequested)
						{
							observer.OnError(error);
						}
						return;
					}
					if (flag)
					{
						observer.OnNext(e.Current);
						continue;
					}
					observer.OnCompleted();
					return;
				}
				while (!cancellationToken.IsCancellationRequested);
			}
			finally
			{
				IAsyncDisposable asyncDisposable = e as IAsyncDisposable;
				if (asyncDisposable != null)
				{
					await asyncDisposable.DisposeAsync();
				}
			}
		}
	}
	internal class ToUniTaskAsyncEnumerable<T> : IUniTaskAsyncEnumerable<T>
	{
		private class _ToUniTaskAsyncEnumerable : IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private readonly IEnumerable<T> source;

			private CancellationToken cancellationToken;

			private IEnumerator<T> enumerator;

			public T Current => enumerator.Current;

			public _ToUniTaskAsyncEnumerable(IEnumerable<T> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (enumerator == null)
				{
					enumerator = source.GetEnumerator();
				}
				if (enumerator.MoveNext())
				{
					return CompletedTasks.True;
				}
				return CompletedTasks.False;
			}

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

		private readonly IEnumerable<T> source;

		public ToUniTaskAsyncEnumerable(IEnumerable<T> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _ToUniTaskAsyncEnumerable(source, cancellationToken);
		}
	}
	internal class ToUniTaskAsyncEnumerableTask<T> : IUniTaskAsyncEnumerable<T>
	{
		private class _ToUniTaskAsyncEnumerableTask : IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private readonly Task<T> source;

			private CancellationToken cancellationToken;

			private T current;

			private bool called;

			public T Current => current;

			public _ToUniTaskAsyncEnumerableTask(Task<T> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
				called = false;
			}

			public async UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (called)
				{
					return false;
				}
				called = true;
				current = await source;
				return true;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly Task<T> source;

		public ToUniTaskAsyncEnumerableTask(Task<T> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _ToUniTaskAsyncEnumerableTask(source, cancellationToken);
		}
	}
	internal class ToUniTaskAsyncEnumerableUniTask<T> : IUniTaskAsyncEnumerable<T>
	{
		private class _ToUniTaskAsyncEnumerableUniTask : IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable
		{
			private readonly UniTask<T> source;

			private CancellationToken cancellationToken;

			private T current;

			private bool called;

			public T Current => current;

			public _ToUniTaskAsyncEnumerableUniTask(UniTask<T> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
				called = false;
			}

			public async UniTask<bool> MoveNextAsync()
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (called)
				{
					return false;
				}
				called = true;
				current = await source;
				return true;
			}

			public UniTask DisposeAsync()
			{
				return default(UniTask);
			}
		}

		private readonly UniTask<T> source;

		public ToUniTaskAsyncEnumerableUniTask(UniTask<T> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _ToUniTaskAsyncEnumerableUniTask(source, cancellationToken);
		}
	}
	internal class ToUniTaskAsyncEnumerableObservable<T> : IUniTaskAsyncEnumerable<T>
	{
		private class _ToUniTaskAsyncEnumerableObservable : MoveNextSource, IUniTaskAsyncEnumerator<T>, IUniTaskAsyncDisposable, IObserver<T>
		{
			private static readonly Action<object> OnCanceledDelegate = OnCanceled;

			private readonly IObservable<T> source;

			private CancellationToken cancellationToken;

			private bool useCachedCurrent;

			private T current;

			private bool subscribeCompleted;

			private readonly Queue<T> queuedResult;

			private Exception error;

			private IDisposable subscription;

			private CancellationTokenRegistration cancellationTokenRegistration;

			public T Current
			{
				get
				{
					if (useCachedCurrent)
					{
						return current;
					}
					lock (queuedResult)
					{
						if (queuedResult.Count != 0)
						{
							current = queuedResult.Dequeue();
							useCachedCurrent = true;
							return current;
						}
						return default(T);
					}
				}
			}

			public _ToUniTaskAsyncEnumerableObservable(IObservable<T> source, CancellationToken cancellationToken)
			{
				this.source = source;
				this.cancellationToken = cancellationToken;
				queuedResult = new Queue<T>();
				if (cancellationToken.CanBeCanceled)
				{
					cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(OnCanceledDelegate, this);
				}
			}

			public UniTask<bool> MoveNextAsync()
			{
				lock (queuedResult)
				{
					useCachedCurrent = false;
					if (cancellationToken.IsCancellationRequested)
					{
						return UniTask.FromCanceled<bool>(cancellationToken);
					}
					if (subscription == null)
					{
						subscription = source.Subscribe(this);
					}
					if (error != null)
					{
						return UniTask.FromException<bool>(error);
					}
					if (queuedResult.Count != 0)
					{
						return CompletedTasks.True;
					}
					if (subscribeCompleted)
					{
						return CompletedTasks.False;
					}
					completionSource.Reset();
					return new UniTask<bool>(this, completionSource.Version);
				}
			}

			public UniTask DisposeAsync()
			{
				subscription.Dispose();
				cancellationTokenRegistration.Dispose();
				completionSource.Reset();
				return default(UniTask);
			}

			public void OnCompleted()
			{
				lock (queuedResult)
				{
					subscribeCompleted = true;
					completionSource.TrySetResult(result: false);
				}
			}

			public void OnError(Exception error)
			{
				lock (queuedResult)
				{
					this.error = error;
					completionSource.TrySetException(error);
				}
			}

			public void OnNext(T value)
			{
				lock (queuedResult)
				{
					queuedResult.Enqueue(value);
					completionSource.TrySetResult(result: true);
				}
			}

			private static void OnCanceled(object state)
			{
				_ToUniTaskAsyncEnumerableObservable toUniTaskAsyncEnumerableObservable = (_ToUniTaskAsyncEnumerableObservable)state;
				lock (toUniTaskAsyncEnumerableObservable.queuedResult)
				{
					toUniTaskAsyncEnumerableObservable.completionSource.TrySetCanceled(toUniTaskAsyncEnumerableObservable.cancellationToken);
				}
			}
		}

		private readonly IObservable<T> source;

		public ToUniTaskAsyncEnumerableObservable(IObservable<T> source)
		{
			this.source = source;
		}

		public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _ToUniTaskAsyncEnumerableObservable(source, cancellationToken);
		}
	}
	internal sealed class Where<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Where : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, bool> predicate;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Action moveNextAction;

			public TSource Current { get; private set; }

			public _Where(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
			{
				this.source = source;
				this.predicate = predicate;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							goto case 0;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						case 1:
							break;
						}
						if (awaiter.GetResult())
						{
							Current = enumerator.Current;
							if (predicate(Current))
							{
								break;
							}
							state = 0;
							continue;
						}
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, bool> predicate;

		public Where(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Where(source, predicate, cancellationToken);
		}
	}
	internal sealed class WhereInt<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _Where : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, int, bool> predicate;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private Action moveNextAction;

			private int index;

			public TSource Current { get; private set; }

			public _Where(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate, CancellationToken cancellationToken)
			{
				this.source = source;
				this.predicate = predicate;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							goto case 0;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							break;
						case 1:
							break;
						}
						if (awaiter.GetResult())
						{
							Current = enumerator.Current;
							if (predicate(Current, checked(index++)))
							{
								break;
							}
							state = 0;
							continue;
						}
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, bool> predicate;

		public WhereInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Where(source, predicate, cancellationToken);
		}
	}
	internal sealed class WhereAwait<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _WhereAwait : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, UniTask<bool>> predicate;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<bool>.Awaiter awaiter2;

			private Action moveNextAction;

			public TSource Current { get; private set; }

			public _WhereAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
			{
				this.source = source;
				this.predicate = predicate;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							goto case 0;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case 1;
						case 1:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								awaiter2 = predicate(Current).GetAwaiter();
								if (!awaiter2.IsCompleted)
								{
									state = 2;
									awaiter2.UnsafeOnCompleted(moveNextAction);
									return;
								}
								break;
							}
							goto end_IL_0001;
						case 2:
							break;
						}
						if (awaiter2.GetResult())
						{
							break;
						}
						state = 0;
						continue;
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, UniTask<bool>> predicate;

		public WhereAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _WhereAwait(source, predicate, cancellationToken);
		}
	}
	internal sealed class WhereIntAwait<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _WhereAwait : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, int, UniTask<bool>> predicate;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<bool>.Awaiter awaiter2;

			private Action moveNextAction;

			private int index;

			public TSource Current { get; private set; }

			public _WhereAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate, CancellationToken cancellationToken)
			{
				this.source = source;
				this.predicate = predicate;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							goto case 0;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case 1;
						case 1:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								awaiter2 = predicate(Current, checked(index++)).GetAwaiter();
								if (!awaiter2.IsCompleted)
								{
									state = 2;
									awaiter2.UnsafeOnCompleted(moveNextAction);
									return;
								}
								break;
							}
							goto end_IL_0001;
						case 2:
							break;
						}
						if (awaiter2.GetResult())
						{
							break;
						}
						state = 0;
						continue;
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, UniTask<bool>> predicate;

		public WhereIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _WhereAwait(source, predicate, cancellationToken);
		}
	}
	internal sealed class WhereAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _WhereAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, CancellationToken, UniTask<bool>> predicate;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<bool>.Awaiter awaiter2;

			private Action moveNextAction;

			public TSource Current { get; private set; }

			public _WhereAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
			{
				this.source = source;
				this.predicate = predicate;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							goto case 0;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case 1;
						case 1:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								awaiter2 = predicate(Current, cancellationToken).GetAwaiter();
								if (!awaiter2.IsCompleted)
								{
									state = 2;
									awaiter2.UnsafeOnCompleted(moveNextAction);
									return;
								}
								break;
							}
							goto end_IL_0001;
						case 2:
							break;
						}
						if (awaiter2.GetResult())
						{
							break;
						}
						state = 0;
						continue;
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, CancellationToken, UniTask<bool>> predicate;

		public WhereAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _WhereAwaitWithCancellation(source, predicate, cancellationToken);
		}
	}
	internal sealed class WhereIntAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
	{
		private sealed class _WhereAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, IUniTaskAsyncDisposable
		{
			private readonly IUniTaskAsyncEnumerable<TSource> source;

			private readonly Func<TSource, int, CancellationToken, UniTask<bool>> predicate;

			private readonly CancellationToken cancellationToken;

			private int state = -1;

			private IUniTaskAsyncEnumerator<TSource> enumerator;

			private UniTask<bool>.Awaiter awaiter;

			private UniTask<bool>.Awaiter awaiter2;

			private Action moveNextAction;

			private int index;

			public TSource Current { get; private set; }

			public _WhereAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
			{
				this.source = source;
				this.predicate = predicate;
				this.cancellationToken = cancellationToken;
				moveNextAction = MoveNext;
			}

			public UniTask<bool> MoveNextAsync()
			{
				if (state == -2)
				{
					return default(UniTask<bool>);
				}
				completionSource.Reset();
				MoveNext();
				return new UniTask<bool>(this, completionSource.Version);
			}

			private void MoveNext()
			{
				while (true)
				{
					try
					{
						switch (state)
						{
						default:
							goto end_IL_0001;
						case -1:
							enumerator = source.GetAsyncEnumerator(cancellationToken);
							goto case 0;
						case 0:
							awaiter = enumerator.MoveNextAsync().GetAwaiter();
							if (!awaiter.IsCompleted)
							{
								state = 1;
								awaiter.UnsafeOnCompleted(moveNextAction);
								return;
							}
							goto case 1;
						case 1:
							if (awaiter.GetResult())
							{
								Current = enumerator.Current;
								awaiter2 = predicate(Current, checked(index++), cancellationToken).GetAwaiter();
								if (!awaiter2.IsCompleted)
								{
									state = 2;
									awaiter2.UnsafeOnCompleted(moveNextAction);
									return;
								}
								break;
							}
							goto end_IL_0001;
						case 2:
							break;
						}
						if (awaiter2.GetResult())
						{
							break;
						}
						state = 0;
						continue;
						end_IL_0001:;
					}
					catch (Exception error)
					{
						state = -2;
						completionSource.TrySetException(error);
						return;
					}
					state = -2;
					completionSource.TrySetResult(result: false);
					return;
				}
				state = 0;
				completionSource.TrySetResult(result: true);
			}

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

		private readonly IUniTaskAsyncEnumerable<TSource> source;

		private readonly Func<TSource, int, CancellationToken, UniTask<bool>> predicate;

		public WhereIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate)
		{
			this.source = source;
			this.predicate = predicate;
		}

		public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _WhereAwaitWithCancellation(source, predicate, cancellationToken);
		}
	}
	internal sealed class Zip<TFirst, TSecond, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _Zip : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> firstMoveNextCoreDelegate = FirstMoveNextCore;

			private static readonly Action<object> secondMoveNextCoreDelegate = SecondMoveNextCore;

			private readonly IUniTaskAsyncEnumerable<TFirst> first;

			private readonly IUniTaskAsyncEnumerable<TSecond> second;

			private readonly Func<TFirst, TSecond, TResult> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TFirst> firstEnumerator;

			private IUniTaskAsyncEnumerator<TSecond> secondEnumerator;

			private UniTask<bool>.Awaiter firstAwaiter;

			private UniTask<bool>.Awaiter secondAwaiter;

			public TResult Current { get; private set; }

			public _Zip(IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector, CancellationToken cancellationToken)
			{
				this.first = first;
				this.second = second;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				completionSource.Reset();
				if (firstEnumerator == null)
				{
					firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
					secondEnumerator = second.GetAsyncEnumerator(cancellationToken);
				}
				firstAwaiter = firstEnumerator.MoveNextAsync().GetAwaiter();
				if (firstAwaiter.IsCompleted)
				{
					FirstMoveNextCore(this);
				}
				else
				{
					firstAwaiter.SourceOnCompleted(firstMoveNextCoreDelegate, this);
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void FirstMoveNextCore(object state)
			{
				_Zip zip = (_Zip)state;
				if (!zip.TryGetResult(zip.firstAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						zip.secondAwaiter = zip.secondEnumerator.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error)
					{
						zip.completionSource.TrySetException(error);
						return;
					}
					if (zip.secondAwaiter.IsCompleted)
					{
						SecondMoveNextCore(zip);
					}
					else
					{
						zip.secondAwaiter.SourceOnCompleted(secondMoveNextCoreDelegate, zip);
					}
				}
				else
				{
					zip.completionSource.TrySetResult(result: false);
				}
			}

			private static void SecondMoveNextCore(object state)
			{
				_Zip zip = (_Zip)state;
				if (!zip.TryGetResult(zip.secondAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						zip.Current = zip.resultSelector(zip.firstEnumerator.Current, zip.secondEnumerator.Current);
					}
					catch (Exception error)
					{
						zip.completionSource.TrySetException(error);
					}
					if (zip.cancellationToken.IsCancellationRequested)
					{
						zip.completionSource.TrySetCanceled(zip.cancellationToken);
					}
					else
					{
						zip.completionSource.TrySetResult(result: true);
					}
				}
				else
				{
					zip.completionSource.TrySetResult(result: false);
				}
			}

			public async UniTask DisposeAsync()
			{
				if (firstEnumerator != null)
				{
					await firstEnumerator.DisposeAsync();
				}
				if (secondEnumerator != null)
				{
					await secondEnumerator.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TFirst> first;

		private readonly IUniTaskAsyncEnumerable<TSecond> second;

		private readonly Func<TFirst, TSecond, TResult> resultSelector;

		public Zip(IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			this.first = first;
			this.second = second;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _Zip(first, second, resultSelector, cancellationToken);
		}
	}
	internal sealed class ZipAwait<TFirst, TSecond, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _ZipAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> firstMoveNextCoreDelegate = FirstMoveNextCore;

			private static readonly Action<object> secondMoveNextCoreDelegate = SecondMoveNextCore;

			private static readonly Action<object> resultAwaitCoreDelegate = ResultAwaitCore;

			private readonly IUniTaskAsyncEnumerable<TFirst> first;

			private readonly IUniTaskAsyncEnumerable<TSecond> second;

			private readonly Func<TFirst, TSecond, UniTask<TResult>> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TFirst> firstEnumerator;

			private IUniTaskAsyncEnumerator<TSecond> secondEnumerator;

			private UniTask<bool>.Awaiter firstAwaiter;

			private UniTask<bool>.Awaiter secondAwaiter;

			private UniTask<TResult>.Awaiter resultAwaiter;

			public TResult Current { get; private set; }

			public _ZipAwait(IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, UniTask<TResult>> resultSelector, CancellationToken cancellationToken)
			{
				this.first = first;
				this.second = second;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				completionSource.Reset();
				if (firstEnumerator == null)
				{
					firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
					secondEnumerator = second.GetAsyncEnumerator(cancellationToken);
				}
				firstAwaiter = firstEnumerator.MoveNextAsync().GetAwaiter();
				if (firstAwaiter.IsCompleted)
				{
					FirstMoveNextCore(this);
				}
				else
				{
					firstAwaiter.SourceOnCompleted(firstMoveNextCoreDelegate, this);
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void FirstMoveNextCore(object state)
			{
				_ZipAwait zipAwait = (_ZipAwait)state;
				if (!zipAwait.TryGetResult(zipAwait.firstAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						zipAwait.secondAwaiter = zipAwait.secondEnumerator.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error)
					{
						zipAwait.completionSource.TrySetException(error);
						return;
					}
					if (zipAwait.secondAwaiter.IsCompleted)
					{
						SecondMoveNextCore(zipAwait);
					}
					else
					{
						zipAwait.secondAwaiter.SourceOnCompleted(secondMoveNextCoreDelegate, zipAwait);
					}
				}
				else
				{
					zipAwait.completionSource.TrySetResult(result: false);
				}
			}

			private static void SecondMoveNextCore(object state)
			{
				_ZipAwait zipAwait = (_ZipAwait)state;
				if (!zipAwait.TryGetResult(zipAwait.secondAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						zipAwait.resultAwaiter = zipAwait.resultSelector(zipAwait.firstEnumerator.Current, zipAwait.secondEnumerator.Current).GetAwaiter();
						if (zipAwait.resultAwaiter.IsCompleted)
						{
							ResultAwaitCore(zipAwait);
						}
						else
						{
							zipAwait.resultAwaiter.SourceOnCompleted(resultAwaitCoreDelegate, zipAwait);
						}
						return;
					}
					catch (Exception error)
					{
						zipAwait.completionSource.TrySetException(error);
						return;
					}
				}
				zipAwait.completionSource.TrySetResult(result: false);
			}

			private static void ResultAwaitCore(object state)
			{
				_ZipAwait zipAwait = (_ZipAwait)state;
				if (zipAwait.TryGetResult(zipAwait.resultAwaiter, out var result))
				{
					zipAwait.Current = result;
					if (zipAwait.cancellationToken.IsCancellationRequested)
					{
						zipAwait.completionSource.TrySetCanceled(zipAwait.cancellationToken);
					}
					else
					{
						zipAwait.completionSource.TrySetResult(result: true);
					}
				}
			}

			public async UniTask DisposeAsync()
			{
				if (firstEnumerator != null)
				{
					await firstEnumerator.DisposeAsync();
				}
				if (secondEnumerator != null)
				{
					await secondEnumerator.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TFirst> first;

		private readonly IUniTaskAsyncEnumerable<TSecond> second;

		private readonly Func<TFirst, TSecond, UniTask<TResult>> resultSelector;

		public ZipAwait(IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, UniTask<TResult>> resultSelector)
		{
			this.first = first;
			this.second = second;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _ZipAwait(first, second, resultSelector, cancellationToken);
		}
	}
	internal sealed class ZipAwaitWithCancellation<TFirst, TSecond, TResult> : IUniTaskAsyncEnumerable<TResult>
	{
		private sealed class _ZipAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>, IUniTaskAsyncDisposable
		{
			private static readonly Action<object> firstMoveNextCoreDelegate = FirstMoveNextCore;

			private static readonly Action<object> secondMoveNextCoreDelegate = SecondMoveNextCore;

			private static readonly Action<object> resultAwaitCoreDelegate = ResultAwaitCore;

			private readonly IUniTaskAsyncEnumerable<TFirst> first;

			private readonly IUniTaskAsyncEnumerable<TSecond> second;

			private readonly Func<TFirst, TSecond, CancellationToken, UniTask<TResult>> resultSelector;

			private CancellationToken cancellationToken;

			private IUniTaskAsyncEnumerator<TFirst> firstEnumerator;

			private IUniTaskAsyncEnumerator<TSecond> secondEnumerator;

			private UniTask<bool>.Awaiter firstAwaiter;

			private UniTask<bool>.Awaiter secondAwaiter;

			private UniTask<TResult>.Awaiter resultAwaiter;

			public TResult Current { get; private set; }

			public _ZipAwaitWithCancellation(IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, CancellationToken, UniTask<TResult>> resultSelector, CancellationToken cancellationToken)
			{
				this.first = first;
				this.second = second;
				this.resultSelector = resultSelector;
				this.cancellationToken = cancellationToken;
			}

			public UniTask<bool> MoveNextAsync()
			{
				completionSource.Reset();
				if (firstEnumerator == null)
				{
					firstEnumerator = first.GetAsyncEnumerator(cancellationToken);
					secondEnumerator = second.GetAsyncEnumerator(cancellationToken);
				}
				firstAwaiter = firstEnumerator.MoveNextAsync().GetAwaiter();
				if (firstAwaiter.IsCompleted)
				{
					FirstMoveNextCore(this);
				}
				else
				{
					firstAwaiter.SourceOnCompleted(firstMoveNextCoreDelegate, this);
				}
				return new UniTask<bool>(this, completionSource.Version);
			}

			private static void FirstMoveNextCore(object state)
			{
				_ZipAwaitWithCancellation zipAwaitWithCancellation = (_ZipAwaitWithCancellation)state;
				if (!zipAwaitWithCancellation.TryGetResult(zipAwaitWithCancellation.firstAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						zipAwaitWithCancellation.secondAwaiter = zipAwaitWithCancellation.secondEnumerator.MoveNextAsync().GetAwaiter();
					}
					catch (Exception error)
					{
						zipAwaitWithCancellation.completionSource.TrySetException(error);
						return;
					}
					if (zipAwaitWithCancellation.secondAwaiter.IsCompleted)
					{
						SecondMoveNextCore(zipAwaitWithCancellation);
					}
					else
					{
						zipAwaitWithCancellation.secondAwaiter.SourceOnCompleted(secondMoveNextCoreDelegate, zipAwaitWithCancellation);
					}
				}
				else
				{
					zipAwaitWithCancellation.completionSource.TrySetResult(result: false);
				}
			}

			private static void SecondMoveNextCore(object state)
			{
				_ZipAwaitWithCancellation zipAwaitWithCancellation = (_ZipAwaitWithCancellation)state;
				if (!zipAwaitWithCancellation.TryGetResult(zipAwaitWithCancellation.secondAwaiter, out var result))
				{
					return;
				}
				if (result)
				{
					try
					{
						zipAwaitWithCancellation.resultAwaiter = zipAwaitWithCancellation.resultSelector(zipAwaitWithCancellation.firstEnumerator.Current, zipAwaitWithCancellation.secondEnumerator.Current, zipAwaitWithCancellation.cancellationToken).GetAwaiter();
						if (zipAwaitWithCancellation.resultAwaiter.IsCompleted)
						{
							ResultAwaitCore(zipAwaitWithCancellation);
						}
						else
						{
							zipAwaitWithCancellation.resultAwaiter.SourceOnCompleted(resultAwaitCoreDelegate, zipAwaitWithCancellation);
						}
						return;
					}
					catch (Exception error)
					{
						zipAwaitWithCancellation.completionSource.TrySetException(error);
						return;
					}
				}
				zipAwaitWithCancellation.completionSource.TrySetResult(result: false);
			}

			private static void ResultAwaitCore(object state)
			{
				_ZipAwaitWithCancellation zipAwaitWithCancellation = (_ZipAwaitWithCancellation)state;
				if (zipAwaitWithCancellation.TryGetResult(zipAwaitWithCancellation.resultAwaiter, out var result))
				{
					zipAwaitWithCancellation.Current = result;
					if (zipAwaitWithCancellation.cancellationToken.IsCancellationRequested)
					{
						zipAwaitWithCancellation.completionSource.TrySetCanceled(zipAwaitWithCancellation.cancellationToken);
					}
					else
					{
						zipAwaitWithCancellation.completionSource.TrySetResult(result: true);
					}
				}
			}

			public async UniTask DisposeAsync()
			{
				if (firstEnumerator != null)
				{
					await firstEnumerator.DisposeAsync();
				}
				if (secondEnumerator != null)
				{
					await secondEnumerator.DisposeAsync();
				}
			}
		}

		private readonly IUniTaskAsyncEnumerable<TFirst> first;

		private readonly IUniTaskAsyncEnumerable<TSecond> second;

		private readonly Func<TFirst, TSecond, CancellationToken, UniTask<TResult>> resultSelector;

		public ZipAwaitWithCancellation(IUniTaskAsyncEnumerable<TFirst> first, IUniTaskAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, CancellationToken, UniTask<TResult>> resultSelector)
		{
			this.first = first;
			this.second = second;
			this.resultSelector = resultSelector;
		}

		public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			return new _ZipAwaitWithCancellation(first, second, resultSelector, cancellationToken);
		}
	}
}
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 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(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 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]);
			}
			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 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);
			}
			ref TAwaiter reference = ref awaiter;
			TAwaiter val = default(TAwaiter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			reference.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);
			}
			ref TAwaiter reference = ref awaiter;
			TAwaiter val = default(TAwaiter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			reference.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);
			}
			ref TAwaiter reference = ref awaiter;
			TAwaiter val = default(TAwaiter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			reference.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);
			}
			ref TAwaiter reference = ref awaiter;
			TAwaiter val = default(TAwaiter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			reference.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);
			}
			ref TAwaiter reference = ref awaiter;
			TAwaiter val = default(TAwaiter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			reference.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);
			}
			ref TAwaiter reference = ref awaiter;
			TAwaiter val = default(TAwaiter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			reference.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>();
			}
			runnerFieldRef = result;
			result.stateMachine = stateMachine;
		}

		static AsyncUniTaskVoid()
		{
			TaskPool.RegisterSizeGetter(typeof(AsyncUniTaskVoid<TStateMachine>), () => pool.Size);
		}

		public void Return()
		{
			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>();
			}
			runnerPromiseFieldRef = result;
			result.stateMachine = stateMachine;
		}

		static AsyncUniTask()
		{
			TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine>), () => pool.Size);
		}

		private void Return()
		{
			core.Reset();
			stateMachine = default(TStateMachine);
			pool.TryPush(this);
		}

		private bool TryReturn()
		{
			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>();
			}
			runnerPromiseFieldRef = result;
			result.stateMachine = stateMachine;
		}

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

		private void Return()
		{
			core.Reset();
			stateMachine = default(TStateMachine);
			pool.TryPush(this);
		}

		private bool TryReturn()
		{
			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);
		}
	}
}