using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using <StartupCode$FSharp-Core>;
using Microsoft.FSharp.Collections;
using Microsoft.FSharp.Control;
using Microsoft.FSharp.Core;
using Microsoft.FSharp.Core.CompilerServices;
using Microsoft.FSharp.Linq;
using Microsoft.FSharp.Linq.RuntimeHelpers;
using Microsoft.FSharp.Primitives.Basics;
using Microsoft.FSharp.Quotations;
using Microsoft.FSharp.Reflection;
using Microsoft.FSharp.Text.StructuredPrintfImpl;

[assembly: FSharpInterfaceDataVersion(2, 0, 0)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyFileVersion("8.1.23.52306")]
[assembly: AssemblyInformationalVersion("8.0.100-beta.23523.6+f41fe153f68dd6b20cf4f91de9ea1e55fc09bb20")]
[assembly: AssemblyProduct("FSharp.Core")]
[assembly: AssemblyTitle("FSharp.Core")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/fsharp")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: ComVisible(false)]
[assembly: CLSCompliant(true)]
[assembly: SecurityTransparent]
[assembly: AutoOpen("Microsoft.FSharp")]
[assembly: AutoOpen("Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators")]
[assembly: AutoOpen("Microsoft.FSharp.Core")]
[assembly: AutoOpen("Microsoft.FSharp.Collections")]
[assembly: AutoOpen("Microsoft.FSharp.Control")]
[assembly: AutoOpen("Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority")]
[assembly: AutoOpen("Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority")]
[assembly: AutoOpen("Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority")]
[assembly: AutoOpen("Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority")]
[assembly: AutoOpen("Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default)]
[assembly: AssemblyVersion("8.0.0.0")]
[assembly: TypeForwardedTo(typeof(AggregateException))]
[assembly: TypeForwardedTo(typeof(IStructuralComparable))]
[assembly: TypeForwardedTo(typeof(IStructuralEquatable))]
[assembly: TypeForwardedTo(typeof(IObservable<>))]
[assembly: TypeForwardedTo(typeof(IObserver<>))]
[assembly: TypeForwardedTo(typeof(Lazy<>))]
[assembly: TypeForwardedTo(typeof(BigInteger))]
[assembly: TypeForwardedTo(typeof(CancellationToken))]
[assembly: TypeForwardedTo(typeof(CancellationTokenRegistration))]
[assembly: TypeForwardedTo(typeof(CancellationTokenSource))]
[assembly: TypeForwardedTo(typeof(Tuple))]
[assembly: TypeForwardedTo(typeof(Tuple<>))]
[assembly: TypeForwardedTo(typeof(Tuple<, >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , , , , >))]
namespace Microsoft.FSharp.Core
{
	[Serializable]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class Unit : IComparable
	{
		internal Unit()
		{
		}

		public override int GetHashCode()
		{
			return 0;
		}

		public override bool Equals(object obj)
		{
			if (obj != null)
			{
				if (LanguagePrimitives.IntrinsicFunctions.TypeTestGeneric<Unit>(obj))
				{
					return true;
				}
				return false;
			}
			return true;
		}

		virtual int IComparable.CompareTo(object _obj)
		{
			return 0;
		}
	}
	[Serializable]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public enum SourceConstructFlags
	{
		None = 0,
		SumType = 1,
		RecordType = 2,
		ObjectType = 3,
		Field = 4,
		Exception = 5,
		Closure = 6,
		Module = 7,
		UnionCase = 8,
		Value = 9,
		KindMask = 31,
		NonPublicRepresentation = 32
	}
	[Serializable]
	[Flags]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public enum CompilationRepresentationFlags
	{
		None = 0,
		Static = 1,
		Instance = 2,
		ModuleSuffix = 4,
		UseNullAsTrueValue = 8,
		Event = 0x10
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class SealedAttribute : Attribute
	{
		internal bool value;

		public bool Value => value;

		public SealedAttribute(bool value)
		{
			this.value = value;
		}

		public SealedAttribute()
			: this(value: true)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class AbstractClassAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.GenericParameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class EqualityConditionalOnAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.GenericParameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class ComparisonConditionalOnAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class AllowNullLiteralAttribute : Attribute
	{
		internal bool value;

		public bool Value => value;

		public AllowNullLiteralAttribute(bool value)
		{
			this.value = value;
		}

		public AllowNullLiteralAttribute()
			: this(value: true)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class VolatileFieldAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class DefaultAugmentationAttribute : Attribute
	{
		internal bool value;

		public bool Value => value;

		public DefaultAugmentationAttribute(bool value)
		{
			this.value = value;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CLIEventAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CLIMutableAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class AutoSerializableAttribute : Attribute
	{
		internal bool value;

		public bool Value => value;

		public AutoSerializableAttribute(bool value)
		{
			this.value = value;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Field, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class DefaultValueAttribute : Attribute
	{
		internal bool check;

		public bool Check => check;

		public DefaultValueAttribute(bool check)
		{
			this.check = check;
		}

		public DefaultValueAttribute()
			: this(check: true)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class EntryPointAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class ReferenceEqualityAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class StructuralComparisonAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class StructuralEqualityAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class NoEqualityAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CustomEqualityAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CustomComparisonAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class NoComparisonAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class ReflectedDefinitionAttribute : Attribute
	{
		internal bool includeValue;

		public bool IncludeValue => includeValue;

		public ReflectedDefinitionAttribute(bool includeValue)
		{
			this.includeValue = includeValue;
		}

		public ReflectedDefinitionAttribute()
			: this(includeValue: false)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CompiledNameAttribute : Attribute
	{
		internal string compiledName;

		public string CompiledName => compiledName;

		public CompiledNameAttribute(string compiledName)
		{
			this.compiledName = compiledName;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Struct | AttributeTargets.ReturnValue, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class StructAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class MeasureAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class MeasureAnnotatedAbbreviationAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Interface, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class InterfaceAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class ClassAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class LiteralAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class FSharpInterfaceDataVersionAttribute : Attribute
	{
		internal int release;

		internal int minor;

		internal int major;

		public int Major => major;

		public int Minor => minor;

		public int Release => release;

		public FSharpInterfaceDataVersionAttribute(int major, int minor, int release)
		{
			this.major = major;
			this.minor = minor;
			this.release = release;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CompilationMappingAttribute : Attribute
	{
		internal int variantNumber;

		internal Type[] typeDefinitions;

		internal SourceConstructFlags sourceConstructFlags;

		internal int sequenceNumber;

		internal string resourceName;

		public SourceConstructFlags SourceConstructFlags => sourceConstructFlags;

		public int SequenceNumber => sequenceNumber;

		public int VariantNumber => variantNumber;

		public Type[] TypeDefinitions => typeDefinitions;

		public string ResourceName => resourceName;

		internal CompilationMappingAttribute(SourceConstructFlags sourceConstructFlags, int variantNumber, int sequenceNumber, string resourceName, Type[] typeDefinitions)
		{
			this.sourceConstructFlags = sourceConstructFlags;
			this.variantNumber = variantNumber;
			this.sequenceNumber = sequenceNumber;
			this.resourceName = resourceName;
			this.typeDefinitions = typeDefinitions;
		}

		public CompilationMappingAttribute(SourceConstructFlags sourceConstructFlags)
			: this(sourceConstructFlags, 0, 0)
		{
		}

		public CompilationMappingAttribute(SourceConstructFlags sourceConstructFlags, int sequenceNumber)
			: this(sourceConstructFlags, 0, sequenceNumber)
		{
		}

		public CompilationMappingAttribute(SourceConstructFlags sourceConstructFlags, int variantNumber, int sequenceNumber)
			: this(sourceConstructFlags, variantNumber, sequenceNumber, null, null)
		{
		}

		public CompilationMappingAttribute(string resourceName, Type[] typeDefinitions)
			: this(SourceConstructFlags.None, 0, 0, resourceName, typeDefinitions)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CompilationSourceNameAttribute : Attribute
	{
		internal string sourceName;

		public string SourceName => sourceName;

		public CompilationSourceNameAttribute(string sourceName)
		{
			this.sourceName = sourceName;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CompilationRepresentationAttribute : Attribute
	{
		internal CompilationRepresentationFlags flags;

		public CompilationRepresentationFlags Flags => flags;

		public CompilationRepresentationAttribute(CompilationRepresentationFlags flags)
		{
			this.flags = flags;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class ExperimentalAttribute : Attribute
	{
		internal string message;

		public string Message => message;

		public ExperimentalAttribute(string message)
		{
			this.message = message;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class InlineIfLambdaAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CompilationArgumentCountsAttribute : Attribute
	{
		internal int[] counts;

		public IEnumerable<int> Counts => (IEnumerable<int>)counts.Clone();

		public CompilationArgumentCountsAttribute(int[] counts)
		{
			this.counts = counts;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CustomOperationAttribute : Attribute
	{
		internal string name;

		internal bool isBinary;

		internal bool allowInto;

		internal bool isJoin;

		internal bool isGroupJoin;

		internal bool maintainsVarSpace;

		internal bool maintainsVarSpaceWithBind;

		internal string joinOnWord;

		public string Name => name;

		public bool AllowIntoPattern
		{
			get
			{
				return allowInto;
			}
			set
			{
				allowInto = value;
			}
		}

		public bool IsLikeZip
		{
			get
			{
				return isBinary;
			}
			set
			{
				isBinary = value;
			}
		}

		public bool IsLikeJoin
		{
			get
			{
				return isJoin;
			}
			set
			{
				isJoin = value;
			}
		}

		public bool IsLikeGroupJoin
		{
			get
			{
				return isGroupJoin;
			}
			set
			{
				isGroupJoin = value;
			}
		}

		public string JoinConditionWord
		{
			get
			{
				return joinOnWord;
			}
			set
			{
				joinOnWord = value;
			}
		}

		public bool MaintainsVariableSpace
		{
			get
			{
				return maintainsVarSpace;
			}
			set
			{
				maintainsVarSpace = value;
			}
		}

		public bool MaintainsVariableSpaceUsingBind
		{
			get
			{
				return maintainsVarSpaceWithBind;
			}
			set
			{
				maintainsVarSpaceWithBind = value;
			}
		}

		public CustomOperationAttribute(string name)
		{
			this.name = name;
			isBinary = false;
			allowInto = false;
			isJoin = false;
			isGroupJoin = false;
			maintainsVarSpace = false;
			maintainsVarSpaceWithBind = false;
			joinOnWord = "";
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class ProjectionParameterAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class StructuredFormatDisplayAttribute : Attribute
	{
		internal string value;

		public string Value => value;

		public StructuredFormatDisplayAttribute(string value)
		{
			this.value = value;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class CompilerMessageAttribute : Attribute
	{
		internal int messageNumber;

		internal string message;

		internal bool isError;

		internal bool isHidden;

		public string Message => message;

		public int MessageNumber => messageNumber;

		public bool IsError
		{
			get
			{
				return isError;
			}
			set
			{
				isError = value;
			}
		}

		public bool IsHidden
		{
			get
			{
				return isHidden;
			}
			set
			{
				isHidden = value;
			}
		}

		public CompilerMessageAttribute(string message, int messageNumber)
		{
			this.message = message;
			this.messageNumber = messageNumber;
			isError = false;
			isHidden = false;
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class UnverifiableAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class NoDynamicInvocationAttribute : Attribute
	{
		internal bool isLegacy;

		internal bool IsLegacy => isLegacy;

		internal NoDynamicInvocationAttribute(bool isLegacy)
		{
			this.isLegacy = isLegacy;
		}

		public NoDynamicInvocationAttribute()
			: this(isLegacy: false)
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class OptionalArgumentAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class GeneralizableValueAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class RequiresExplicitTypeArgumentsAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class RequireQualifiedAccessAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class AutoOpenAttribute : Attribute
	{
		internal string path;

		public string Path => path;

		public AutoOpenAttribute(string path)
		{
			this.path = path;
		}

		public AutoOpenAttribute()
			: this("")
		{
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	internal sealed class ValueAsStaticPropertyAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class NoCompilerInliningAttribute : Attribute
	{
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Sealed]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	public sealed class TailCallAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[Serializable]
	[Flags]
	[RequireQualifiedAccess]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	internal enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		Interfaces = 0x2000,
		All = -1
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	[CompilationMapping(SourceConstructFlags.ObjectType)]
	internal class DynamicallyAccessedMembersAttribute : Attribute
	{
		internal DynamicallyAccessedMemberTypes MemberTypes@;

		internal DynamicallyAccessedMemberTypes MemberTypes
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return MemberTypes@;
			}
			[CompilerGenerated]
			[DebuggerNonUserCode]
			set
			{
				MemberTypes@ = value;
			}
		}

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes@ = memberTypes;
		}

		internal void DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes@ = memberTypes;
		}
	}
}
namespace Microsoft.FSharp.Core
{
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[StructuralEquality]
	[StructuralComparison]
	[CompiledName("FSharpChoice`2")]
	[CompilationMapping(SourceConstructFlags.SumType)]
	public abstract class FSharpChoice<T1, T2> : IEquatable<FSharpChoice<T1, T2>>, IStructuralEquatable, IComparable<FSharpChoice<T1, T2>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Choice1Of2 = 0;

			public const int Choice2Of2 = 1;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, >.Choice1Of2@DebugTypeProxy))]
		public class Choice1Of2 : FSharpChoice<T1, T2>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T1 item;

			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice1Of2(T1 item)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, >.Choice2Of2@DebugTypeProxy))]
		public class Choice2Of2 : FSharpChoice<T1, T2>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T2 item;

			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice2Of2(T2 item)
			{
				this.item = item;
			}
		}

		[SpecialName]
		internal class Choice1Of2@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice1Of2@DebugTypeProxy(Choice1Of2 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice2Of2@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice2Of2@DebugTypeProxy(Choice2Of2 obj)
			{
				_obj = obj;
			}
		}

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public int Tag
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return (this is Choice2Of2) ? 1 : 0;
			}
		}

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice1Of2
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return this is Choice1Of2;
			}
		}

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice2Of2
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return this is Choice2Of2;
			}
		}

		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, >))]
		[CompilerGenerated]
		[DebuggerNonUserCode]
		internal FSharpChoice()
		{
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 0)]
		public static FSharpChoice<T1, T2> NewChoice1Of2(T1 item)
		{
			return new Choice1Of2(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 1)]
		public static FSharpChoice<T1, T2> NewChoice2Of2(T2 item)
		{
			return new Choice2Of2(item);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(FSharpChoice<T1, T2> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int num = ((this is Choice2Of2) ? 1 : 0);
					int num2 = ((obj is Choice2Of2) ? 1 : 0);
					if (num == num2)
					{
						IComparer genericComparer;
						if (this is Choice1Of2)
						{
							Choice1Of2 choice1Of = (Choice1Of2)this;
							Choice1Of2 choice1Of2 = (Choice1Of2)obj;
							genericComparer = LanguagePrimitives.GenericComparer;
							T1 item = choice1Of.item;
							T1 item2 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item, item2);
						}
						Choice2Of2 choice2Of = (Choice2Of2)this;
						Choice2Of2 choice2Of2 = (Choice2Of2)obj;
						genericComparer = LanguagePrimitives.GenericComparer;
						T2 item3 = choice2Of.item;
						T2 item4 = choice2Of2.item;
						return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item3, item4);
					}
					return num - num2;
				}
				return 1;
			}
			if (obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj)
		{
			return CompareTo((FSharpChoice<T1, T2>)obj);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj, IComparer comp)
		{
			FSharpChoice<T1, T2> fSharpChoice = (FSharpChoice<T1, T2>)obj;
			if (this != null)
			{
				if ((FSharpChoice<T1, T2>)obj != null)
				{
					int num = ((this is Choice2Of2) ? 1 : 0);
					FSharpChoice<T1, T2> fSharpChoice2 = fSharpChoice;
					int num2 = ((fSharpChoice2 is Choice2Of2) ? 1 : 0);
					if (num == num2)
					{
						if (this is Choice1Of2)
						{
							Choice1Of2 choice1Of = (Choice1Of2)this;
							Choice1Of2 choice1Of2 = (Choice1Of2)fSharpChoice;
							T1 item = choice1Of.item;
							T1 item2 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item, item2);
						}
						Choice2Of2 choice2Of = (Choice2Of2)this;
						Choice2Of2 choice2Of2 = (Choice2Of2)fSharpChoice;
						T2 item3 = choice2Of.item;
						T2 item4 = choice2Of2.item;
						return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item3, item4);
					}
					return num - num2;
				}
				return 1;
			}
			if ((FSharpChoice<T1, T2>)obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				int num = 0;
				if (this is Choice1Of2)
				{
					Choice1Of2 choice1Of = (Choice1Of2)this;
					num = 0;
					T1 item = choice1Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item) + ((num << 6) + (num >> 2)));
				}
				Choice2Of2 choice2Of = (Choice2Of2)this;
				num = 1;
				T2 item2 = choice2Of.item;
				return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item2) + ((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 FSharpChoice<T1, T2> fSharpChoice)
				{
					int num = ((this is Choice2Of2) ? 1 : 0);
					FSharpChoice<T1, T2> fSharpChoice2 = fSharpChoice;
					int num2 = ((fSharpChoice2 is Choice2Of2) ? 1 : 0);
					if (num == num2)
					{
						if (this is Choice1Of2)
						{
							Choice1Of2 choice1Of = (Choice1Of2)this;
							Choice1Of2 choice1Of2 = (Choice1Of2)fSharpChoice;
							T1 item = choice1Of.item;
							T1 item2 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item, item2);
						}
						Choice2Of2 choice2Of = (Choice2Of2)this;
						Choice2Of2 choice2Of2 = (Choice2Of2)fSharpChoice;
						T2 item3 = choice2Of.item;
						T2 item4 = choice2Of2.item;
						return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item3, item4);
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public virtual sealed bool Equals(FSharpChoice<T1, T2> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int num = ((this is Choice2Of2) ? 1 : 0);
					int num2 = ((obj is Choice2Of2) ? 1 : 0);
					if (num == num2)
					{
						if (this is Choice1Of2)
						{
							Choice1Of2 choice1Of = (Choice1Of2)this;
							Choice1Of2 choice1Of2 = (Choice1Of2)obj;
							T1 item = choice1Of.item;
							T1 item2 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item, item2);
						}
						Choice2Of2 choice2Of = (Choice2Of2)this;
						Choice2Of2 choice2Of2 = (Choice2Of2)obj;
						T2 item3 = choice2Of.item;
						T2 item4 = choice2Of2.item;
						return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item3, item4);
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is FSharpChoice<T1, T2> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[StructuralEquality]
	[StructuralComparison]
	[CompiledName("FSharpChoice`3")]
	[CompilationMapping(SourceConstructFlags.SumType)]
	public abstract class FSharpChoice<T1, T2, T3> : IEquatable<FSharpChoice<T1, T2, T3>>, IStructuralEquatable, IComparable<FSharpChoice<T1, T2, T3>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Choice1Of3 = 0;

			public const int Choice2Of3 = 1;

			public const int Choice3Of3 = 2;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , >.Choice1Of3@DebugTypeProxy))]
		public class Choice1Of3 : FSharpChoice<T1, T2, T3>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T1 item;

			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice1Of3(T1 item)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , >.Choice2Of3@DebugTypeProxy))]
		public class Choice2Of3 : FSharpChoice<T1, T2, T3>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T2 item;

			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice2Of3(T2 item)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , >.Choice3Of3@DebugTypeProxy))]
		public class Choice3Of3 : FSharpChoice<T1, T2, T3>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T3 item;

			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice3Of3(T3 item)
			{
				this.item = item;
			}
		}

		[SpecialName]
		internal class Choice1Of3@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice1Of3@DebugTypeProxy(Choice1Of3 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice2Of3@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice2Of3@DebugTypeProxy(Choice2Of3 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice3Of3@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice3Of3@DebugTypeProxy(Choice3Of3 obj)
			{
				_obj = obj;
			}
		}

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

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice1Of3
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return this is Choice1Of3;
			}
		}

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice2Of3
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return this is Choice2Of3;
			}
		}

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice3Of3
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return this is Choice3Of3;
			}
		}

		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , >))]
		[CompilerGenerated]
		[DebuggerNonUserCode]
		internal FSharpChoice()
		{
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 0)]
		public static FSharpChoice<T1, T2, T3> NewChoice1Of3(T1 item)
		{
			return new Choice1Of3(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 1)]
		public static FSharpChoice<T1, T2, T3> NewChoice2Of3(T2 item)
		{
			return new Choice2Of3(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 2)]
		public static FSharpChoice<T1, T2, T3> NewChoice3Of3(T3 item)
		{
			return new Choice3Of3(item);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(FSharpChoice<T1, T2, T3> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int num = ((this is Choice3Of3) ? 2 : ((this is Choice2Of3) ? 1 : 0));
					int num2 = ((obj is Choice3Of3) ? 2 : ((obj is Choice2Of3) ? 1 : 0));
					if (num == num2)
					{
						IComparer genericComparer;
						if (!(this is Choice1Of3))
						{
							if (this is Choice2Of3)
							{
								Choice2Of3 choice2Of = (Choice2Of3)this;
								Choice2Of3 choice2Of2 = (Choice2Of3)obj;
								genericComparer = LanguagePrimitives.GenericComparer;
								T2 item = choice2Of.item;
								T2 item2 = choice2Of2.item;
								return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item, item2);
							}
							if (this is Choice3Of3)
							{
								Choice3Of3 choice3Of = (Choice3Of3)this;
								Choice3Of3 choice3Of2 = (Choice3Of3)obj;
								genericComparer = LanguagePrimitives.GenericComparer;
								T3 item3 = choice3Of.item;
								T3 item4 = choice3Of2.item;
								return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item3, item4);
							}
						}
						Choice1Of3 choice1Of = (Choice1Of3)this;
						Choice1Of3 choice1Of2 = (Choice1Of3)obj;
						genericComparer = LanguagePrimitives.GenericComparer;
						T1 item5 = choice1Of.item;
						T1 item6 = choice1Of2.item;
						return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item5, item6);
					}
					return num - num2;
				}
				return 1;
			}
			if (obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj)
		{
			return CompareTo((FSharpChoice<T1, T2, T3>)obj);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj, IComparer comp)
		{
			FSharpChoice<T1, T2, T3> fSharpChoice = (FSharpChoice<T1, T2, T3>)obj;
			if (this != null)
			{
				if ((FSharpChoice<T1, T2, T3>)obj != null)
				{
					int num = ((this is Choice3Of3) ? 2 : ((this is Choice2Of3) ? 1 : 0));
					FSharpChoice<T1, T2, T3> fSharpChoice2 = fSharpChoice;
					int num2 = ((fSharpChoice2 is Choice3Of3) ? 2 : ((fSharpChoice2 is Choice2Of3) ? 1 : 0));
					if (num == num2)
					{
						if (!(this is Choice1Of3))
						{
							if (this is Choice2Of3)
							{
								Choice2Of3 choice2Of = (Choice2Of3)this;
								Choice2Of3 choice2Of2 = (Choice2Of3)fSharpChoice;
								T2 item = choice2Of.item;
								T2 item2 = choice2Of2.item;
								return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item, item2);
							}
							if (this is Choice3Of3)
							{
								Choice3Of3 choice3Of = (Choice3Of3)this;
								Choice3Of3 choice3Of2 = (Choice3Of3)fSharpChoice;
								T3 item3 = choice3Of.item;
								T3 item4 = choice3Of2.item;
								return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item3, item4);
							}
						}
						Choice1Of3 choice1Of = (Choice1Of3)this;
						Choice1Of3 choice1Of2 = (Choice1Of3)fSharpChoice;
						T1 item5 = choice1Of.item;
						T1 item6 = choice1Of2.item;
						return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item5, item6);
					}
					return num - num2;
				}
				return 1;
			}
			if ((FSharpChoice<T1, T2, T3>)obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				int num = 0;
				if (!(this is Choice1Of3))
				{
					if (this is Choice2Of3)
					{
						Choice2Of3 choice2Of = (Choice2Of3)this;
						num = 1;
						T2 item = choice2Of.item;
						return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item) + ((num << 6) + (num >> 2)));
					}
					if (this is Choice3Of3)
					{
						Choice3Of3 choice3Of = (Choice3Of3)this;
						num = 2;
						T3 item2 = choice3Of.item;
						return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item2) + ((num << 6) + (num >> 2)));
					}
				}
				Choice1Of3 choice1Of = (Choice1Of3)this;
				num = 0;
				T1 item3 = choice1Of.item;
				return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item3) + ((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 FSharpChoice<T1, T2, T3> fSharpChoice)
				{
					int num = ((this is Choice3Of3) ? 2 : ((this is Choice2Of3) ? 1 : 0));
					FSharpChoice<T1, T2, T3> fSharpChoice2 = fSharpChoice;
					int num2 = ((fSharpChoice2 is Choice3Of3) ? 2 : ((fSharpChoice2 is Choice2Of3) ? 1 : 0));
					if (num == num2)
					{
						if (!(this is Choice1Of3))
						{
							if (this is Choice2Of3)
							{
								Choice2Of3 choice2Of = (Choice2Of3)this;
								Choice2Of3 choice2Of2 = (Choice2Of3)fSharpChoice;
								T2 item = choice2Of.item;
								T2 item2 = choice2Of2.item;
								return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item, item2);
							}
							if (this is Choice3Of3)
							{
								Choice3Of3 choice3Of = (Choice3Of3)this;
								Choice3Of3 choice3Of2 = (Choice3Of3)fSharpChoice;
								T3 item3 = choice3Of.item;
								T3 item4 = choice3Of2.item;
								return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item3, item4);
							}
						}
						Choice1Of3 choice1Of = (Choice1Of3)this;
						Choice1Of3 choice1Of2 = (Choice1Of3)fSharpChoice;
						T1 item5 = choice1Of.item;
						T1 item6 = choice1Of2.item;
						return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item5, item6);
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public virtual sealed bool Equals(FSharpChoice<T1, T2, T3> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int num = ((this is Choice3Of3) ? 2 : ((this is Choice2Of3) ? 1 : 0));
					int num2 = ((obj is Choice3Of3) ? 2 : ((obj is Choice2Of3) ? 1 : 0));
					if (num == num2)
					{
						if (!(this is Choice1Of3))
						{
							if (this is Choice2Of3)
							{
								Choice2Of3 choice2Of = (Choice2Of3)this;
								Choice2Of3 choice2Of2 = (Choice2Of3)obj;
								T2 item = choice2Of.item;
								T2 item2 = choice2Of2.item;
								return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item, item2);
							}
							if (this is Choice3Of3)
							{
								Choice3Of3 choice3Of = (Choice3Of3)this;
								Choice3Of3 choice3Of2 = (Choice3Of3)obj;
								T3 item3 = choice3Of.item;
								T3 item4 = choice3Of2.item;
								return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item3, item4);
							}
						}
						Choice1Of3 choice1Of = (Choice1Of3)this;
						Choice1Of3 choice1Of2 = (Choice1Of3)obj;
						T1 item5 = choice1Of.item;
						T1 item6 = choice1Of2.item;
						return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item5, item6);
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is FSharpChoice<T1, T2, T3> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[StructuralEquality]
	[StructuralComparison]
	[CompiledName("FSharpChoice`4")]
	[CompilationMapping(SourceConstructFlags.SumType)]
	public abstract class FSharpChoice<T1, T2, T3, T4> : IEquatable<FSharpChoice<T1, T2, T3, T4>>, IStructuralEquatable, IComparable<FSharpChoice<T1, T2, T3, T4>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Choice1Of4 = 0;

			public const int Choice2Of4 = 1;

			public const int Choice3Of4 = 2;

			public const int Choice4Of4 = 3;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , >.Choice1Of4@DebugTypeProxy))]
		public class Choice1Of4 : FSharpChoice<T1, T2, T3, T4>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T1 item;

			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice1Of4(T1 item)
				: base(0)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , >.Choice2Of4@DebugTypeProxy))]
		public class Choice2Of4 : FSharpChoice<T1, T2, T3, T4>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T2 item;

			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice2Of4(T2 item)
				: base(1)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , >.Choice3Of4@DebugTypeProxy))]
		public class Choice3Of4 : FSharpChoice<T1, T2, T3, T4>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T3 item;

			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice3Of4(T3 item)
				: base(2)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , >.Choice4Of4@DebugTypeProxy))]
		public class Choice4Of4 : FSharpChoice<T1, T2, T3, T4>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T4 item;

			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice4Of4(T4 item)
				: base(3)
			{
				this.item = item;
			}
		}

		[SpecialName]
		internal class Choice1Of4@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice1Of4@DebugTypeProxy(Choice1Of4 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice2Of4@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice2Of4@DebugTypeProxy(Choice2Of4 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice3Of4@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice3Of4@DebugTypeProxy(Choice3Of4 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice4Of4@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice4Of4@DebugTypeProxy(Choice4Of4 obj)
			{
				_obj = obj;
			}
		}

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

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

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

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

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

		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , >))]
		[CompilerGenerated]
		[DebuggerNonUserCode]
		internal FSharpChoice(int _tag)
		{
			this._tag = _tag;
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 0)]
		public static FSharpChoice<T1, T2, T3, T4> NewChoice1Of4(T1 item)
		{
			return new Choice1Of4(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 1)]
		public static FSharpChoice<T1, T2, T3, T4> NewChoice2Of4(T2 item)
		{
			return new Choice2Of4(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 2)]
		public static FSharpChoice<T1, T2, T3, T4> NewChoice3Of4(T3 item)
		{
			return new Choice3Of4(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 3)]
		public static FSharpChoice<T1, T2, T3, T4> NewChoice4Of4(T4 item)
		{
			return new Choice4Of4(item);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(FSharpChoice<T1, T2, T3, T4> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int tag = _tag;
					int tag2 = obj._tag;
					if (tag == tag2)
					{
						switch (Tag)
						{
						default:
						{
							Choice1Of4 choice1Of = (Choice1Of4)this;
							Choice1Of4 choice1Of2 = (Choice1Of4)obj;
							IComparer genericComparer = LanguagePrimitives.GenericComparer;
							T1 item7 = choice1Of.item;
							T1 item8 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item7, item8);
						}
						case 1:
						{
							Choice2Of4 choice2Of = (Choice2Of4)this;
							Choice2Of4 choice2Of2 = (Choice2Of4)obj;
							IComparer genericComparer = LanguagePrimitives.GenericComparer;
							T2 item5 = choice2Of.item;
							T2 item6 = choice2Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item5, item6);
						}
						case 2:
						{
							Choice3Of4 choice3Of = (Choice3Of4)this;
							Choice3Of4 choice3Of2 = (Choice3Of4)obj;
							IComparer genericComparer = LanguagePrimitives.GenericComparer;
							T3 item3 = choice3Of.item;
							T3 item4 = choice3Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item3, item4);
						}
						case 3:
						{
							Choice4Of4 choice4Of = (Choice4Of4)this;
							Choice4Of4 choice4Of2 = (Choice4Of4)obj;
							IComparer genericComparer = LanguagePrimitives.GenericComparer;
							T4 item = choice4Of.item;
							T4 item2 = choice4Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(genericComparer, item, item2);
						}
						}
					}
					return tag - tag2;
				}
				return 1;
			}
			if (obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj)
		{
			return CompareTo((FSharpChoice<T1, T2, T3, T4>)obj);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj, IComparer comp)
		{
			FSharpChoice<T1, T2, T3, T4> fSharpChoice = (FSharpChoice<T1, T2, T3, T4>)obj;
			if (this != null)
			{
				if ((FSharpChoice<T1, T2, T3, T4>)obj != null)
				{
					int tag = _tag;
					int tag2 = fSharpChoice._tag;
					if (tag == tag2)
					{
						switch (Tag)
						{
						default:
						{
							Choice1Of4 choice1Of = (Choice1Of4)this;
							Choice1Of4 choice1Of2 = (Choice1Of4)fSharpChoice;
							T1 item7 = choice1Of.item;
							T1 item8 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item7, item8);
						}
						case 1:
						{
							Choice2Of4 choice2Of = (Choice2Of4)this;
							Choice2Of4 choice2Of2 = (Choice2Of4)fSharpChoice;
							T2 item5 = choice2Of.item;
							T2 item6 = choice2Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item5, item6);
						}
						case 2:
						{
							Choice3Of4 choice3Of = (Choice3Of4)this;
							Choice3Of4 choice3Of2 = (Choice3Of4)fSharpChoice;
							T3 item3 = choice3Of.item;
							T3 item4 = choice3Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item3, item4);
						}
						case 3:
						{
							Choice4Of4 choice4Of = (Choice4Of4)this;
							Choice4Of4 choice4Of2 = (Choice4Of4)fSharpChoice;
							T4 item = choice4Of.item;
							T4 item2 = choice4Of2.item;
							return LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic(comp, item, item2);
						}
						}
					}
					return tag - tag2;
				}
				return 1;
			}
			if ((FSharpChoice<T1, T2, T3, T4>)obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				int num = 0;
				switch (Tag)
				{
				default:
				{
					Choice1Of4 choice1Of = (Choice1Of4)this;
					num = 0;
					T1 item4 = choice1Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item4) + ((num << 6) + (num >> 2)));
				}
				case 1:
				{
					Choice2Of4 choice2Of = (Choice2Of4)this;
					num = 1;
					T2 item3 = choice2Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item3) + ((num << 6) + (num >> 2)));
				}
				case 2:
				{
					Choice3Of4 choice3Of = (Choice3Of4)this;
					num = 2;
					T3 item2 = choice3Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item2) + ((num << 6) + (num >> 2)));
				}
				case 3:
				{
					Choice4Of4 choice4Of = (Choice4Of4)this;
					num = 3;
					T4 item = choice4Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, 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 FSharpChoice<T1, T2, T3, T4> fSharpChoice)
				{
					int tag = _tag;
					int tag2 = fSharpChoice._tag;
					if (tag == tag2)
					{
						switch (Tag)
						{
						default:
						{
							Choice1Of4 choice1Of = (Choice1Of4)this;
							Choice1Of4 choice1Of2 = (Choice1Of4)fSharpChoice;
							T1 item7 = choice1Of.item;
							T1 item8 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item7, item8);
						}
						case 1:
						{
							Choice2Of4 choice2Of = (Choice2Of4)this;
							Choice2Of4 choice2Of2 = (Choice2Of4)fSharpChoice;
							T2 item5 = choice2Of.item;
							T2 item6 = choice2Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item5, item6);
						}
						case 2:
						{
							Choice3Of4 choice3Of = (Choice3Of4)this;
							Choice3Of4 choice3Of2 = (Choice3Of4)fSharpChoice;
							T3 item3 = choice3Of.item;
							T3 item4 = choice3Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item3, item4);
						}
						case 3:
						{
							Choice4Of4 choice4Of = (Choice4Of4)this;
							Choice4Of4 choice4Of2 = (Choice4Of4)fSharpChoice;
							T4 item = choice4Of.item;
							T4 item2 = choice4Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic(comp, item, item2);
						}
						}
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public virtual sealed bool Equals(FSharpChoice<T1, T2, T3, T4> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int tag = _tag;
					int tag2 = obj._tag;
					if (tag == tag2)
					{
						switch (Tag)
						{
						default:
						{
							Choice1Of4 choice1Of = (Choice1Of4)this;
							Choice1Of4 choice1Of2 = (Choice1Of4)obj;
							T1 item7 = choice1Of.item;
							T1 item8 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item7, item8);
						}
						case 1:
						{
							Choice2Of4 choice2Of = (Choice2Of4)this;
							Choice2Of4 choice2Of2 = (Choice2Of4)obj;
							T2 item5 = choice2Of.item;
							T2 item6 = choice2Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item5, item6);
						}
						case 2:
						{
							Choice3Of4 choice3Of = (Choice3Of4)this;
							Choice3Of4 choice3Of2 = (Choice3Of4)obj;
							T3 item3 = choice3Of.item;
							T3 item4 = choice3Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item3, item4);
						}
						case 3:
						{
							Choice4Of4 choice4Of = (Choice4Of4)this;
							Choice4Of4 choice4Of2 = (Choice4Of4)obj;
							T4 item = choice4Of.item;
							T4 item2 = choice4Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item, item2);
						}
						}
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is FSharpChoice<T1, T2, T3, T4> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[StructuralEquality]
	[StructuralComparison]
	[CompiledName("FSharpChoice`5")]
	[CompilationMapping(SourceConstructFlags.SumType)]
	public abstract class FSharpChoice<T1, T2, T3, T4, T5> : IEquatable<FSharpChoice<T1, T2, T3, T4, T5>>, IStructuralEquatable, IComparable<FSharpChoice<T1, T2, T3, T4, T5>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Choice1Of5 = 0;

			public const int Choice2Of5 = 1;

			public const int Choice3Of5 = 2;

			public const int Choice4Of5 = 3;

			public const int Choice5Of5 = 4;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , >.Choice1Of5@DebugTypeProxy))]
		public class Choice1Of5 : FSharpChoice<T1, T2, T3, T4, T5>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T1 item;

			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice1Of5(T1 item)
				: base(0)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , >.Choice2Of5@DebugTypeProxy))]
		public class Choice2Of5 : FSharpChoice<T1, T2, T3, T4, T5>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T2 item;

			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice2Of5(T2 item)
				: base(1)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , >.Choice3Of5@DebugTypeProxy))]
		public class Choice3Of5 : FSharpChoice<T1, T2, T3, T4, T5>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T3 item;

			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice3Of5(T3 item)
				: base(2)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , >.Choice4Of5@DebugTypeProxy))]
		public class Choice4Of5 : FSharpChoice<T1, T2, T3, T4, T5>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T4 item;

			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice4Of5(T4 item)
				: base(3)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , >.Choice5Of5@DebugTypeProxy))]
		public class Choice5Of5 : FSharpChoice<T1, T2, T3, T4, T5>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T5 item;

			[CompilationMapping(SourceConstructFlags.Field, 4, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T5 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice5Of5(T5 item)
				: base(4)
			{
				this.item = item;
			}
		}

		[SpecialName]
		internal class Choice1Of5@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice1Of5@DebugTypeProxy(Choice1Of5 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice2Of5@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice2Of5@DebugTypeProxy(Choice2Of5 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice3Of5@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice3Of5@DebugTypeProxy(Choice3Of5 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice4Of5@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice4Of5@DebugTypeProxy(Choice4Of5 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice5Of5@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 4, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T5 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice5Of5@DebugTypeProxy(Choice5Of5 obj)
			{
				_obj = obj;
			}
		}

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

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

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

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

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

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice5Of5
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return Tag == 4;
			}
		}

		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , >))]
		[CompilerGenerated]
		[DebuggerNonUserCode]
		internal FSharpChoice(int _tag)
		{
			this._tag = _tag;
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 0)]
		public static FSharpChoice<T1, T2, T3, T4, T5> NewChoice1Of5(T1 item)
		{
			return new Choice1Of5(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 1)]
		public static FSharpChoice<T1, T2, T3, T4, T5> NewChoice2Of5(T2 item)
		{
			return new Choice2Of5(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 2)]
		public static FSharpChoice<T1, T2, T3, T4, T5> NewChoice3Of5(T3 item)
		{
			return new Choice3Of5(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 3)]
		public static FSharpChoice<T1, T2, T3, T4, T5> NewChoice4Of5(T4 item)
		{
			return new Choice4Of5(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 4)]
		public static FSharpChoice<T1, T2, T3, T4, T5> NewChoice5Of5(T5 item)
		{
			return new Choice5Of5(item);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(FSharpChoice<T1, T2, T3, T4, T5> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					return $Prim-types.CompareTo$cont@3583(this, obj, null);
				}
				return 1;
			}
			if (obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj)
		{
			return CompareTo((FSharpChoice<T1, T2, T3, T4, T5>)obj);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj, IComparer comp)
		{
			FSharpChoice<T1, T2, T3, T4, T5> objTemp = (FSharpChoice<T1, T2, T3, T4, T5>)obj;
			if (this != null)
			{
				return $Prim-types.CompareTo$cont@3583-1(comp, this, obj, objTemp, null);
			}
			if ((FSharpChoice<T1, T2, T3, T4, T5>)obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				int num = 0;
				switch (Tag)
				{
				default:
				{
					Choice1Of5 choice1Of = (Choice1Of5)this;
					num = 0;
					T1 item5 = choice1Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item5) + ((num << 6) + (num >> 2)));
				}
				case 1:
				{
					Choice2Of5 choice2Of = (Choice2Of5)this;
					num = 1;
					T2 item4 = choice2Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item4) + ((num << 6) + (num >> 2)));
				}
				case 2:
				{
					Choice3Of5 choice3Of = (Choice3Of5)this;
					num = 2;
					T3 item3 = choice3Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item3) + ((num << 6) + (num >> 2)));
				}
				case 3:
				{
					Choice4Of5 choice4Of = (Choice4Of5)this;
					num = 3;
					T4 item2 = choice4Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, item2) + ((num << 6) + (num >> 2)));
				}
				case 4:
				{
					Choice5Of5 choice5Of = (Choice5Of5)this;
					num = 4;
					T5 item = choice5Of.item;
					return -1640531527 + (LanguagePrimitives.HashCompare.GenericHashParamObj(comp, 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)
			{
				return $Prim-types.Equals$cont@3583(this, obj, comp, null);
			}
			return obj == null;
		}

		[CompilerGenerated]
		public virtual sealed bool Equals(FSharpChoice<T1, T2, T3, T4, T5> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int tag = _tag;
					int tag2 = obj._tag;
					if (tag == tag2)
					{
						switch (Tag)
						{
						default:
						{
							Choice1Of5 choice1Of = (Choice1Of5)this;
							Choice1Of5 choice1Of2 = (Choice1Of5)obj;
							T1 item9 = choice1Of.item;
							T1 item10 = choice1Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item9, item10);
						}
						case 1:
						{
							Choice2Of5 choice2Of = (Choice2Of5)this;
							Choice2Of5 choice2Of2 = (Choice2Of5)obj;
							T2 item7 = choice2Of.item;
							T2 item8 = choice2Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item7, item8);
						}
						case 2:
						{
							Choice3Of5 choice3Of = (Choice3Of5)this;
							Choice3Of5 choice3Of2 = (Choice3Of5)obj;
							T3 item5 = choice3Of.item;
							T3 item6 = choice3Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item5, item6);
						}
						case 3:
						{
							Choice4Of5 choice4Of = (Choice4Of5)this;
							Choice4Of5 choice4Of2 = (Choice4Of5)obj;
							T4 item3 = choice4Of.item;
							T4 item4 = choice4Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item3, item4);
						}
						case 4:
						{
							Choice5Of5 choice5Of = (Choice5Of5)this;
							Choice5Of5 choice5Of2 = (Choice5Of5)obj;
							T5 item = choice5Of.item;
							T5 item2 = choice5Of2.item;
							return LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic(item, item2);
						}
						}
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is FSharpChoice<T1, T2, T3, T4, T5> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[StructuralEquality]
	[StructuralComparison]
	[CompiledName("FSharpChoice`6")]
	[CompilationMapping(SourceConstructFlags.SumType)]
	public abstract class FSharpChoice<T1, T2, T3, T4, T5, T6> : IEquatable<FSharpChoice<T1, T2, T3, T4, T5, T6>>, IStructuralEquatable, IComparable<FSharpChoice<T1, T2, T3, T4, T5, T6>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Choice1Of6 = 0;

			public const int Choice2Of6 = 1;

			public const int Choice3Of6 = 2;

			public const int Choice4Of6 = 3;

			public const int Choice5Of6 = 4;

			public const int Choice6Of6 = 5;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , >.Choice1Of6@DebugTypeProxy))]
		public class Choice1Of6 : FSharpChoice<T1, T2, T3, T4, T5, T6>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T1 item;

			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice1Of6(T1 item)
				: base(0)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , >.Choice2Of6@DebugTypeProxy))]
		public class Choice2Of6 : FSharpChoice<T1, T2, T3, T4, T5, T6>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T2 item;

			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice2Of6(T2 item)
				: base(1)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , >.Choice3Of6@DebugTypeProxy))]
		public class Choice3Of6 : FSharpChoice<T1, T2, T3, T4, T5, T6>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T3 item;

			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice3Of6(T3 item)
				: base(2)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , >.Choice4Of6@DebugTypeProxy))]
		public class Choice4Of6 : FSharpChoice<T1, T2, T3, T4, T5, T6>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T4 item;

			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice4Of6(T4 item)
				: base(3)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , >.Choice5Of6@DebugTypeProxy))]
		public class Choice5Of6 : FSharpChoice<T1, T2, T3, T4, T5, T6>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T5 item;

			[CompilationMapping(SourceConstructFlags.Field, 4, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T5 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice5Of6(T5 item)
				: base(4)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , >.Choice6Of6@DebugTypeProxy))]
		public class Choice6Of6 : FSharpChoice<T1, T2, T3, T4, T5, T6>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T6 item;

			[CompilationMapping(SourceConstructFlags.Field, 5, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T6 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice6Of6(T6 item)
				: base(5)
			{
				this.item = item;
			}
		}

		[SpecialName]
		internal class Choice1Of6@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice1Of6@DebugTypeProxy(Choice1Of6 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice2Of6@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice2Of6@DebugTypeProxy(Choice2Of6 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice3Of6@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice3Of6@DebugTypeProxy(Choice3Of6 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice4Of6@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice4Of6@DebugTypeProxy(Choice4Of6 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice5Of6@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 4, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T5 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice5Of6@DebugTypeProxy(Choice5Of6 obj)
			{
				_obj = obj;
			}
		}

		[SpecialName]
		internal class Choice6Of6@DebugTypeProxy
		{
			[CompilationMapping(SourceConstructFlags.Field, 5, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T6 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return _obj.item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public Choice6Of6@DebugTypeProxy(Choice6Of6 obj)
			{
				_obj = obj;
			}
		}

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

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

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

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

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

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice5Of6
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return Tag == 4;
			}
		}

		[CompilerGenerated]
		[DebuggerNonUserCode]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsChoice6Of6
		{
			[CompilerGenerated]
			[DebuggerNonUserCode]
			get
			{
				return Tag == 5;
			}
		}

		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , >))]
		[CompilerGenerated]
		[DebuggerNonUserCode]
		internal FSharpChoice(int _tag)
		{
			this._tag = _tag;
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 0)]
		public static FSharpChoice<T1, T2, T3, T4, T5, T6> NewChoice1Of6(T1 item)
		{
			return new Choice1Of6(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 1)]
		public static FSharpChoice<T1, T2, T3, T4, T5, T6> NewChoice2Of6(T2 item)
		{
			return new Choice2Of6(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 2)]
		public static FSharpChoice<T1, T2, T3, T4, T5, T6> NewChoice3Of6(T3 item)
		{
			return new Choice3Of6(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 3)]
		public static FSharpChoice<T1, T2, T3, T4, T5, T6> NewChoice4Of6(T4 item)
		{
			return new Choice4Of6(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 4)]
		public static FSharpChoice<T1, T2, T3, T4, T5, T6> NewChoice5Of6(T5 item)
		{
			return new Choice5Of6(item);
		}

		[CompilationMapping(SourceConstructFlags.UnionCase, 5)]
		public static FSharpChoice<T1, T2, T3, T4, T5, T6> NewChoice6Of6(T6 item)
		{
			return new Choice6Of6(item);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(FSharpChoice<T1, T2, T3, T4, T5, T6> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int tag = _tag;
					int tag2 = obj._tag;
					if (tag == tag2)
					{
						return $Prim-types.CompareTo$cont@3592-2(this, obj, null);
					}
					return tag - tag2;
				}
				return 1;
			}
			if (obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj)
		{
			return CompareTo((FSharpChoice<T1, T2, T3, T4, T5, T6>)obj);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj, IComparer comp)
		{
			FSharpChoice<T1, T2, T3, T4, T5, T6> objTemp = (FSharpChoice<T1, T2, T3, T4, T5, T6>)obj;
			if (this != null)
			{
				if ((FSharpChoice<T1, T2, T3, T4, T5, T6>)obj != null)
				{
					return $Prim-types.CompareTo$cont@3592-3(comp, this, objTemp, null);
				}
				return 1;
			}
			if ((FSharpChoice<T1, T2, T3, T4, T5, T6>)obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				return $Prim-types.GetHashCode$cont@3592(comp, this, null);
			}
			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 FSharpChoice<T1, T2, T3, T4, T5, T6> that)
				{
					return $Prim-types.Equals$cont@3592-1(this, that, comp, null);
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public virtual sealed bool Equals(FSharpChoice<T1, T2, T3, T4, T5, T6> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					return $Prim-types.Equals$cont@3592-2(this, obj, null);
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is FSharpChoice<T1, T2, T3, T4, T5, T6> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[StructuralEquality]
	[StructuralComparison]
	[CompiledName("FSharpChoice`7")]
	[CompilationMapping(SourceConstructFlags.SumType)]
	public abstract class FSharpChoice<T1, T2, T3, T4, T5, T6, T7> : IEquatable<FSharpChoice<T1, T2, T3, T4, T5, T6, T7>>, IStructuralEquatable, IComparable<FSharpChoice<T1, T2, T3, T4, T5, T6, T7>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Choice1Of7 = 0;

			public const int Choice2Of7 = 1;

			public const int Choice3Of7 = 2;

			public const int Choice4Of7 = 3;

			public const int Choice5Of7 = 4;

			public const int Choice6Of7 = 5;

			public const int Choice7Of7 = 6;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , , >.Choice1Of7@DebugTypeProxy))]
		public class Choice1Of7 : FSharpChoice<T1, T2, T3, T4, T5, T6, T7>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T1 item;

			[CompilationMapping(SourceConstructFlags.Field, 0, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T1 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice1Of7(T1 item)
				: base(0)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , , >.Choice2Of7@DebugTypeProxy))]
		public class Choice2Of7 : FSharpChoice<T1, T2, T3, T4, T5, T6, T7>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T2 item;

			[CompilationMapping(SourceConstructFlags.Field, 1, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T2 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice2Of7(T2 item)
				: base(1)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , , >.Choice3Of7@DebugTypeProxy))]
		public class Choice3Of7 : FSharpChoice<T1, T2, T3, T4, T5, T6, T7>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T3 item;

			[CompilationMapping(SourceConstructFlags.Field, 2, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T3 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice3Of7(T3 item)
				: base(2)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , , >.Choice4Of7@DebugTypeProxy))]
		public class Choice4Of7 : FSharpChoice<T1, T2, T3, T4, T5, T6, T7>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T4 item;

			[CompilationMapping(SourceConstructFlags.Field, 3, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T4 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(FSharpChoice<, , , , , , >))]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Choice4Of7(T4 item)
				: base(3)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(FSharpChoice<, , , , , , >.Choice5Of7@DebugTypeProxy))]
		public class Choice5Of7 : FSharpChoice<T1, T2, T3, T4, T5, T6, T7>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly T5 item;

			[CompilationMapping(SourceConstructFlags.Field, 4, 0)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public T5 Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonP