using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using <StartupCode$FSharp-Control-AsyncSeq>;
using FSharp.Control;
using Microsoft.FSharp.Collections;
using Microsoft.FSharp.Control;
using Microsoft.FSharp.Core;
using Microsoft.FSharp.Core.CompilerServices;

[assembly: FSharpInterfaceDataVersion(2, 0, 0)]
[assembly: AssemblyTitle("FSharp.Control.AsyncSeq")]
[assembly: AssemblyProduct("src/FSharp.Control.AsyncSeq")]
[assembly: AssemblyDescription("Asynchronous sequences for F#")]
[assembly: AssemblyVersion("2.0.21")]
[assembly: AssemblyFileVersion("2.0.21")]
[assembly: InternalsVisibleTo("FSharp.Control.AsyncSeq.Tests")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("2.0.21.0")]
namespace FSharp.Control
{
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public interface IAsyncEnumerator<T> : IDisposable
	{
		virtual FSharpAsync<FSharpOption<T>> MoveNext();
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public interface IAsyncEnumerable<T>
	{
		virtual IAsyncEnumerator<T> GetEnumerator();
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public sealed class AsyncSeqSrc<T> : IEquatable<AsyncSeqSrc<T>>, IStructuralEquatable
	{
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal FSharpRef<AsyncSeqSrcNode<T>> tail@;

		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal FSharpRef<AsyncSeqSrcNode<T>> tail => tail@;

		internal AsyncSeqSrc(FSharpRef<AsyncSeqSrcNode<T>> tail)
		{
			tail@ = tail;
		}

		[CompilerGenerated]
		public override string ToString()
		{
			return ((FSharpFunc<AsyncSeqSrc<AsyncSeqSrc<T>>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<AsyncSeqSrc<T>, string>>((PrintfFormat<FSharpFunc<AsyncSeqSrc<T>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<AsyncSeqSrc<FSharpFunc<AsyncSeqSrc<T>, string>>, string>, Unit, string, string, AsyncSeqSrc<FSharpFunc<AsyncSeqSrc<T>, string>>>("%+A"))).Invoke((AsyncSeqSrc<AsyncSeqSrc<T>>)(object)this);
		}

		[CompilerGenerated]
		public sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				int num = 0;
				return -1640531527 + (((FSharpRef<AsyncSeqSrcNode<AsyncSeqSrcNode<T>>>)(object)tail@).GetHashCode(comp) + ((num << 6) + (num >> 2)));
			}
			return 0;
		}

		[CompilerGenerated]
		public sealed override int GetHashCode()
		{
			return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
		}

		[CompilerGenerated]
		public sealed bool Equals(object obj, IEqualityComparer comp)
		{
			if (this != null)
			{
				if (obj is AsyncSeqSrc<T> asyncSeqSrc)
				{
					FSharpRef<AsyncSeqSrcNode<T>> val = tail@;
					FSharpRef<AsyncSeqSrcNode<T>> val2 = asyncSeqSrc.tail@;
					return ((FSharpRef<AsyncSeqSrcNode<AsyncSeqSrcNode<T>>>)(object)val).Equals((object)val2, comp);
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed bool Equals(AsyncSeqSrc<T> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					return HashCompare.GenericEqualityERIntrinsic<FSharpRef<AsyncSeqSrcNode<T>>>(tail@, obj.tail@);
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is AsyncSeqSrc<T> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	internal class AsyncSeqSrcNode<a>
	{
		internal TaskCompletionSource<FSharpOption<Tuple<a, AsyncSeqSrcNode<a>>>> tcs@;

		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal TaskCompletionSource<FSharpOption<Tuple<a, AsyncSeqSrcNode<a>>>> tcs => tcs@;

		public AsyncSeqSrcNode(TaskCompletionSource<FSharpOption<Tuple<a, AsyncSeqSrcNode<a>>>> tcs)
		{
			tcs@ = tcs;
		}
	}
	[Serializable]
	[AbstractClass]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	internal abstract class AsyncSeqOp<T>
	{
		public abstract virtual IAsyncEnumerable<U> ChooseAsync<U>(FSharpFunc<T, FSharpAsync<FSharpOption<U>>> P_0);

		[CompilationArgumentCounts(new int[] { 1, 1 })]
		public abstract virtual FSharpAsync<S> FoldAsync<S>(FSharpFunc<S, FSharpFunc<T, FSharpAsync<S>>> P_0, S P_1);

		public AsyncSeqOp()
		{
		}

		public virtual IAsyncEnumerable<a> MapAsync<a>(FSharpFunc<T, FSharpAsync<a>> f)
		{
			FSharpFunc<a, FSharpOption<a>> arg = new $AsyncSeq.MapAsync@279<a>();
			FSharpFunc<FSharpAsync<a>, FSharpAsync<FSharpOption<a>>> g = new $AsyncSeq.MapAsync@279-1<a>(arg);
			return ChooseAsync(new $AsyncSeq.MapAsync@279-2<T, a>(f, g));
		}

		public virtual FSharpAsync<Unit> IterAsync(FSharpFunc<T, FSharpAsync<Unit>> f)
		{
			return FoldAsync<Unit>((FSharpFunc<Unit, FSharpFunc<T, FSharpAsync<Unit>>>)(object)new $AsyncSeq.IterAsync@281<T>(f), null);
		}
	}
}
namespace <StartupCode$FSharp-Control-AsyncSeq>.$.NETFramework,Version=v4.5
{
	internal static class AssemblyAttributes
	{
	}
}
namespace FSharp.Control
{
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public static class Seq
	{
		public static IEnumerable<T> ofAsyncSeq<T>(IAsyncEnumerable<T> source)
		{
			return AsyncSeq.toBlockingSeq(source);
		}
	}
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public static class AsyncSeqSrc
	{
		public static AsyncSeqSrc<T> create<T>()
		{
			return new AsyncSeqSrc<T>(new FSharpRef<AsyncSeqSrcNode<T>>(new AsyncSeqSrcNode<T>(new TaskCompletionSource<FSharpOption<Tuple<T, AsyncSeqSrcNode<T>>>>())));
		}

		[CompilationArgumentCounts(new int[] { 1, 1 })]
		public static void put<T>(T item, AsyncSeqSrc<T> src)
		{
			AsyncSeq.AsyncSeqSrcImpl.put(item, src);
		}

		public static void close<T>(AsyncSeqSrc<T> src)
		{
			src.tail@.contents.tcs@.SetResult(null);
		}

		public static IAsyncEnumerable<T> toAsyncSeq<T>(AsyncSeqSrc<T> src)
		{
			return AsyncSeq.AsyncSeqSrcImpl.toAsyncSeqImpl(src.tail@.contents);
		}

		[CompilationArgumentCounts(new int[] { 1, 1 })]
		public static void error<T>(Exception exn, AsyncSeqSrc<T> src)
		{
			src.tail@.contents.tcs@.SetException(exn);
		}
	}
	[AutoOpen]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public static class AsyncSeqExtensions
	{
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		public static AsyncSeq.AsyncSeqBuilder asyncSeq => $AsyncSeq.asyncSeq@1704-1;

		[CompilationArgumentCounts(new int[] { 1, 2 })]
		public static FSharpAsync<Unit> AsyncBuilder.For<T>(FSharpAsyncBuilder x, IAsyncEnumerable<T> seq, FSharpFunc<T, FSharpAsync<Unit>> action)
		{
			return AsyncSeq.iterAsync(action, seq);
		}
	}
	[RequireQualifiedAccess]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public static class AsyncSeq
	{
		[Serializable]
		internal sealed class empty@357-3<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal empty@357-3()
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<T>>((FSharpOption<T>)null);
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class empty@356-2<T> : IAsyncEnumerator<T>
		{
			private FSharpAsync<FSharpOption<T>> FSharp-Control-IAsyncEnumerator`1-MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new empty@357-3<T>());
			}

			FSharpAsync<FSharpOption<T>> IAsyncEnumerator<T>.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerator`1-MoveNext
				return this.FSharp-Control-IAsyncEnumerator`1-MoveNext();
			}

			private void System-IDisposable-Dispose()
			{
			}

			void IDisposable.Dispose()
			{
				//ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose
				this.System-IDisposable-Dispose();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class empty@354-1<T> : IAsyncEnumerable<T>
		{
			private IAsyncEnumerator<T> FSharp-Control-IAsyncEnumerable`1-GetEnumerator()
			{
				return new empty@356-2<T>();
			}

			IAsyncEnumerator<T> IAsyncEnumerable<T>.GetEnumerator()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerable`1-GetEnumerator
				return this.FSharp-Control-IAsyncEnumerable`1-GetEnumerator();
			}
		}

		[Serializable]
		internal sealed class singleton@365-2<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			public T v;

			public FSharpRef<int> state;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal singleton@365-2(T v, FSharpRef<int> state)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.v = v;
				this.state = state;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				bool flag = state.contents == 0;
				state.contents += 1;
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<T>>((!flag) ? null : FSharpOption<T>.Some(v));
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class singleton@364-1<T> : IAsyncEnumerator<T>
		{
			public T v;

			public FSharpRef<int> state;

			public singleton@364-1(T v, FSharpRef<int> state)
			{
				this.v = v;
				this.state = state;
				base..ctor();
			}

			private FSharpAsync<FSharpOption<T>> FSharp-Control-IAsyncEnumerator`1-MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new singleton@365-2<T>(v, state));
			}

			FSharpAsync<FSharpOption<T>> IAsyncEnumerator<T>.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerator`1-MoveNext
				return this.FSharp-Control-IAsyncEnumerator`1-MoveNext();
			}

			private void System-IDisposable-Dispose()
			{
			}

			void IDisposable.Dispose()
			{
				//ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose
				this.System-IDisposable-Dispose();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class singleton@361<T> : IAsyncEnumerable<T>
		{
			public T v;

			public singleton@361(T v)
			{
				this.v = v;
				base..ctor();
			}

			private IAsyncEnumerator<T> FSharp-Control-IAsyncEnumerable`1-GetEnumerator()
			{
				FSharpRef<int> state = new FSharpRef<int>(0);
				return new singleton@364-1<T>(v, state);
			}

			IAsyncEnumerator<T> IAsyncEnumerable<T>.GetEnumerator()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerable`1-GetEnumerator
				return this.FSharp-Control-IAsyncEnumerable`1-GetEnumerator();
			}
		}

		[Serializable]
		internal sealed class bindAsync@382-3<T, U> : FSharpFunc<T, FSharpAsync<AsyncGenerator.Step<U>>>
		{
			public FSharpFunc<T, IAsyncEnumerable<U>> f;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal bindAsync@382-3(FSharpFunc<T, IAsyncEnumerable<U>> f)
			{
				((FSharpFunc<T, FSharpAsync<AsyncGenerator.Step<FSharpAsync<AsyncGenerator.Step<U>>>>>)(object)this)..ctor();
				this.f = f;
			}

			public override FSharpAsync<AsyncGenerator.Step<U>> Invoke(T _arg1)
			{
				AsyncGenerator.AsyncGenerator<U> item = AsyncGenerator.generatorFromEnumerator(((FSharpFunc<T, IAsyncEnumerable<IAsyncEnumerable<U>>>)(object)f).Invoke(_arg1).GetEnumerator());
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<AsyncGenerator.Step<U>>(AsyncGenerator.Step<U>.NewGoto(item));
			}
		}

		[Serializable]
		internal sealed class bindAsync@381-2<U, T> : FSharpFunc<Unit, FSharpAsync<AsyncGenerator.Step<U>>>
		{
			public FSharpFunc<T, IAsyncEnumerable<U>> f;

			public FSharpAsync<T> inp;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal bindAsync@381-2(FSharpFunc<T, IAsyncEnumerable<U>> f, FSharpAsync<T> inp)
			{
				((FSharpFunc<Unit, FSharpAsync<AsyncGenerator.Step<Unit>>>)(object)this)..ctor();
				this.f = f;
				this.inp = inp;
			}

			public override FSharpAsync<AsyncGenerator.Step<U>> Invoke(Unit unitVar)
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Bind<T, AsyncGenerator.Step<U>>(inp, (FSharpFunc<T, FSharpAsync<AsyncGenerator.Step<U>>>)new bindAsync@382-3<T, U>(f));
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class bindAsync@379-1<U, T> : AsyncGenerator.AsyncGenerator<U>
		{
			public FSharpFunc<T, IAsyncEnumerable<U>> f;

			public FSharpAsync<T> inp;

			public bindAsync@379-1(FSharpFunc<T, IAsyncEnumerable<U>> f, FSharpAsync<T> inp)
			{
				this.f = f;
				this.inp = inp;
				base..ctor();
			}

			private FSharpAsync<AsyncGenerator.Step<U>> FSharp-Control-AsyncGenerator-AsyncGenerator`1-Apply()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<AsyncGenerator.Step<U>>((FSharpFunc<Unit, FSharpAsync<AsyncGenerator.Step<U>>>)new bindAsync@381-2<U, T>(f, inp));
			}

			FSharpAsync<AsyncGenerator.Step<U>> AsyncGenerator.AsyncGenerator<U>.Apply()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-AsyncGenerator-AsyncGenerator`1-Apply
				return this.FSharp-Control-AsyncGenerator-AsyncGenerator`1-Apply();
			}

			private FSharpOption<FSharpFunc<Unit, Unit>> FSharp-Control-AsyncGenerator-AsyncGenerator`1-get_Disposer()
			{
				return null;
			}

			FSharpOption<FSharpFunc<Unit, Unit>> AsyncGenerator.AsyncGenerator<U>.get_Disposer()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-AsyncGenerator-AsyncGenerator`1-get_Disposer
				return this.FSharp-Control-AsyncGenerator-AsyncGenerator`1-get_Disposer();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class bindAsync@377<U, T> : IAsyncEnumerable<U>
		{
			public FSharpFunc<T, IAsyncEnumerable<U>> f;

			public FSharpAsync<T> inp;

			public bindAsync@377(FSharpFunc<T, IAsyncEnumerable<U>> f, FSharpAsync<T> inp)
			{
				this.f = f;
				this.inp = inp;
				base..ctor();
			}

			private IAsyncEnumerator<U> FSharp-Control-IAsyncEnumerable`1-GetEnumerator()
			{
				return AsyncGenerator.enumeratorFromGenerator(new bindAsync@379-1<U, T>(f, inp));
			}

			IAsyncEnumerator<U> IAsyncEnumerable<U>.GetEnumerator()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerable`1-GetEnumerator
				return this.FSharp-Control-IAsyncEnumerable`1-GetEnumerator();
			}
		}

		[Serializable]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		public class AsyncSeqBuilder
		{
			public IAsyncEnumerable<T> Yield<T>(T value)
			{
				return singleton(value);
			}

			public IAsyncEnumerable<T> Return<unit, T>(unit _arg1)
			{
				return empty<T>();
			}

			public IAsyncEnumerable<T> YieldFrom<T>(IAsyncEnumerable<T> source)
			{
				return source;
			}

			public IAsyncEnumerable<T> Zero<T>()
			{
				return empty<T>();
			}

			public IAsyncEnumerable<U> Bind<T, U>(FSharpAsync<T> source, FSharpFunc<T, IAsyncEnumerable<U>> body)
			{
				return bindAsync<T, U>(body, source);
			}

			public IAsyncEnumerable<T> Combine<T>(IAsyncEnumerable<T> seq1, IAsyncEnumerable<T> seq2)
			{
				return AsyncGenerator.append(seq1, seq2);
			}

			public IAsyncEnumerable<T> While<T>(FSharpFunc<Unit, bool> guard, IAsyncEnumerable<T> body)
			{
				Lazy<IAsyncEnumerable<T>> fix = default(Lazy<IAsyncEnumerable<T>>);
				FSharpFunc<Unit, IAsyncEnumerable<T>> val = new While@412<T>(guard, body, fix);
				fix = LazyExtensions.Create<IAsyncEnumerable<T>>(val);
				((While@412<T>)val).fix = fix;
				return fix.Value;
			}

			public IAsyncEnumerable<T> Delay<T>(FSharpFunc<Unit, IAsyncEnumerable<T>> f)
			{
				return AsyncGenerator.delay<T>(f);
			}

			public IAsyncEnumerable<T> TryFinally<T>(IAsyncEnumerable<T> body, FSharpFunc<Unit, Unit> compensation)
			{
				return tryFinally(body, compensation);
			}

			public IAsyncEnumerable<T> TryWith<T>(IAsyncEnumerable<T> body, FSharpFunc<Exception, IAsyncEnumerable<T>> handler)
			{
				return tryWith(body, handler);
			}

			public IAsyncEnumerable<U> Using<T, U>(T resource, FSharpFunc<T, IAsyncEnumerable<U>> binder) where T : IDisposable
			{
				return tryFinally(binder.Invoke(resource), new Using@703<T>(resource));
			}

			public IAsyncEnumerable<TResult> For<T, TResult>(IEnumerable<T> source, FSharpFunc<T, IAsyncEnumerable<TResult>> action)
			{
				return collectSeq<T, TResult>(action, source);
			}

			public IAsyncEnumerable<TResult> For<T, TResult>(IAsyncEnumerable<T> source, FSharpFunc<T, IAsyncEnumerable<TResult>> action)
			{
				return collect<T, TResult>(action, source);
			}
		}

		[Serializable]
		internal sealed class While@412-1<T> : FSharpFunc<Unit, IAsyncEnumerable<T>>
		{
			public FSharpFunc<Unit, bool> guard;

			public IAsyncEnumerable<T> body;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Lazy<IAsyncEnumerable<T>> fix;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal While@412-1(FSharpFunc<Unit, bool> guard, IAsyncEnumerable<T> body, Lazy<IAsyncEnumerable<T>> fix)
			{
				((FSharpFunc<Unit, IAsyncEnumerable<Unit>>)(object)this)..ctor();
				this.guard = guard;
				this.body = body;
				this.fix = fix;
			}

			public override IAsyncEnumerable<T> Invoke(Unit unitVar0)
			{
				if (guard.Invoke((Unit)null))
				{
					return AsyncGenerator.append(body, fix.Value);
				}
				return empty<T>();
			}
		}

		[Serializable]
		internal sealed class While@412<T> : FSharpFunc<Unit, IAsyncEnumerable<T>>
		{
			public FSharpFunc<Unit, bool> guard;

			public IAsyncEnumerable<T> body;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Lazy<IAsyncEnumerable<T>> fix;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal While@412(FSharpFunc<Unit, bool> guard, IAsyncEnumerable<T> body, Lazy<IAsyncEnumerable<T>> fix)
			{
				((FSharpFunc<Unit, IAsyncEnumerable<Unit>>)(object)this)..ctor();
				this.guard = guard;
				this.body = body;
				this.fix = fix;
			}

			public override IAsyncEnumerable<T> Invoke(Unit unitVar)
			{
				return AsyncGenerator.delay(new While@412-1<T>(guard, body, fix));
			}
		}

		[Serializable]
		internal sealed class emitEnumerator@424-2<T> : FSharpFunc<Unit, bool>
		{
			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@424-2(FSharpRef<FSharpOption<T>> b)
			{
				this.b = b;
			}

			public override bool Invoke(Unit unitVar)
			{
				return ((FSharpRef<FSharpOption<FSharpOption<T>>>)(object)b).contents != null;
			}
		}

		[Serializable]
		internal sealed class emitEnumerator@427-5<T> : FSharpFunc<FSharpOption<T>, IAsyncEnumerable<T>>
		{
			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@427-5(FSharpRef<FSharpOption<T>> b)
			{
				((FSharpFunc<FSharpOption<FSharpOption<T>>, IAsyncEnumerable<FSharpOption<T>>>)(object)this)..ctor();
				this.b = b;
			}

			public override IAsyncEnumerable<T> Invoke(FSharpOption<T> _arg2)
			{
				((FSharpRef<FSharpOption<FSharpOption<T>>>)(object)b).contents = (FSharpOption<FSharpOption<T>>)(object)_arg2;
				return empty<T>();
			}
		}

		[Serializable]
		internal sealed class emitEnumerator@426-4<T> : FSharpFunc<Unit, IAsyncEnumerable<T>>
		{
			public IAsyncEnumerator<T> ie;

			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@426-4(IAsyncEnumerator<T> ie, FSharpRef<FSharpOption<T>> b)
			{
				((FSharpFunc<Unit, IAsyncEnumerable<Unit>>)(object)this)..ctor();
				this.ie = ie;
				this.b = b;
			}

			public override IAsyncEnumerable<T> Invoke(Unit unitVar)
			{
				return bindAsync(new emitEnumerator@427-5<T>(b), ie.MoveNext());
			}
		}

		[Serializable]
		internal sealed class emitEnumerator@425-3<T> : FSharpFunc<Unit, IAsyncEnumerable<T>>
		{
			public IAsyncEnumerator<T> ie;

			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@425-3(IAsyncEnumerator<T> ie, FSharpRef<FSharpOption<T>> b)
			{
				((FSharpFunc<Unit, IAsyncEnumerable<Unit>>)(object)this)..ctor();
				this.ie = ie;
				this.b = b;
			}

			public override IAsyncEnumerable<T> Invoke(Unit unitVar)
			{
				return AsyncGenerator.append(singleton(((FSharpRef<FSharpOption<FSharpOption<T>>>)(object)b).contents.Value), AsyncGenerator.delay(new emitEnumerator@426-4<T>(ie, b)));
			}
		}

		[Serializable]
		internal sealed class emitEnumerator@423-1<T> : FSharpFunc<FSharpOption<T>, IAsyncEnumerable<T>>
		{
			public IAsyncEnumerator<T> ie;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@423-1(IAsyncEnumerator<T> ie)
			{
				((FSharpFunc<FSharpOption<FSharpOption<T>>, IAsyncEnumerable<FSharpOption<T>>>)(object)this)..ctor();
				this.ie = ie;
			}

			public override IAsyncEnumerable<T> Invoke(FSharpOption<T> _arg1)
			{
				FSharpRef<FSharpOption<T>> b = (FSharpRef<FSharpOption<T>>)(object)new FSharpRef<FSharpOption<FSharpOption<T>>>((FSharpOption<FSharpOption<T>>)(object)_arg1);
				return asyncSeq.While(new emitEnumerator@424-2<T>(b), AsyncGenerator.delay(new emitEnumerator@425-3<T>(ie, b)));
			}
		}

		[Serializable]
		internal sealed class emitEnumerator@422<T> : FSharpFunc<Unit, IAsyncEnumerable<T>>
		{
			public IAsyncEnumerator<T> ie;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@422(IAsyncEnumerator<T> ie)
			{
				((FSharpFunc<Unit, IAsyncEnumerable<Unit>>)(object)this)..ctor();
				this.ie = ie;
			}

			public override IAsyncEnumerable<T> Invoke(Unit unitVar)
			{
				return bindAsync(new emitEnumerator@423-1<T>(ie), ie.MoveNext());
			}
		}

		[Serializable]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[RequireQualifiedAccess]
		[DebuggerDisplay("{__DebugDisplay(),nq}")]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal class TryWithState<T> : IEquatable<TryWithState<T>>, IStructuralEquatable
		{
			internal static class Tags
			{
				public const int NotStarted = 0;

				public const int HaveBodyEnumerator = 1;

				public const int HaveHandlerEnumerator = 2;

				public const int Finished = 3;
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(TryWithState<>.NotStarted@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class NotStarted : TryWithState<T>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerable<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal NotStarted(IAsyncEnumerable<T> item)
					: base(0)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(TryWithState<>.HaveBodyEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveBodyEnumerator : TryWithState<T>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveBodyEnumerator(IAsyncEnumerator<T> item)
					: base(1)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(TryWithState<>.HaveHandlerEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveHandlerEnumerator : TryWithState<T>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveHandlerEnumerator(IAsyncEnumerator<T> item)
					: base(2)
				{
					this.item = item;
				}
			}

			[SpecialName]
			internal class NotStarted@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public NotStarted@DebugTypeProxy(NotStarted obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveBodyEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveBodyEnumerator@DebugTypeProxy(HaveBodyEnumerator obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveHandlerEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveHandlerEnumerator@DebugTypeProxy(HaveHandlerEnumerator obj)
				{
					_obj = obj;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal int Tag
			{
				[DebuggerNonUserCode]
				get;
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsNotStarted
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 0;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveBodyEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 1;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveHandlerEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 2;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal static TryWithState<T> Finished
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				get
				{
					return _unique_Finished;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsFinished
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 3;
				}
			}

			static TryWithState()
			{
				_unique_Finished = new TryWithState<T>(3);
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal TryWithState(int _tag)
			{
				this._tag = _tag;
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static TryWithState<T> NewNotStarted(IAsyncEnumerable<T> item)
			{
				return new NotStarted(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static TryWithState<T> NewHaveBodyEnumerator(IAsyncEnumerator<T> item)
			{
				return new HaveBodyEnumerator(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static TryWithState<T> NewHaveHandlerEnumerator(IAsyncEnumerator<T> item)
			{
				return new HaveHandlerEnumerator(item);
			}

			[SpecialName]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal object __DebugDisplay()
			{
				return ((FSharpFunc<TryWithState<TryWithState<T>>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<TryWithState<T>, string>>((PrintfFormat<FSharpFunc<TryWithState<T>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<TryWithState<FSharpFunc<TryWithState<T>, string>>, string>, Unit, string, string, string>("%+0.8A"))).Invoke((TryWithState<TryWithState<T>>)(object)this);
			}

			[CompilerGenerated]
			public override string ToString()
			{
				return ((FSharpFunc<TryWithState<TryWithState<T>>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<TryWithState<T>, string>>((PrintfFormat<FSharpFunc<TryWithState<T>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<TryWithState<FSharpFunc<TryWithState<T>, string>>, string>, Unit, string, string, TryWithState<FSharpFunc<TryWithState<T>, string>>>("%+A"))).Invoke((TryWithState<TryWithState<T>>)(object)this);
			}

			[CompilerGenerated]
			public virtual sealed int GetHashCode(IEqualityComparer comp)
			{
				if (this != null)
				{
					int num = 0;
					switch (Tag)
					{
					default:
						return _tag;
					case 0:
					{
						NotStarted notStarted = (NotStarted)this;
						num = 0;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerable<T>>(comp, notStarted.item) + ((num << 6) + (num >> 2)));
					}
					case 1:
					{
						HaveBodyEnumerator haveBodyEnumerator = (HaveBodyEnumerator)this;
						num = 1;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveBodyEnumerator.item) + ((num << 6) + (num >> 2)));
					}
					case 2:
					{
						HaveHandlerEnumerator haveHandlerEnumerator = (HaveHandlerEnumerator)this;
						num = 2;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveHandlerEnumerator.item) + ((num << 6) + (num >> 2)));
					}
					}
				}
				return 0;
			}

			[CompilerGenerated]
			public sealed override int GetHashCode()
			{
				return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(object obj, IEqualityComparer comp)
			{
				if (this != null)
				{
					if (obj is TryWithState<T> tryWithState)
					{
						int tag = _tag;
						int tag2 = tryWithState._tag;
						if (tag == tag2)
						{
							switch (Tag)
							{
							default:
								return true;
							case 0:
							{
								NotStarted notStarted = (NotStarted)this;
								NotStarted notStarted2 = (NotStarted)tryWithState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerable<T>>(comp, notStarted.item, notStarted2.item);
							}
							case 1:
							{
								HaveBodyEnumerator haveBodyEnumerator = (HaveBodyEnumerator)this;
								HaveBodyEnumerator haveBodyEnumerator2 = (HaveBodyEnumerator)tryWithState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveBodyEnumerator.item, haveBodyEnumerator2.item);
							}
							case 2:
							{
								HaveHandlerEnumerator haveHandlerEnumerator = (HaveHandlerEnumerator)this;
								HaveHandlerEnumerator haveHandlerEnumerator2 = (HaveHandlerEnumerator)tryWithState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveHandlerEnumerator.item, haveHandlerEnumerator2.item);
							}
							}
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(TryWithState<T> obj)
			{
				if (this != null)
				{
					if (obj != null)
					{
						int tag = _tag;
						int tag2 = obj._tag;
						if (tag == tag2)
						{
							switch (Tag)
							{
							default:
								return true;
							case 0:
							{
								NotStarted notStarted = (NotStarted)this;
								NotStarted notStarted2 = (NotStarted)obj;
								return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerable<T>>(notStarted.item, notStarted2.item);
							}
							case 1:
							{
								HaveBodyEnumerator haveBodyEnumerator = (HaveBodyEnumerator)this;
								HaveBodyEnumerator haveBodyEnumerator2 = (HaveBodyEnumerator)obj;
								return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<T>>(haveBodyEnumerator.item, haveBodyEnumerator2.item);
							}
							case 2:
							{
								HaveHandlerEnumerator haveHandlerEnumerator = (HaveHandlerEnumerator)this;
								HaveHandlerEnumerator haveHandlerEnumerator2 = (HaveHandlerEnumerator)obj;
								return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<T>>(haveHandlerEnumerator.item, haveHandlerEnumerator2.item);
							}
							}
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public sealed override bool Equals(object obj)
			{
				if (obj is TryWithState<T> obj2)
				{
					return Equals(obj2);
				}
				return false;
			}
		}

		[Serializable]
		internal sealed class tryWith@448-3<T> : FSharpFunc<Unit, FSharpAsync<Unit>>
		{
			public IAsyncEnumerable<T> inp;

			public FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@448-3(IAsyncEnumerable<T> inp, FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res)
			{
				this.inp = inp;
				this.res = res;
			}

			public override FSharpAsync<Unit> Invoke(Unit unitVar)
			{
				((FSharpRef<FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>>)(object)res).contents = (FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>)(object)FSharpChoice<IAsyncEnumerator<IAsyncEnumerator<T>>, Exception>.NewChoice1Of2((IAsyncEnumerator<IAsyncEnumerator<T>>)inp.GetEnumerator());
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Zero();
			}
		}

		[Serializable]
		internal sealed class tryWith@447-4<T> : FSharpFunc<Exception, FSharpAsync<Unit>>
		{
			public FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@447-4(FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res)
			{
				this.res = res;
			}

			public override FSharpAsync<Unit> Invoke(Exception _arg1)
			{
				((FSharpRef<FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>>)(object)res).contents = (FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>)(object)FSharpChoice<IAsyncEnumerator<IAsyncEnumerator<T>>, Exception>.NewChoice2Of2(_arg1);
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Zero();
			}
		}

		[Serializable]
		internal sealed class tryWith@451-5<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			public FSharpFunc<Exception, IAsyncEnumerable<T>> handler;

			public FSharpRef<TryWithState<T>> state;

			public IAsyncEnumerator<T> x;

			public FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@451-5(FSharpFunc<Exception, IAsyncEnumerable<T>> handler, FSharpRef<TryWithState<T>> state, IAsyncEnumerator<T> x, FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.handler = handler;
				this.state = state;
				this.x = x;
				this.res = res;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				FSharpChoice<IAsyncEnumerator<T>, Exception> contents = ((FSharpRef<FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>>)(object)res).contents;
				IAsyncEnumerator<T> enumerator;
				if (contents is Choice2Of2<IAsyncEnumerator<T>, Exception>)
				{
					Choice2Of2<IAsyncEnumerator<T>, Exception> val = (Choice2Of2<IAsyncEnumerator<T>, Exception>)(object)contents;
					Exception item = ((Choice2Of2<IAsyncEnumerator<IAsyncEnumerator<T>>, Exception>)(object)val).Item;
					x.Dispose();
					enumerator = ((FSharpFunc<Exception, IAsyncEnumerable<Exception>>)(object)handler).Invoke(item).GetEnumerator();
					((FSharpRef<TryWithState<TryWithState<T>>>)(object)state).contents = (TryWithState<TryWithState<T>>)(object)TryWithState<T>.NewHaveHandlerEnumerator(enumerator);
					return x.MoveNext();
				}
				Choice1Of2<IAsyncEnumerator<T>, Exception> val2 = (Choice1Of2<IAsyncEnumerator<T>, Exception>)(object)contents;
				enumerator = ((Choice1Of2<IAsyncEnumerator<IAsyncEnumerator<T>>, Exception>)(object)val2).Item;
				((FSharpRef<TryWithState<TryWithState<T>>>)(object)state).contents = (TryWithState<TryWithState<T>>)(object)TryWithState<T>.NewHaveBodyEnumerator(enumerator);
				return x.MoveNext();
			}
		}

		[Serializable]
		internal sealed class tryWith@466-7<T> : FSharpFunc<FSharpOption<T>, FSharpAsync<Unit>>
		{
			public FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@466-7(FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res)
			{
				((FSharpFunc<FSharpOption<FSharpOption<T>>, FSharpAsync<Unit>>)(object)this)..ctor();
				this.res = res;
			}

			public override FSharpAsync<Unit> Invoke(FSharpOption<T> _arg2)
			{
				((FSharpRef<FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>>)(object)res).contents = (FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>)(object)FSharpChoice<FSharpOption<FSharpOption<T>>, Exception>.NewChoice1Of2((FSharpOption<FSharpOption<T>>)(object)_arg2);
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Zero();
			}
		}

		[Serializable]
		internal sealed class tryWith@465-6<T> : FSharpFunc<Unit, FSharpAsync<Unit>>
		{
			public IAsyncEnumerator<T> e;

			public FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@465-6(IAsyncEnumerator<T> e, FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res)
			{
				this.e = e;
				this.res = res;
			}

			public override FSharpAsync<Unit> Invoke(Unit unitVar)
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Bind<FSharpOption<T>, Unit>(e.MoveNext(), (FSharpFunc<FSharpOption<T>, FSharpAsync<Unit>>)new tryWith@466-7<T>(res));
			}
		}

		[Serializable]
		internal sealed class tryWith@464-8<T> : FSharpFunc<Exception, FSharpAsync<Unit>>
		{
			public FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@464-8(FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res)
			{
				this.res = res;
			}

			public override FSharpAsync<Unit> Invoke(Exception _arg3)
			{
				((FSharpRef<FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>>)(object)res).contents = (FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>)(object)FSharpChoice<FSharpOption<FSharpOption<T>>, Exception>.NewChoice2Of2(_arg3);
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Zero();
			}
		}

		[Serializable]
		internal sealed class tryWith@469-9<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			public FSharpFunc<Exception, IAsyncEnumerable<T>> handler;

			public FSharpRef<TryWithState<T>> state;

			public IAsyncEnumerator<T> x;

			public FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@469-9(FSharpFunc<Exception, IAsyncEnumerable<T>> handler, FSharpRef<TryWithState<T>> state, IAsyncEnumerator<T> x, FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.handler = handler;
				this.state = state;
				this.x = x;
				this.res = res;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				FSharpChoice<FSharpOption<T>, Exception> contents = ((FSharpRef<FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>>)(object)res).contents;
				if (contents is Choice2Of2<FSharpOption<T>, Exception>)
				{
					Choice2Of2<FSharpOption<T>, Exception> val = (Choice2Of2<FSharpOption<T>, Exception>)(object)contents;
					Exception item = ((Choice2Of2<FSharpOption<FSharpOption<T>>, Exception>)(object)val).Item;
					x.Dispose();
					IAsyncEnumerator<T> enumerator = ((FSharpFunc<Exception, IAsyncEnumerable<Exception>>)(object)handler).Invoke(item).GetEnumerator();
					((FSharpRef<TryWithState<TryWithState<T>>>)(object)state).contents = (TryWithState<TryWithState<T>>)(object)TryWithState<T>.NewHaveHandlerEnumerator(enumerator);
					return x.MoveNext();
				}
				Choice1Of2<FSharpOption<T>, Exception> val2 = (Choice1Of2<FSharpOption<T>, Exception>)(object)contents;
				FSharpOption<T> item2 = ((Choice1Of2<FSharpOption<FSharpOption<T>>, Exception>)(object)val2).Item;
				FSharpAsyncBuilder defaultAsyncBuilder = ExtraTopLevelOperators.DefaultAsyncBuilder;
				if (item2 == null)
				{
					x.Dispose();
				}
				return defaultAsyncBuilder.Return<FSharpOption<T>>(item2);
			}
		}

		[Serializable]
		internal sealed class tryWith@484-10<T> : FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>>
		{
			public IAsyncEnumerator<T> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@484-10(IAsyncEnumerator<T> x)
			{
				((FSharpFunc<FSharpOption<FSharpOption<T>>, FSharpAsync<FSharpOption<FSharpOption<T>>>>)(object)this)..ctor();
				this.x = x;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(FSharpOption<T> _arg4)
			{
				FSharpAsyncBuilder defaultAsyncBuilder = ExtraTopLevelOperators.DefaultAsyncBuilder;
				object obj;
				if (_arg4 == null)
				{
					x.Dispose();
					obj = null;
				}
				else
				{
					obj = _arg4;
				}
				return defaultAsyncBuilder.Return<FSharpOption<T>>((FSharpOption<T>)obj);
			}
		}

		[Serializable]
		internal sealed class tryWith@444-2<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			public FSharpFunc<Exception, IAsyncEnumerable<T>> handler;

			public FSharpRef<TryWithState<T>> state;

			public IAsyncEnumerator<T> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@444-2(FSharpFunc<Exception, IAsyncEnumerable<T>> handler, FSharpRef<TryWithState<T>> state, IAsyncEnumerator<T> x)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.handler = handler;
				this.state = state;
				this.x = x;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				TryWithState<T> contents = ((FSharpRef<TryWithState<TryWithState<T>>>)(object)state).contents;
				switch (contents.Tag)
				{
				default:
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<T>>((FSharpOption<T>)null);
				case 0:
				{
					TryWithState<T>.NotStarted notStarted = (TryWithState<T>.NotStarted)contents;
					IAsyncEnumerable<T> item2 = notStarted.item;
					FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res2 = (FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>>)(object)new FSharpRef<FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>>((FSharpChoice<IAsyncEnumerator<FSharpChoice<IAsyncEnumerator<T>, Exception>>, Exception>)null);
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Combine<FSharpOption<T>>(ExtraTopLevelOperators.DefaultAsyncBuilder.TryWith<Unit>(ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)new tryWith@448-3<T>(item2, res2)), (FSharpFunc<Exception, FSharpAsync<Unit>>)new tryWith@447-4<T>(res2)), ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryWith@451-5<T>(handler, state, x, res2)));
				}
				case 1:
				{
					TryWithState<T>.HaveBodyEnumerator haveBodyEnumerator = (TryWithState<T>.HaveBodyEnumerator)contents;
					IAsyncEnumerator<T> item = haveBodyEnumerator.item;
					FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res = (FSharpRef<FSharpChoice<FSharpOption<T>, Exception>>)(object)new FSharpRef<FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>>((FSharpChoice<FSharpOption<FSharpChoice<FSharpOption<T>, Exception>>, Exception>)null);
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Combine<FSharpOption<T>>(ExtraTopLevelOperators.DefaultAsyncBuilder.TryWith<Unit>(ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)new tryWith@465-6<T>(item, res)), (FSharpFunc<Exception, FSharpAsync<Unit>>)new tryWith@464-8<T>(res)), ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryWith@469-9<T>(handler, state, x, res)));
				}
				case 2:
				{
					TryWithState<T>.HaveHandlerEnumerator haveHandlerEnumerator = (TryWithState<T>.HaveHandlerEnumerator)contents;
					IAsyncEnumerator<T> item = haveHandlerEnumerator.item;
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Bind<FSharpOption<T>, FSharpOption<T>>(item.MoveNext(), (FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>>)new tryWith@484-10<T>(x));
				}
				}
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class tryWith@442-1<T> : IAsyncEnumerator<T>
		{
			public FSharpFunc<Exception, IAsyncEnumerable<T>> handler;

			public FSharpRef<TryWithState<T>> state;

			public tryWith@442-1(FSharpFunc<Exception, IAsyncEnumerable<T>> handler, FSharpRef<TryWithState<T>> state)
			{
				this.handler = handler;
				this.state = state;
				base..ctor();
			}

			private FSharpAsync<FSharpOption<T>> FSharp-Control-IAsyncEnumerator`1-MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryWith@444-2<T>(handler, state, this));
			}

			FSharpAsync<FSharpOption<T>> IAsyncEnumerator<T>.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerator`1-MoveNext
				return this.FSharp-Control-IAsyncEnumerator`1-MoveNext();
			}

			private void System-IDisposable-Dispose()
			{
				TryWithState<T> contents = ((FSharpRef<TryWithState<TryWithState<T>>>)(object)state).contents;
				IAsyncEnumerator<T> item;
				switch (contents.Tag)
				{
				default:
					return;
				case 1:
					item = ((TryWithState<T>.HaveBodyEnumerator)contents).item;
					break;
				case 2:
					item = ((TryWithState<T>.HaveHandlerEnumerator)contents).item;
					break;
				}
				((FSharpRef<TryWithState<TryWithState<T>>>)(object)state).contents = (TryWithState<TryWithState<T>>)(object)TryWithState<T>.Finished;
				item?.Dispose();
			}

			void IDisposable.Dispose()
			{
				//ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose
				this.System-IDisposable-Dispose();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class tryWith@439<T> : IAsyncEnumerable<T>
		{
			public IAsyncEnumerable<T> inp;

			public FSharpFunc<Exception, IAsyncEnumerable<T>> handler;

			public tryWith@439(IAsyncEnumerable<T> inp, FSharpFunc<Exception, IAsyncEnumerable<T>> handler)
			{
				this.inp = inp;
				this.handler = handler;
				base..ctor();
			}

			private IAsyncEnumerator<T> FSharp-Control-IAsyncEnumerable`1-GetEnumerator()
			{
				FSharpRef<TryWithState<T>> state = (FSharpRef<TryWithState<T>>)(object)new FSharpRef<TryWithState<TryWithState<T>>>((TryWithState<TryWithState<T>>)(object)TryWithState<T>.NewNotStarted(inp));
				return new tryWith@442-1<T>(handler, state);
			}

			IAsyncEnumerator<T> IAsyncEnumerable<T>.GetEnumerator()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerable`1-GetEnumerator
				return this.FSharp-Control-IAsyncEnumerable`1-GetEnumerator();
			}
		}

		[Serializable]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[RequireQualifiedAccess]
		[DebuggerDisplay("{__DebugDisplay(),nq}")]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal abstract class TryFinallyState<T> : IEquatable<TryFinallyState<T>>, IStructuralEquatable
		{
			internal static class Tags
			{
				public const int NotStarted = 0;

				public const int HaveBodyEnumerator = 1;

				public const int Finished = 2;
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(TryFinallyState<>.NotStarted@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class NotStarted : TryFinallyState<T>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerable<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal NotStarted(IAsyncEnumerable<T> item)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(TryFinallyState<>.HaveBodyEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveBodyEnumerator : TryFinallyState<T>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveBodyEnumerator(IAsyncEnumerator<T> item)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(TryFinallyState<>._Finished@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class _Finished : TryFinallyState<T>
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal _Finished()
				{
				}
			}

			[SpecialName]
			internal class NotStarted@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public NotStarted@DebugTypeProxy(NotStarted obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveBodyEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveBodyEnumerator@DebugTypeProxy(HaveBodyEnumerator obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class _Finished@DebugTypeProxy
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public _Finished@DebugTypeProxy(_Finished obj)
				{
					_obj = obj;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal int Tag
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return (this is _Finished) ? 2 : ((this is HaveBodyEnumerator) ? 1 : 0);
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsNotStarted
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return this is NotStarted;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveBodyEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return this is HaveBodyEnumerator;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal static TryFinallyState<T> Finished
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				get
				{
					return _unique_Finished;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsFinished
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return this is _Finished;
				}
			}

			static TryFinallyState()
			{
				_unique_Finished = new _Finished();
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal TryFinallyState()
			{
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static TryFinallyState<T> NewNotStarted(IAsyncEnumerable<T> item)
			{
				return new NotStarted(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static TryFinallyState<T> NewHaveBodyEnumerator(IAsyncEnumerator<T> item)
			{
				return new HaveBodyEnumerator(item);
			}

			[SpecialName]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal object __DebugDisplay()
			{
				return ((FSharpFunc<TryFinallyState<TryFinallyState<T>>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<TryFinallyState<T>, string>>((PrintfFormat<FSharpFunc<TryFinallyState<T>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<TryFinallyState<FSharpFunc<TryFinallyState<T>, string>>, string>, Unit, string, string, string>("%+0.8A"))).Invoke((TryFinallyState<TryFinallyState<T>>)(object)this);
			}

			[CompilerGenerated]
			public override string ToString()
			{
				return ((FSharpFunc<TryFinallyState<TryFinallyState<T>>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<TryFinallyState<T>, string>>((PrintfFormat<FSharpFunc<TryFinallyState<T>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<TryFinallyState<FSharpFunc<TryFinallyState<T>, string>>, string>, Unit, string, string, TryFinallyState<FSharpFunc<TryFinallyState<T>, string>>>("%+A"))).Invoke((TryFinallyState<TryFinallyState<T>>)(object)this);
			}

			[CompilerGenerated]
			public virtual sealed int GetHashCode(IEqualityComparer comp)
			{
				if (this != null)
				{
					int num = 0;
					if (!(this is NotStarted))
					{
						if (!(this is HaveBodyEnumerator))
						{
							return (this is _Finished) ? 2 : ((this is HaveBodyEnumerator) ? 1 : 0);
						}
						HaveBodyEnumerator haveBodyEnumerator = (HaveBodyEnumerator)this;
						num = 1;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveBodyEnumerator.item) + ((num << 6) + (num >> 2)));
					}
					NotStarted notStarted = (NotStarted)this;
					num = 0;
					return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerable<T>>(comp, notStarted.item) + ((num << 6) + (num >> 2)));
				}
				return 0;
			}

			[CompilerGenerated]
			public sealed override int GetHashCode()
			{
				return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(object obj, IEqualityComparer comp)
			{
				if (this != null)
				{
					if (obj is TryFinallyState<T> tryFinallyState)
					{
						int num = ((this is _Finished) ? 2 : ((this is HaveBodyEnumerator) ? 1 : 0));
						TryFinallyState<T> tryFinallyState2 = tryFinallyState;
						int num2 = ((tryFinallyState2 is _Finished) ? 2 : ((tryFinallyState2 is HaveBodyEnumerator) ? 1 : 0));
						if (num == num2)
						{
							if (!(this is NotStarted))
							{
								if (!(this is HaveBodyEnumerator))
								{
									return true;
								}
								HaveBodyEnumerator haveBodyEnumerator = (HaveBodyEnumerator)this;
								HaveBodyEnumerator haveBodyEnumerator2 = (HaveBodyEnumerator)tryFinallyState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveBodyEnumerator.item, haveBodyEnumerator2.item);
							}
							NotStarted notStarted = (NotStarted)this;
							NotStarted notStarted2 = (NotStarted)tryFinallyState;
							return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerable<T>>(comp, notStarted.item, notStarted2.item);
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(TryFinallyState<T> obj)
			{
				if (this != null)
				{
					if (obj != null)
					{
						int num = ((this is _Finished) ? 2 : ((this is HaveBodyEnumerator) ? 1 : 0));
						int num2 = ((obj is _Finished) ? 2 : ((obj is HaveBodyEnumerator) ? 1 : 0));
						if (num == num2)
						{
							if (!(this is NotStarted))
							{
								if (!(this is HaveBodyEnumerator))
								{
									return true;
								}
								HaveBodyEnumerator haveBodyEnumerator = (HaveBodyEnumerator)this;
								HaveBodyEnumerator haveBodyEnumerator2 = (HaveBodyEnumerator)obj;
								return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<T>>(haveBodyEnumerator.item, haveBodyEnumerator2.item);
							}
							NotStarted notStarted = (NotStarted)this;
							NotStarted notStarted2 = (NotStarted)obj;
							return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerable<T>>(notStarted.item, notStarted2.item);
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public sealed override bool Equals(object obj)
			{
				if (obj is TryFinallyState<T> obj2)
				{
					return Equals(obj2);
				}
				return false;
			}
		}

		[Serializable]
		internal sealed class tryFinally@519-3<T> : FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>>
		{
			public IAsyncEnumerator<T> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@519-3(IAsyncEnumerator<T> x)
			{
				((FSharpFunc<FSharpOption<FSharpOption<T>>, FSharpAsync<FSharpOption<FSharpOption<T>>>>)(object)this)..ctor();
				this.x = x;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(FSharpOption<T> _arg1)
			{
				FSharpAsyncBuilder defaultAsyncBuilder = ExtraTopLevelOperators.DefaultAsyncBuilder;
				if (_arg1 == null)
				{
					x.Dispose();
				}
				return defaultAsyncBuilder.Return<FSharpOption<T>>(_arg1);
			}
		}

		[Serializable]
		internal sealed class tryFinally@511-2<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			public FSharpRef<TryFinallyState<T>> state;

			public IAsyncEnumerator<T> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@511-2(FSharpRef<TryFinallyState<T>> state, IAsyncEnumerator<T> x)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.state = state;
				this.x = x;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				TryFinallyState<T> contents = ((FSharpRef<TryFinallyState<TryFinallyState<T>>>)(object)state).contents;
				TryFinallyState<T> tryFinallyState = contents;
				IAsyncEnumerator<T> item;
				if (!(tryFinallyState is TryFinallyState<T>.NotStarted))
				{
					if (!(tryFinallyState is TryFinallyState<T>.HaveBodyEnumerator))
					{
						return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<T>>((FSharpOption<T>)null);
					}
					TryFinallyState<T>.HaveBodyEnumerator haveBodyEnumerator = (TryFinallyState<T>.HaveBodyEnumerator)contents;
					item = haveBodyEnumerator.item;
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Bind<FSharpOption<T>, FSharpOption<T>>(item.MoveNext(), (FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>>)new tryFinally@519-3<T>(x));
				}
				TryFinallyState<T>.NotStarted notStarted = (TryFinallyState<T>.NotStarted)contents;
				IAsyncEnumerable<T> item2 = notStarted.item;
				item = item2.GetEnumerator();
				((FSharpRef<TryFinallyState<TryFinallyState<T>>>)(object)state).contents = (TryFinallyState<TryFinallyState<T>>)(object)TryFinallyState<T>.NewHaveBodyEnumerator(item);
				return x.MoveNext();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class tryFinally@509-1<T> : IAsyncEnumerator<T>
		{
			public FSharpFunc<Unit, Unit> compensation;

			public FSharpRef<TryFinallyState<T>> state;

			public tryFinally@509-1(FSharpFunc<Unit, Unit> compensation, FSharpRef<TryFinallyState<T>> state)
			{
				this.compensation = compensation;
				this.state = state;
				base..ctor();
			}

			private FSharpAsync<FSharpOption<T>> FSharp-Control-IAsyncEnumerator`1-MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryFinally@511-2<T>(state, this));
			}

			FSharpAsync<FSharpOption<T>> IAsyncEnumerator<T>.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerator`1-MoveNext
				return this.FSharp-Control-IAsyncEnumerator`1-MoveNext();
			}

			private void System-IDisposable-Dispose()
			{
				TryFinallyState<T> contents = ((FSharpRef<TryFinallyState<TryFinallyState<T>>>)(object)state).contents;
				if (contents is TryFinallyState<T>.HaveBodyEnumerator)
				{
					TryFinallyState<T>.HaveBodyEnumerator haveBodyEnumerator = (TryFinallyState<T>.HaveBodyEnumerator)contents;
					IAsyncEnumerator<T> item = haveBodyEnumerator.item;
					((FSharpRef<TryFinallyState<TryFinallyState<T>>>)(object)state).contents = (TryFinallyState<TryFinallyState<T>>)(object)TryFinallyState<T>.Finished;
					item?.Dispose();
					compensation.Invoke((Unit)null);
				}
			}

			void IDisposable.Dispose()
			{
				//ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose
				this.System-IDisposable-Dispose();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class tryFinally@506<T> : IAsyncEnumerable<T>
		{
			public IAsyncEnumerable<T> inp;

			public FSharpFunc<Unit, Unit> compensation;

			public tryFinally@506(IAsyncEnumerable<T> inp, FSharpFunc<Unit, Unit> compensation)
			{
				this.inp = inp;
				this.compensation = compensation;
				base..ctor();
			}

			private IAsyncEnumerator<T> FSharp-Control-IAsyncEnumerable`1-GetEnumerator()
			{
				FSharpRef<TryFinallyState<T>> state = (FSharpRef<TryFinallyState<T>>)(object)new FSharpRef<TryFinallyState<TryFinallyState<T>>>((TryFinallyState<TryFinallyState<T>>)(object)TryFinallyState<T>.NewNotStarted(inp));
				return new tryFinally@509-1<T>(compensation, state);
			}

			IAsyncEnumerator<T> IAsyncEnumerable<T>.GetEnumerator()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerable`1-GetEnumerator
				return this.FSharp-Control-IAsyncEnumerable`1-GetEnumerator();
			}
		}

		[Serializable]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[RequireQualifiedAccess]
		[DebuggerDisplay("{__DebugDisplay(),nq}")]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal class CollectState<T, U> : IEquatable<CollectState<T, U>>, IStructuralEquatable
		{
			internal static class Tags
			{
				public const int NotStarted = 0;

				public const int HaveInputEnumerator = 1;

				public const int HaveInnerEnumerator = 2;

				public const int Finished = 3;
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(CollectState<, >.NotStarted@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class NotStarted : CollectState<T, U>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerable<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal NotStarted(IAsyncEnumerable<T> item)
					: base(0)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(CollectState<, >.HaveInputEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveInputEnumerator : CollectState<T, U>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveInputEnumerator(IAsyncEnumerator<T> item)
					: base(1)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(CollectState<, >.HaveInnerEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveInnerEnumerator : CollectState<T, U>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<T> item1;

				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<U> item2;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<T> Item1
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item1;
					}
				}

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<U> Item2
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item2;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveInnerEnumerator(IAsyncEnumerator<T> item1, IAsyncEnumerator<U> item2)
					: base(2)
				{
					this.item1 = item1;
					this.item2 = item2;
				}
			}

			[SpecialName]
			internal class NotStarted@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public NotStarted@DebugTypeProxy(NotStarted obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveInputEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveInputEnumerator@DebugTypeProxy(HaveInputEnumerator obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveInnerEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<T> Item1
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item1;
					}
				}

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<U> Item2
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item2;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveInnerEnumerator@DebugTypeProxy(HaveInnerEnumerator obj)
				{
					_obj = obj;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal int Tag
			{
				[DebuggerNonUserCode]
				get;
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsNotStarted
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 0;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveInputEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 1;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveInnerEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 2;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal static CollectState<T, U> Finished
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				get
				{
					return _unique_Finished;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsFinished
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 3;
				}
			}

			static CollectState()
			{
				_unique_Finished = new CollectState<T, U>(3);
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal CollectState(int _tag)
			{
				this._tag = _tag;
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static CollectState<T, U> NewNotStarted(IAsyncEnumerable<T> item)
			{
				return new NotStarted(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static CollectState<T, U> NewHaveInputEnumerator(IAsyncEnumerator<T> item)
			{
				return new HaveInputEnumerator(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static CollectState<T, U> NewHaveInnerEnumerator(IAsyncEnumerator<T> item1, IAsyncEnumerator<U> item2)
			{
				return new HaveInnerEnumerator(item1, item2);
			}

			[SpecialName]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal object __DebugDisplay()
			{
				return ((FSharpFunc<CollectState<CollectState<T, U>, string>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<CollectState<T, U>, string>>((PrintfFormat<FSharpFunc<CollectState<T, U>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<CollectState<FSharpFunc<CollectState<T, U>, string>, Unit>, string>, Unit, string, string, string>("%+0.8A"))).Invoke((CollectState<CollectState<T, U>, string>)(object)this);
			}

			[CompilerGenerated]
			public override string ToString()
			{
				return ((FSharpFunc<CollectState<CollectState<T, U>, string>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<CollectState<T, U>, string>>((PrintfFormat<FSharpFunc<CollectState<T, U>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<CollectState<FSharpFunc<CollectState<T, U>, string>, Unit>, string>, Unit, string, string, CollectState<FSharpFunc<CollectState<T, U>, string>, Unit>>("%+A"))).Invoke((CollectState<CollectState<T, U>, string>)(object)this);
			}

			[CompilerGenerated]
			public virtual sealed int GetHashCode(IEqualityComparer comp)
			{
				if (this != null)
				{
					int num = 0;
					switch (Tag)
					{
					default:
						return _tag;
					case 0:
					{
						NotStarted notStarted = (NotStarted)this;
						num = 0;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerable<T>>(comp, notStarted.item) + ((num << 6) + (num >> 2)));
					}
					case 1:
					{
						HaveInputEnumerator haveInputEnumerator = (HaveInputEnumerator)this;
						num = 1;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveInputEnumerator.item) + ((num << 6) + (num >> 2)));
					}
					case 2:
					{
						HaveInnerEnumerator haveInnerEnumerator = (HaveInnerEnumerator)this;
						num = 2;
						num = -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<U>>(comp, haveInnerEnumerator.item2) + ((num << 6) + (num >> 2)));
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveInnerEnumerator.item1) + ((num << 6) + (num >> 2)));
					}
					}
				}
				return 0;
			}

			[CompilerGenerated]
			public sealed override int GetHashCode()
			{
				return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(object obj, IEqualityComparer comp)
			{
				if (this != null)
				{
					if (obj is CollectState<T, U> collectState)
					{
						int tag = _tag;
						int tag2 = collectState._tag;
						if (tag == tag2)
						{
							switch (Tag)
							{
							default:
								return true;
							case 0:
							{
								NotStarted notStarted = (NotStarted)this;
								NotStarted notStarted2 = (NotStarted)collectState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerable<T>>(comp, notStarted.item, notStarted2.item);
							}
							case 1:
							{
								HaveInputEnumerator haveInputEnumerator = (HaveInputEnumerator)this;
								HaveInputEnumerator haveInputEnumerator2 = (HaveInputEnumerator)collectState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveInputEnumerator.item, haveInputEnumerator2.item);
							}
							case 2:
							{
								HaveInnerEnumerator haveInnerEnumerator = (HaveInnerEnumerator)this;
								HaveInnerEnumerator haveInnerEnumerator2 = (HaveInnerEnumerator)collectState;
								if (HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<T>>(comp, haveInnerEnumerator.item1, haveInnerEnumerator2.item1))
								{
									return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<U>>(comp, haveInnerEnumerator.item2, haveInnerEnumerator2.item2);
								}
								return false;
							}
							}
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(CollectState<T, U> obj)
			{
				if (this != null)
				{
					if (obj != null)
					{
						int tag = _tag;
						int tag2 = obj._tag;
						if (tag == tag2)
						{
							switch (Tag)
							{
							default:
								return true;
							case 0:
							{
								NotStarted notStarted = (NotStarted)this;
								NotStarted notStarted2 = (NotStarted)obj;
								return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerable<T>>(notStarted.item, notStarted2.item);
							}
							case 1:
							{
								HaveInputEnumerator haveInputEnumerator = (HaveInputEnumerator)this;
								HaveInputEnumerator haveInputEnumerator2 = (HaveInputEnumerator)obj;
								return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<T>>(haveInputEnumerator.item, haveInputEnumerator2.item);
							}
							case 2:
							{
								HaveInnerEnumerator haveInnerEnumerator = (HaveInnerEnumerator)this;
								HaveInnerEnumerator haveInnerEnumerator2 = (HaveInnerEnumerator)obj;
								if (HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<T>>(haveInnerEnumerator.item1, haveInnerEnumerator2.item1))
								{
									return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<U>>(haveInnerEnumerator.item2, haveInnerEnumerator2.item2);
								}
								return false;
							}
							}
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public sealed override bool Equals(object obj)
			{
				if (obj is CollectState<T, U> obj2)
				{
					return Equals(obj2);
				}
				return false;
			}
		}

		[Serializable]
		internal sealed class collect@556-3<T, TResult> : FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<TResult>>>
		{
			public FSharpFunc<T, IAsyncEnumerable<TResult>> f;

			public FSharpRef<CollectState<T, TResult>> state;

			public IAsyncEnumerator<TResult> x;

			public IAsyncEnumerator<T> e1;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@556-3(FSharpFunc<T, IAsyncEnumerable<TResult>> f, FSharpRef<CollectState<T, TResult>> state, IAsyncEnumerator<TResult> x, IAsyncEnumerator<T> e1)
			{
				((FSharpFunc<FSharpOption<FSharpOption<T>>, FSharpAsync<FSharpOption<FSharpAsync<FSharpOption<TResult>>>>>)(object)this)..ctor();
				this.f = f;
				this.state = state;
				this.x = x;
				this.e1 = e1;
			}

			public override FSharpAsync<FSharpOption<TResult>> Invoke(FSharpOption<T> _arg1)
			{
				if (_arg1 == null)
				{
					x.Dispose();
				}
				else
				{
					T value = _arg1.Value;
					IAsyncEnumerator<TResult> enumerator = ((FSharpFunc<T, IAsyncEnumerable<IAsyncEnumerable<TResult>>>)(object)f).Invoke(value).GetEnumerator();
					((FSharpRef<CollectState<CollectState<T, TResult>, ?>>)(object)state).contents = (CollectState<CollectState<T, TResult>, ?>)(object)CollectState<T, TResult>.NewHaveInnerEnumerator(e1, enumerator);
				}
				return x.MoveNext();
			}
		}

		[Serializable]
		internal sealed class collect@566-4<TResult, T> : FSharpFunc<FSharpOption<TResult>, FSharpAsync<FSharpOption<TResult>>>
		{
			public FSharpRef<CollectState<T, TResult>> state;

			public IAsyncEnumerator<TResult> x;

			public IAsyncEnumerator<TResult> e2;

			public IAsyncEnumerator<T> e1;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@566-4(FSharpRef<CollectState<T, TResult>> state, IAsyncEnumerator<TResult> x, IAsyncEnumerator<TResult> e2, IAsyncEnumerator<T> e1)
			{
				((FSharpFunc<FSharpOption<FSharpOption<TResult>>, FSharpAsync<FSharpOption<FSharpOption<TResult>>>>)(object)this)..ctor();
				this.state = state;
				this.x = x;
				this.e2 = e2;
				this.e1 = e1;
			}

			public override FSharpAsync<FSharpOption<TResult>> Invoke(FSharpOption<TResult> _arg2)
			{
				if (_arg2 != null)
				{
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<TResult>>(_arg2);
				}
				((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents = (CollectState<?, CollectState<T, TResult>>)(object)CollectState<T, TResult>.NewHaveInputEnumerator(e1);
				e2?.Dispose();
				return x.MoveNext();
			}
		}

		[Serializable]
		internal sealed class collect@548-2<TResult, T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<TResult>>>
		{
			public FSharpFunc<T, IAsyncEnumerable<TResult>> f;

			public FSharpRef<CollectState<T, TResult>> state;

			public IAsyncEnumerator<TResult> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@548-2(FSharpFunc<T, IAsyncEnumerable<TResult>> f, FSharpRef<CollectState<T, TResult>> state, IAsyncEnumerator<TResult> x)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.f = f;
				this.state = state;
				this.x = x;
			}

			public override FSharpAsync<FSharpOption<TResult>> Invoke(Unit unitVar)
			{
				CollectState<T, TResult> contents = ((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents;
				switch (contents.Tag)
				{
				default:
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<TResult>>((FSharpOption<TResult>)null);
				case 0:
				{
					CollectState<T, TResult>.NotStarted notStarted = (CollectState<T, TResult>.NotStarted)contents;
					IAsyncEnumerable<T> item3 = notStarted.item;
					IAsyncEnumerator<T> item2 = item3.GetEnumerator();
					((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents = (CollectState<?, CollectState<T, TResult>>)(object)CollectState<T, TResult>.NewHaveInputEnumerator(item2);
					return x.MoveNext();
				}
				case 1:
				{
					CollectState<T, TResult>.HaveInputEnumerator haveInputEnumerator = (CollectState<T, TResult>.HaveInputEnumerator)contents;
					IAsyncEnumerator<T> item2 = haveInputEnumerator.item;
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Bind<FSharpOption<T>, FSharpOption<TResult>>(item2.MoveNext(), (FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<TResult>>>)new collect@556-3<T, TResult>(f, state, x, item2));
				}
				case 2:
				{
					CollectState<T, TResult>.HaveInnerEnumerator haveInnerEnumerator = (CollectState<T, TResult>.HaveInnerEnumerator)contents;
					IAsyncEnumerator<TResult> item = haveInnerEnumerator.item2;
					IAsyncEnumerator<T> item2 = haveInnerEnumerator.item1;
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Bind<FSharpOption<TResult>, FSharpOption<TResult>>(item.MoveNext(), (FSharpFunc<FSharpOption<TResult>, FSharpAsync<FSharpOption<TResult>>>)new collect@566-4<TResult, T>(state, x, item, item2));
				}
				}
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class collect@546-1<TResult, T> : IAsyncEnumerator<TResult>
		{
			public FSharpFunc<T, IAsyncEnumerable<TResult>> f;

			public FSharpRef<CollectState<T, TResult>> state;

			public collect@546-1(FSharpFunc<T, IAsyncEnumerable<TResult>> f, FSharpRef<CollectState<T, TResult>> state)
			{
				this.f = f;
				this.state = state;
				base..ctor();
			}

			private FSharpAsync<FSharpOption<TResult>> FSharp-Control-IAsyncEnumerator`1-MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<TResult>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<TResult>>>)new collect@548-2<TResult, T>(f, state, this));
			}

			FSharpAsync<FSharpOption<TResult>> IAsyncEnumerator<TResult>.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerator`1-MoveNext
				return this.FSharp-Control-IAsyncEnumerator`1-MoveNext();
			}

			private void System-IDisposable-Dispose()
			{
				CollectState<T, TResult> contents = ((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents;
				switch (contents.Tag)
				{
				case 1:
				{
					CollectState<T, TResult>.HaveInputEnumerator haveInputEnumerator = (CollectState<T, TResult>.HaveInputEnumerator)contents;
					IAsyncEnumerator<T> item2 = haveInputEnumerator.item;
					((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents = (CollectState<?, CollectState<T, TResult>>)(object)CollectState<T, TResult>.Finished;
					item2?.Dispose();
					break;
				}
				case 2:
				{
					CollectState<T, TResult>.HaveInnerEnumerator haveInnerEnumerator = (CollectState<T, TResult>.HaveInnerEnumerator)contents;
					IAsyncEnumerator<TResult> item = haveInnerEnumerator.item2;
					IAsyncEnumerator<T> item2 = haveInnerEnumerator.item1;
					((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents = (CollectState<?, CollectState<T, TResult>>)(object)CollectState<T, TResult>.Finished;
					item?.Dispose();
					item2?.Dispose();
					break;
				}
				}
			}

			void IDisposable.Dispose()
			{
				//ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose
				this.System-IDisposable-Dispose();
			}
		}

		[Serializable]
		[SpecialName]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal sealed class collect@543<TResult, T> : IAsyncEnumerable<TResult>
		{
			public FSharpFunc<T, IAsyncEnumerable<TResult>> f;

			public IAsyncEnumerable<T> inp;

			public collect@543(FSharpFunc<T, IAsyncEnumerable<TResult>> f, IAsyncEnumerable<T> inp)
			{
				this.f = f;
				this.inp = inp;
				base..ctor();
			}

			private IAsyncEnumerator<TResult> FSharp-Control-IAsyncEnumerable`1-GetEnumerator()
			{
				FSharpRef<CollectState<T, TResult>> state = (FSharpRef<CollectState<T, TResult>>)(object)new FSharpRef<CollectState<?, CollectState<T, TResult>>>((CollectState<?, CollectState<T, TResult>>)(object)CollectState<T, TResult>.NewNotStarted(inp));
				return new collect@546-1<TResult, T>(f, state);
			}

			IAsyncEnumerator<TResult> IAsyncEnumerable<TResult>.GetEnumerator()
			{
				//ILSpy generated this explicit interface implementation from .override directive in FSharp-Control-IAsyncEnumerable`1-GetEnumerator
				return this.FSharp-Control-IAsyncEnumerable`1-GetEnumerator();
			}
		}

		[Serializable]
		[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
		[RequireQualifiedAccess]
		[DebuggerDisplay("{__DebugDisplay(),nq}")]
		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		internal class CollectSeqState<T, U> : IEquatable<CollectSeqState<T, U>>, IStructuralEquatable
		{
			internal static class Tags
			{
				public const int NotStarted = 0;

				public const int HaveInputEnumerator = 1;

				public const int HaveInnerEnumerator = 2;

				public const int Finished = 3;
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(CollectSeqState<, >.NotStarted@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class NotStarted : CollectSeqState<T, U>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IEnumerable<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal NotStarted(IEnumerable<T> item)
					: base(0)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(CollectSeqState<, >.HaveInputEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveInputEnumerator : CollectSeqState<T, U>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IEnumerator<T> item;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveInputEnumerator(IEnumerator<T> item)
					: base(1)
				{
					this.item = item;
				}
			}

			[Serializable]
			[SpecialName]
			[DebuggerTypeProxy(typeof(CollectSeqState<, >.HaveInnerEnumerator@DebugTypeProxy))]
			[DebuggerDisplay("{__DebugDisplay(),nq}")]
			internal class HaveInnerEnumerator : CollectSeqState<T, U>
			{
				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IEnumerator<T> item1;

				[DebuggerBrowsable(DebuggerBrowsableState.Never)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal readonly IAsyncEnumerator<U> item2;

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IEnumerator<T> Item1
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item1;
					}
				}

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal IAsyncEnumerator<U> Item2
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return item2;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				internal HaveInnerEnumerator(IEnumerator<T> item1, IAsyncEnumerator<U> item2)
					: base(2)
				{
					this.item1 = item1;
					this.item2 = item2;
				}
			}

			[SpecialName]
			internal class NotStarted@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IEnumerable<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public NotStarted@DebugTypeProxy(NotStarted obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveInputEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IEnumerator<T> Item
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveInputEnumerator@DebugTypeProxy(HaveInputEnumerator obj)
				{
					_obj = obj;
				}
			}

			[SpecialName]
			internal class HaveInnerEnumerator@DebugTypeProxy
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IEnumerator<T> Item1
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item1;
					}
				}

				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				[CompilerGenerated]
				[DebuggerNonUserCode]
				public IAsyncEnumerator<U> Item2
				{
					[CompilerGenerated]
					[DebuggerNonUserCode]
					get
					{
						return _obj.item2;
					}
				}

				[CompilerGenerated]
				[DebuggerNonUserCode]
				public HaveInnerEnumerator@DebugTypeProxy(HaveInnerEnumerator obj)
				{
					_obj = obj;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal int Tag
			{
				[DebuggerNonUserCode]
				get;
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsNotStarted
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 0;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveInputEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 1;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsHaveInnerEnumerator
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 2;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal static CollectSeqState<T, U> Finished
			{
				[CompilationMapping(/*Could not decode attribute arguments.*/)]
				get
				{
					return _unique_Finished;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			internal bool IsFinished
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return Tag == 3;
				}
			}

			static CollectSeqState()
			{
				_unique_Finished = new CollectSeqState<T, U>(3);
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal CollectSeqState(int _tag)
			{
				this._tag = _tag;
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static CollectSeqState<T, U> NewNotStarted(IEnumerable<T> item)
			{
				return new NotStarted(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static CollectSeqState<T, U> NewHaveInputEnumerator(IEnumerator<T> item)
			{
				return new HaveInputEnumerator(item);
			}

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			internal static CollectSeqState<T, U> NewHaveInnerEnumerator(IEnumerator<T> item1, IAsyncEnumerator<U> item2)
			{
				return new HaveInnerEnumerator(item1, item2);
			}

			[SpecialName]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal object __DebugDisplay()
			{
				return ((FSharpFunc<CollectSeqState<CollectSeqState<T, U>, string>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<CollectSeqState<T, U>, string>>((PrintfFormat<FSharpFunc<CollectSeqState<T, U>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<CollectSeqState<FSharpFunc<CollectSeqState<T, U>, string>, Unit>, string>, Unit, string, string, string>("%+0.8A"))).Invoke((CollectSeqState<CollectSeqState<T, U>, string>)(object)this);
			}

			[CompilerGenerated]
			public override string ToString()
			{
				return ((FSharpFunc<CollectSeqState<CollectSeqState<T, U>, string>, string>)(object)ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<CollectSeqState<T, U>, string>>((PrintfFormat<FSharpFunc<CollectSeqState<T, U>, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<CollectSeqState<FSharpFunc<CollectSeqState<T, U>, string>, Unit>, string>, Unit, string, string, CollectSeqState<FSharpFunc<CollectSeqState<T, U>, string>, Unit>>("%+A"))).Invoke((CollectSeqState<CollectSeqState<T, U>, string>)(object)this);
			}

			[CompilerGenerated]
			public virtual sealed int GetHashCode(IEqualityComparer comp)
			{
				if (this != null)
				{
					int num = 0;
					switch (Tag)
					{
					default:
						return _tag;
					case 0:
					{
						NotStarted notStarted = (NotStarted)this;
						num = 0;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IEnumerable<T>>(comp, notStarted.item) + ((num << 6) + (num >> 2)));
					}
					case 1:
					{
						HaveInputEnumerator haveInputEnumerator = (HaveInputEnumerator)this;
						num = 1;
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IEnumerator<T>>(comp, haveInputEnumerator.item) + ((num << 6) + (num >> 2)));
					}
					case 2:
					{
						HaveInnerEnumerator haveInnerEnumerator = (HaveInnerEnumerator)this;
						num = 2;
						num = -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IAsyncEnumerator<U>>(comp, haveInnerEnumerator.item2) + ((num << 6) + (num >> 2)));
						return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<IEnumerator<T>>(comp, haveInnerEnumerator.item1) + ((num << 6) + (num >> 2)));
					}
					}
				}
				return 0;
			}

			[CompilerGenerated]
			public sealed override int GetHashCode()
			{
				return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(object obj, IEqualityComparer comp)
			{
				if (this != null)
				{
					if (obj is CollectSeqState<T, U> collectSeqState)
					{
						int tag = _tag;
						int tag2 = collectSeqState._tag;
						if (tag == tag2)
						{
							switch (Tag)
							{
							default:
								return true;
							case 0:
							{
								NotStarted notStarted = (NotStarted)this;
								NotStarted notStarted2 = (NotStarted)collectSeqState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IEnumerable<T>>(comp, notStarted.item, notStarted2.item);
							}
							case 1:
							{
								HaveInputEnumerator haveInputEnumerator = (HaveInputEnumerator)this;
								HaveInputEnumerator haveInputEnumerator2 = (HaveInputEnumerator)collectSeqState;
								return HashCompare.GenericEqualityWithComparerIntrinsic<IEnumerator<T>>(comp, haveInputEnumerator.item, haveInputEnumerator2.item);
							}
							case 2:
							{
								HaveInnerEnumerator haveInnerEnumerator = (HaveInnerEnumerator)this;
								HaveInnerEnumerator haveInnerEnumerator2 = (HaveInnerEnumerator)collectSeqState;
								if (HashCompare.GenericEqualityWithComparerIntrinsic<IEnumerator<T>>(comp, haveInnerEnumerator.item1, haveInnerEnumerator2.item1))
								{
									return HashCompare.GenericEqualityWithComparerIntrinsic<IAsyncEnumerator<U>>(comp, haveInnerEnumerator.item2, haveInnerEnumerator2.item2);
								}
								return false;
							}
							}
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public virtual sealed bool Equals(CollectSeqState<T, U> obj)
			{
				if (this != null)
				{
					if (obj != null)
					{
						int tag = _tag;
						int tag2 = obj._tag;
						if (tag == tag2)
						{
							switch (Tag)
							{
							default:
								return true;
							case 0:
							{
								NotStarted notStarted = (NotStarted)this;
								NotStarted notStarted2 = (NotStarted)obj;
								return HashCompare.GenericEqualityERIntrinsic<IEnumerable<T>>(notStarted.item, notStarted2.item);
							}
							case 1:
							{
								HaveInputEnumerator haveInputEnumerator = (HaveInputEnumerator)this;
								HaveInputEnumerator haveInputEnumerator2 = (HaveInputEnumerator)obj;
								return HashCompare.GenericEqualityERIntrinsic<IEnumerator<T>>(haveInputEnumerator.item, haveInputEnumerator2.item);
							}
							case 2:
							{
								HaveInnerEnumerator haveInnerEnumerator = (HaveInnerEnumerator)this;
								HaveInnerEnumerator haveInnerEnumerator2 = (HaveInnerEnumerator)obj;
								if (HashCompare.GenericEqualityERIntrinsic<IEnumerator<T>>(haveInnerEnumerator.item1, haveInnerEnumerator2.item1))
								{
									return HashCompare.GenericEqualityERIntrinsic<IAsyncEnumerator<U>>(haveInnerEnumerator.item2, haveInnerEnumerator2.item2);
								}
								return false;
							}
							}
						}
						return false;
					}
					return false;
				}
				return obj == null;
			}

			[CompilerGenerated]
			public sealed override bool Equals(object obj)
			{
				if (obj is CollectSeqState<T, U> obj2)
				{
					return Equals(obj2);
				}
				return false;
			}
		}

		[Serializable]
		internal sealed class collectSeq@619-3<U, T> : FSharpFunc<FSharpOption<U>, FSharpAsync<FSharpOption<U>>>
		{
			public FSharpRef<CollectSeqState<T, U>> state;

			public IAsyncEnumerator<U> x;

			public IAsyncEnumerator<U> e2;

			public IEnumerator<T> e1;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collectSeq@619-3(FSharpRef<CollectSeqState<T, U>> state, IAsyncEnumerator<U> x, IAsyncEnumerator<U> e2, IEnumerator<T> e1)
			{
				((FSharpFunc<FSharpOption<FSharpOption<U>>, FSharpAsync<FSharpOption<FSharpOption<U>>>>)(object)this)..ctor();
				this.state = state;
				this.x = x;
				this.e2 = e2;
				this.e1 = e1;
			}

			public override FSharpAsync<FSharpOption<U>> Invoke(FSharpOption<U> _arg1)
			{
				if (_arg1 != null)
				{
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<U>>(_arg1);
				}
				((FSharpRef<CollectSeqState<?, CollectSeqState<T, U>>>)(object)state).contents = (CollectSeqState<?, CollectSeqState<T, U>>)(object)CollectSeqState<T, U>.NewHaveInputEnumerator(e1);
				e2?.Dispose();
				return x.MoveNext();
			}
		}

		[Serializable]
		internal sealed class collectSeq@603-2<U, T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<U>>>
		{
			public FSharpFunc<T, IAsyncEnumerable<U>> f;

			public FSharpRef<CollectSeqState<T, U>> state;

			public IAsyncEnumerator<U> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collectSeq@603-2(FSharpFunc<T, IAsyncEnumerable<U>> f, FSharpRef<CollectSeqState<T, U>> state, IAsyncEnumerator<U> x)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.f = f;
				this.state = state;
				this.x = x;
			}

			public override FSharpAsync<FSharpOption<U>> Invoke(Unit unitVar)
			{
				CollectSeqState<T, U> contents = ((FSharpRef<CollectSeqState<?, CollectSeqState<T, U>>>)(object)state).contents;
				switch (contents.Tag)
				{
				default:
					return ExtraTopLevelOperators.DefaultAsyncBuilder.Return<FSharpOption<U>>((FSharpOption<U>)null);
				case 0:
				{
					CollectSeqState<T, U>.NotStarted notStarted = (CollectSeqState<T, U>.NotStarted)contents;
					IEnumerable<T> item3 = notStarted.item;
					IEnumerator<T> item2 = item3.GetEnumerator();
					((FSharpRef<CollectSeqState<?, CollectSeqState<T, U>>>)(object)state).contents = (CollectSeqState<?, CollectSeqState<T, U>>)(object)CollectSeqS