using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.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: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Tomas Petricek;Don Syme;Lev Gorodinski")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2017")]
[assembly: AssemblyDescription("Asynchronous sequences for F#")]
[assembly: AssemblyFileVersion("3.2.1.0")]
[assembly: AssemblyInformationalVersion("3.2.1")]
[assembly: AssemblyProduct("FSharp.Control.AsyncSeq")]
[assembly: AssemblyTitle("FSharp.Control.AsyncSeq")]
[assembly: AssemblyVersion("3.2.1.0")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/fsprojects/FSharp.Control.AsyncSeq")]
[assembly: InternalsVisibleTo("FSharp.Control.AsyncSeq.Tests")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("3.2.1.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>> @_instance;
			@_instance = $AsyncSeq.MapAsync@299<a>.@_instance;
			FSharpFunc<FSharpAsync<a>, FSharpAsync<FSharpOption<a>>> func = new $AsyncSeq.MapAsync@299-1<a>(@_instance);
			return ChooseAsync(new $AsyncSeq.MapAsync@299-2<T, a>(f, func));
		}

		public virtual FSharpAsync<Unit> IterAsync(FSharpFunc<T, FSharpAsync<Unit>> f)
		{
			return FoldAsync<Unit>((FSharpFunc<Unit, FSharpFunc<T, FSharpAsync<Unit>>>)(object)new $AsyncSeq.IterAsync@301<T>(f), null);
		}
	}
	[RequireQualifiedAccess]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public static class Seq
	{
		public static IEnumerable<T> ofAsyncSeq<T>(IAsyncEnumerable<T> source)
		{
			return AsyncSeq.toBlockingSeq(source);
		}
	}
	[RequireQualifiedAccess]
	[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@1817-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@375-4<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal empty@375-4(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

		[Serializable]
		internal sealed class empty@375-3<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			internal static readonly empty@375-3<T> @_instance = new empty@375-3<T>();

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal empty@375-3()
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar)
			{
				FSharpOption<T> value = null;
				return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new empty@375-4<T>(value));
			}
		}

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

			void IDisposable.Dispose()
			{
			}
		}

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

		[Serializable]
		internal sealed class singleton@385-3<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal singleton@385-3(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

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

			public FSharpRef<int> state;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal singleton@383-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;
				FSharpOption<T> value = ((!flag) ? null : FSharpOption<T>.Some(v));
				return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new singleton@385-3<T>(value));
			}
		}

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

			public FSharpRef<int> state;

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

			FSharpAsync<FSharpOption<T>> IAsyncEnumerator<T>.MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new singleton@383-2<T>(v, state));
			}

			void IDisposable.Dispose()
			{
			}
		}

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

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

			IAsyncEnumerator<T> IAsyncEnumerable<T>.GetEnumerator()
			{
				FSharpRef<int> state = new FSharpRef<int>(0);
				return new singleton@382-1<T>(v, state);
			}
		}

		[Serializable]
		internal sealed class bindAsync@403-4<U> : FSharpFunc<AsyncActivation<AsyncGenerator.Step<U>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public AsyncGenerator.Step<U> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal bindAsync@403-4(AsyncGenerator.Step<U> value)
			{
				((FSharpFunc<AsyncActivation<AsyncGenerator.Step<AsyncActivation<AsyncGenerator.Step<U>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<AsyncGenerator.Step<U>> ctxt)
			{
				return ((AsyncActivation<AsyncGenerator.Step<AsyncGenerator.Step<U>>>*)(&ctxt))->OnSuccess((AsyncGenerator.Step<AsyncGenerator.Step<U>>)(object)value);
			}
		}

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal bindAsync@400-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());
				AsyncGenerator.Step<U> value = AsyncGenerator.Step<U>.NewGoto(item);
				return AsyncPrimitives.MakeAsync<AsyncGenerator.Step<U>>((FSharpFunc<AsyncActivation<AsyncGenerator.Step<U>>, AsyncReturn>)new bindAsync@403-4<U>(value));
			}
		}

		[Serializable]
		internal sealed class bindAsync@399-5<U, T> : FSharpFunc<AsyncActivation<AsyncGenerator.Step<U>>, AsyncReturn>
		{
			public FSharpAsync<T> inp;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<T, FSharpAsync<AsyncGenerator.Step<U>>> binder;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal bindAsync@399-5(FSharpAsync<T> inp, FSharpFunc<T, FSharpAsync<AsyncGenerator.Step<U>>> binder)
			{
				((FSharpFunc<AsyncActivation<AsyncGenerator.Step<AsyncActivation<AsyncGenerator.Step<U>>>>, AsyncReturn>)(object)this)..ctor();
				this.inp = inp;
				this.binder = binder;
			}

			public override AsyncReturn Invoke(AsyncActivation<AsyncGenerator.Step<U>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<AsyncGenerator.Step<U>, T>(ctxt, inp, binder);
			}
		}

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

			public FSharpAsync<T> inp;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal bindAsync@399-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)
			{
				FSharpFunc<T, FSharpAsync<AsyncGenerator.Step<U>>> binder = new bindAsync@400-3<T, U>(f);
				return AsyncPrimitives.MakeAsync<AsyncGenerator.Step<U>>((FSharpFunc<AsyncActivation<AsyncGenerator.Step<U>>, AsyncReturn>)new bindAsync@399-5<U, T>(inp, binder));
			}
		}

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

			public FSharpAsync<T> inp;

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

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

			FSharpOption<FSharpFunc<Unit, Unit>> AsyncGenerator.AsyncGenerator<U>.get_Disposer()
			{
				return null;
			}
		}

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

			public FSharpAsync<T> inp;

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

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

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

			internal IAsyncEnumerable<a> Return<a>()
			{
				return empty<a>();
			}

			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@430<T>(guard, body, fix);
				fix = LazyExtensions.Create<IAsyncEnumerable<T>>(val);
				((While@430<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@721<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@430-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@430-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@430<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@430(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@430-1<T>(guard, body, fix));
			}
		}

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@442-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@445-5<T> : FSharpFunc<FSharpOption<T>, IAsyncEnumerable<T>>
		{
			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@445-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@444-4<T> : FSharpFunc<Unit, IAsyncEnumerable<T>>
		{
			public IAsyncEnumerator<T> ie;

			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@444-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@445-5<T>(b), ie.MoveNext());
			}
		}

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

			public FSharpRef<FSharpOption<T>> b;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@443-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@444-4<T>(ie, b)));
			}
		}

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal emitEnumerator@441-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@442-2<T>(b), AsyncGenerator.delay(new emitEnumerator@443-3<T>(ie, b)));
			}
		}

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

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

			public override IAsyncEnumerable<T> Invoke(Unit unitVar)
			{
				return bindAsync(new emitEnumerator@441-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@506-3<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@506-3(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

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

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@466-4(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@465-6<T> : FSharpFunc<Exception, FSharpOption<FSharpAsync<Unit>>>
		{
			public FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res;

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

			public override FSharpOption<FSharpAsync<Unit>> Invoke(Exception edi)
			{
				return catchFunction@1<T>(res, edi);
			}
		}

		[Serializable]
		internal sealed class tryWith@465-5<T> : FSharpFunc<AsyncActivation<Unit>, AsyncReturn>
		{
			public FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<Unit> computation;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@465-5(FSharpRef<FSharpChoice<IAsyncEnumerator<T>, Exception>> res, FSharpAsync<Unit> computation)
			{
				this.res = res;
				this.computation = computation;
			}

			public override AsyncReturn Invoke(AsyncActivation<Unit> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.TryWith<Unit>(ctxt, computation, (FSharpFunc<Exception, FSharpOption<FSharpAsync<Unit>>>)new tryWith@465-6<T>(res));
			}
		}

		[Serializable]
		internal sealed class tryWith@469-7<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@469-7(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@465-8<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<T>> computation2;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@465-8(FSharpAsync<FSharpOption<T>> computation2)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.computation2 = computation2;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar0)
			{
				return computation2;
			}
		}

		[Serializable]
		internal sealed class tryWith@465-9<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<Unit> computation1;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>> part2;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@465-9(FSharpAsync<Unit> computation1, FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>> part2)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.computation1 = computation1;
				this.part2 = part2;
			}

			public override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<FSharpOption<T>, Unit>(ctxt, computation1, part2);
			}
		}

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@484-11(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@483-12<T> : FSharpFunc<AsyncActivation<Unit>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<T>> computation;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<FSharpOption<T>, FSharpAsync<Unit>> binder;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@483-12(FSharpAsync<FSharpOption<T>> computation, FSharpFunc<FSharpOption<T>, FSharpAsync<Unit>> binder)
			{
				this.computation = computation;
				this.binder = binder;
			}

			public override AsyncReturn Invoke(AsyncActivation<Unit> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<Unit, FSharpOption<T>>(ctxt, computation, binder);
			}
		}

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

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

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

			public override FSharpAsync<Unit> Invoke(Unit unitVar)
			{
				FSharpAsync<FSharpOption<T>> computation = e.MoveNext();
				FSharpFunc<FSharpOption<T>, FSharpAsync<Unit>> binder = new tryWith@484-11<T>(res);
				return AsyncPrimitives.MakeAsync<Unit>((FSharpFunc<AsyncActivation<Unit>, AsyncReturn>)new tryWith@483-12<T>(computation, binder));
			}
		}

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

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

			public override FSharpOption<FSharpAsync<Unit>> Invoke(Exception edi)
			{
				return catchFunction@1-1<T>(res, edi);
			}
		}

		[Serializable]
		internal sealed class tryWith@482-13<T> : FSharpFunc<AsyncActivation<Unit>, AsyncReturn>
		{
			public FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<Unit> computation;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@482-13(FSharpRef<FSharpChoice<FSharpOption<T>, Exception>> res, FSharpAsync<Unit> computation)
			{
				this.res = res;
				this.computation = computation;
			}

			public override AsyncReturn Invoke(AsyncActivation<Unit> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.TryWith<Unit>(ctxt, computation, (FSharpFunc<Exception, FSharpOption<FSharpAsync<Unit>>>)new tryWith@482-14<T>(res));
			}
		}

		[Serializable]
		internal sealed class tryWith@489-16<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@489-16(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

		[Serializable]
		internal sealed class tryWith@487-15<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@487-15(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;
				if (item2 == null)
				{
					x.Dispose();
				}
				FSharpOption<T> value = item2;
				return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryWith@489-16<T>(value));
			}
		}

		[Serializable]
		internal sealed class tryWith@482-17<T> : FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<T>> computation2;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@482-17(FSharpAsync<FSharpOption<T>> computation2)
			{
				((FSharpFunc<Unit, FSharpAsync<FSharpOption<Unit>>>)(object)this)..ctor();
				this.computation2 = computation2;
			}

			public override FSharpAsync<FSharpOption<T>> Invoke(Unit unitVar0)
			{
				return computation2;
			}
		}

		[Serializable]
		internal sealed class tryWith@482-18<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<Unit> computation1;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>> part2;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@482-18(FSharpAsync<Unit> computation1, FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>> part2)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.computation1 = computation1;
				this.part2 = part2;
			}

			public override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<FSharpOption<T>, Unit>(ctxt, computation1, part2);
			}
		}

		[Serializable]
		internal sealed class tryWith@502-20<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@502-20(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@502-19(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)
			{
				object obj;
				if (_arg4 == null)
				{
					x.Dispose();
					obj = null;
				}
				else
				{
					obj = _arg4;
				}
				FSharpOption<T> value = (FSharpOption<T>)obj;
				return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryWith@502-20<T>(value));
			}
		}

		[Serializable]
		internal sealed class tryWith@501-21<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<T>> computation;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>> binder;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryWith@501-21(FSharpAsync<FSharpOption<T>> computation, FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>> binder)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.computation = computation;
				this.binder = binder;
			}

			public override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<FSharpOption<T>, FSharpOption<T>>(ctxt, computation, binder);
			}
		}

		[Serializable]
		internal sealed class tryWith@462-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@462-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:
				{
					FSharpOption<T> value = null;
					return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryWith@506-3<T>(value));
				}
				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);
					FSharpAsync<Unit> computation2 = ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)new tryWith@466-4<T>(item2, res2));
					FSharpAsync<Unit> computation3 = AsyncPrimitives.MakeAsync<Unit>((FSharpFunc<AsyncActivation<Unit>, AsyncReturn>)new tryWith@465-5<T>(res2, computation2));
					FSharpAsync<FSharpOption<T>> computation = ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryWith@469-7<T>(handler, state, x, res2));
					FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>> part = new tryWith@465-8<T>(computation);
					return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryWith@465-9<T>(computation3, part));
				}
				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);
					FSharpAsync<Unit> computation2 = ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)new tryWith@483-10<T>(item, res));
					FSharpAsync<Unit> computation3 = AsyncPrimitives.MakeAsync<Unit>((FSharpFunc<AsyncActivation<Unit>, AsyncReturn>)new tryWith@482-13<T>(res, computation2));
					FSharpAsync<FSharpOption<T>> computation = ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryWith@487-15<T>(handler, state, x, res));
					FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>> part = new tryWith@482-17<T>(computation);
					return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryWith@482-18<T>(computation3, part));
				}
				case 2:
				{
					TryWithState<T>.HaveHandlerEnumerator haveHandlerEnumerator = (TryWithState<T>.HaveHandlerEnumerator)contents;
					IAsyncEnumerator<T> item = haveHandlerEnumerator.item;
					FSharpAsync<FSharpOption<T>> computation = item.MoveNext();
					FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>> binder = new tryWith@502-19<T>(x);
					return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryWith@501-21<T>(computation, binder));
				}
				}
			}
		}

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

			public FSharpRef<TryWithState<T>> state;

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

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

			void 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;
				IDisposable disposable = item;
				try
				{
					disposable.Dispose();
					Unit val = null;
				}
				catch (object obj)
				{
					Exception ex = (Exception)obj;
					Unit val = null;
				}
			}
		}

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

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

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

			IAsyncEnumerator<T> IAsyncEnumerable<T>.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@460-1<T>(handler, state);
			}
		}

		[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@543-3<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@543-3(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

		[Serializable]
		internal sealed class tryFinally@537-5<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<T> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@537-5(FSharpOption<T> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<T>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<T>>)(object)value);
			}
		}

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

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@537-4(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)
			{
				if (_arg1 == null)
				{
					x.Dispose();
				}
				return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryFinally@537-5<T>(_arg1));
			}
		}

		[Serializable]
		internal sealed class tryFinally@536-6<T> : FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<T>> computation;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>> binder;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@536-6(FSharpAsync<FSharpOption<T>> computation, FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>> binder)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<T>>>>, AsyncReturn>)(object)this)..ctor();
				this.computation = computation;
				this.binder = binder;
			}

			public override AsyncReturn Invoke(AsyncActivation<FSharpOption<T>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<FSharpOption<T>, FSharpOption<T>>(ctxt, computation, binder);
			}
		}

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

			public IAsyncEnumerator<T> x;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal tryFinally@529-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))
					{
						FSharpOption<T> value = null;
						return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryFinally@543-3<T>(value));
					}
					TryFinallyState<T>.HaveBodyEnumerator haveBodyEnumerator = (TryFinallyState<T>.HaveBodyEnumerator)contents;
					item = haveBodyEnumerator.item;
					FSharpAsync<FSharpOption<T>> computation = item.MoveNext();
					FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<T>>> binder = new tryFinally@537-4<T>(x);
					return AsyncPrimitives.MakeAsync<FSharpOption<T>>((FSharpFunc<AsyncActivation<FSharpOption<T>>, AsyncReturn>)new tryFinally@536-6<T>(computation, binder));
				}
				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@527-1<T> : IAsyncEnumerator<T>
		{
			public FSharpFunc<Unit, Unit> compensation;

			public FSharpRef<TryFinallyState<T>> state;

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

			FSharpAsync<FSharpOption<T>> IAsyncEnumerator<T>.MoveNext()
			{
				return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<FSharpOption<T>>((FSharpFunc<Unit, FSharpAsync<FSharpOption<T>>>)new tryFinally@529-2<T>(state, this));
			}

			void 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;
					IDisposable disposable = item;
					try
					{
						disposable.Dispose();
						Unit val = null;
					}
					catch (object obj)
					{
						Exception ex = (Exception)obj;
						Unit val = null;
					}
					compensation.Invoke((Unit)null);
				}
			}
		}

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

			public FSharpFunc<Unit, Unit> compensation;

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

			IAsyncEnumerator<T> IAsyncEnumerable<T>.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@527-1<T>(compensation, state);
			}
		}

		[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@592-3<TResult> : FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpOption<TResult> value;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@592-3(FSharpOption<TResult> value)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<TResult>>>>, AsyncReturn>)(object)this)..ctor();
				this.value = value;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<TResult>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<TResult>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<TResult>>)(object)value);
			}
		}

		[Serializable]
		internal sealed class collect@574-4<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@574-4(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@573-5<TResult, T> : FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<T>> computation;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<TResult>>> binder;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@573-5(FSharpAsync<FSharpOption<T>> computation, FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<TResult>>> binder)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<TResult>>>>, AsyncReturn>)(object)this)..ctor();
				this.computation = computation;
				this.binder = binder;
			}

			public override AsyncReturn Invoke(AsyncActivation<FSharpOption<TResult>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<FSharpOption<TResult>, FSharpOption<T>>(ctxt, computation, binder);
			}
		}

		[Serializable]
		internal sealed class collect@590-7<TResult> : FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@590-7(FSharpOption<TResult> _arg2)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<TResult>>>>, AsyncReturn>)(object)this)..ctor();
				this._arg2 = _arg2;
			}

			public unsafe override AsyncReturn Invoke(AsyncActivation<FSharpOption<TResult>> ctxt)
			{
				return ((AsyncActivation<FSharpOption<FSharpOption<TResult>>>*)(&ctxt))->OnSuccess((FSharpOption<FSharpOption<TResult>>)(object)_arg2);
			}
		}

		[Serializable]
		internal sealed class collect@584-6<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@584-6(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 AsyncPrimitives.MakeAsync<FSharpOption<TResult>>((FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>)new collect@590-7<TResult>(_arg2));
				}
				((FSharpRef<CollectState<?, CollectState<T, TResult>>>)(object)state).contents = (CollectState<?, CollectState<T, TResult>>)(object)CollectState<T, TResult>.NewHaveInputEnumerator(e1);
				IDisposable disposable = e2;
				try
				{
					disposable.Dispose();
					Unit val = null;
				}
				catch (object obj)
				{
					Exception ex = (Exception)obj;
					Unit val = null;
				}
				return x.MoveNext();
			}
		}

		[Serializable]
		internal sealed class collect@583-8<TResult> : FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpAsync<FSharpOption<TResult>> computation;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public FSharpFunc<FSharpOption<TResult>, FSharpAsync<FSharpOption<TResult>>> binder;

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal collect@583-8(FSharpAsync<FSharpOption<TResult>> computation, FSharpFunc<FSharpOption<TResult>, FSharpAsync<FSharpOption<TResult>>> binder)
			{
				((FSharpFunc<AsyncActivation<FSharpOption<AsyncActivation<FSharpOption<TResult>>>>, AsyncReturn>)(object)this)..ctor();
				this.computation = computation;
				this.binder = binder;
			}

			public override AsyncReturn Invoke(AsyncActivation<FSharpOption<TResult>> ctxt)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return AsyncPrimitives.Bind<FSharpOption<TResult>, FSharpOption<TResult>>(ctxt, computation, binder);
			}
		}

		[Serializable]
		internal sealed class collect@566-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@566-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:
				{
					FSharpOption<TResult> value = null;
					return AsyncPrimitives.MakeAsync<FSharpOption<TResult>>((FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>)new collect@592-3<TResult>(value));
				}
				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;
					FSharpAsync<FSharpOption<T>> computation2 = item2.MoveNext();
					FSharpFunc<FSharpOption<T>, FSharpAsync<FSharpOption<TResult>>> binder2 = new collect@574-4<T, TResult>(f, state, x, item2);
					return AsyncPrimitives.MakeAsync<FSharpOption<TResult>>((FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>)new collect@573-5<TResult, T>(computation2, binder2));
				}
				case 2:
				{
					CollectState<T, TResult>.HaveInnerEnumerator haveInnerEnumerator = (CollectState<T, TResult>.HaveInnerEnumerator)contents;
					IAsyncEnumerator<TResult> item = haveInnerEnumerator.item2;
					IAsyncEnumerator<T> item2 = haveInnerEnumerator.item1;
					FSharpAsync<FSharpOption<TResult>> computation = item.MoveNext();
					FSharpFunc<FSharpOption<TResult>, FSharpAsync<FSharpOption<TResult>>> binder = new collect@584-6<TResult, T>(state, x, item, item2);
					return AsyncPrimitives.MakeAsync<FSharpOption<TResult>>((FSharpFunc<AsyncActivation<FSharpOption<TResult>>, AsyncReturn>)new collect@583-8<TResult>(computation, binder));
				}
				}
			}
		}

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

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

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

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

			void 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;
					IDisposable disposable = item2;
					try
					{
						disposable.Dispose();
						Unit val = null;
						break;
					}
					catch (object obj3)
					{
						Exception ex = (Exception)obj3;
						Unit val = null;
						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;
					IDisposable